@agfpd/iapeer 0.4.131 → 0.4.133

package/docs/08-peer-management.md

@@ -53,7 +53,7 @@ iapeer verify          # report divergences
 iapeer verify --fix    # repair
 ```
 
-`verify` checks three things: profiles' conformance to the standard, divergences between the registry and the local profiles, and **MCP parity across a peer's agent runtimes** — a server declared for one runtime of the peer and missing for another is an error naming the peer, the server and both sides (`✗ p: MCP server "x" is in [codex] but MISSING in [claude]`). Peer-level sources: claude `.mcp.json`, codex `<cwd>/.codex/config.toml`, opencode host-default + per-peer `opencode.json` + fragments; the core `iapeer` server is excluded (wired on every runtime by construction). `--fix` does not copy MCP servers between runtimes — their configs differ in form; the report says what to add where. With `--fix` the command self-heals the registry from the profiles (and migrates profiles from the old runtime-field format to the current one along the way). It's the standard way to put the registry in order if it's gone out of sync.
+`verify` checks three things: profiles' conformance to the standard, divergences between the registry and the local profiles, and **MCP parity across a peer's agent runtimes** — a server declared for one runtime of the peer and missing for another is an error naming the peer, the server and both sides (`✗ p: MCP server "x" is in [codex] but MISSING in [claude]`). It compares what each runtime ACTUALLY sees at launch: claude `.mcp.json` + servers of enabled plugins; codex `<cwd>/.codex/config.toml` + servers of enabled codex plugins (host `~/.codex/config.toml`, overridden by the peer's); opencode host-default + per-peer `opencode.json` + the core's peer-MCP projection + fragments. A server that only a HOST-wide plugin supplies counts as present (it satisfies a declaration on another runtime — voice-connect's server reaches codex through the host plugin) but is never reported on its own: that is a host decision, not peer drift. The core `iapeer` server is excluded. `--fix` re-projects every opencode endpoint's MCP set from the peer's claude/codex declarations (docs/20 §Peer MCP) — claude and codex sources are never edited; a claude↔codex gap is still only reported (their owners align them). With `--fix` the command self-heals the registry from the profiles (and migrates profiles from the old runtime-field format to the current one along the way). It's the standard way to put the registry in order if it's gone out of sync.
 
 **The daemon reconciles continuously (0.4.104).** The local `peer-profile.json` is the source of truth and the registry only its projection — but until 0.4.104 a direct edit of the source (the owner's legitimate move) propagated only when some reindexing verb happened to run afterwards; the router reads the INDEX per-request, so a stale projection mis-routed deliveries (measured live 17.07.2026: a peer's local profile said `default_runtime: claude` for days while the index kept `codex`, and deliveries went to a mute codex session). The daemon now runs a profile-sync sweep (`daemon/profilesync.ts`, 60 s, mtime/set-gated — steady state is stats only, zero writes): any change to a registered peer's local profile triggers the same locked `reindexFromLocals` the verbs use, and a boot sweep heals drift accumulated while the daemon was down. Heals are logged to `lifecycle.log` as `profile-reindex` events. `verify` remains the read-only report and the manual lever; the daemon closes the propagation gap.
 

package/docs/20-opencode.md

@@ -123,6 +123,30 @@ Open core contracts this ABI depends on:
   provision/unprovision per peer and runtime, like the memory slot. Until it
   exists, a manual install is not reported as final.
 
+## Peer MCP — OpenCode sees the same servers as the peer's other runtimes
+
+Invariant (18.10.2026): after `add-runtime opencode` the peer on OpenCode has the same MCP set as on
+claude/codex, and `verify` is clean with no hand edit. The source of truth stays the peer's own
+declarations — claude `.mcp.json` + plugins enabled in the peer's `.claude/settings*.json`, codex
+`<cwd>/.codex/config.toml` `[mcp_servers]` + plugins enabled in the peer's codex config
+(`src/mcp/peerServers.ts`). OpenCode gets a core-owned **projection** in
+`<private dir>/peer-mcp.json` (0600 — env carries the servers' own secrets, as the sources do):
+
+- claude stdio `{command,args,env}` / codex `command,args,env` → `{type:"local", command:[…],
+  environment, enabled:true, timeout:30000}` (a first `npx -y` start blows OpenCode's 5 s default);
+- claude `http|sse` `{url,headers}` / codex `url, http_headers, env_http_headers,
+  bearer_token_env_var` → `{type:"remote", url, headers, enabled:true, oauth:false}`;
+- `${VAR}` / `${VAR:-default}` → `{env:VAR}` (OpenCode has no default syntax — the default is
+  dropped); `${CLAUDE_PLUGIN_ROOT}` → the plugin's install root.
+
+Regenerated on `add-runtime opencode`, on every OpenCode launch (follows its sources — a server added
+later reaches OpenCode on the next launch) and by `verify --fix` (one-shot alignment). Merged in
+`composeOpencodeConfig` right after the host default and BEFORE the peer's `opencode.json`, so an
+operator entry always wins. Not projected: the core `iapeer`; any name another OpenCode source
+already supplies (host default, peer config, memory/capability fragments — a deep merge of two
+definitions would mix their fields); servers a HOST-wide plugin gives every peer of one runtime
+(host decision, not the peer's). A live OpenCode session keeps its tools until its next launch.
+
 ## Launch self-check (OC04)
 
 OpenCode tolerates some broken surfaces silently: a fragment plugin whose file
@@ -188,16 +212,23 @@ process was SIGKILLed before any answer, and the fresh next session never saw it
   session is gone or was replaced become orphans and are redelivered through the
   normal route as their original sender, prefixed `[redelivered by iapeer: …]`
   (wake-on-miss and the crash-loop guard apply). If redelivery fails, the sender
-  receives an explicit notice from `iapeer`. Logged as `ev=inflight-orphaned`
+  receives an explicit notice from the core identity `iapeer-system`. Logged as `ev=inflight-orphaned`
   (lifecycle.log) and `ev=inflight-redelivered|inflight-undelivered`
   (delivery.log).
 - A false «not processed» costs a visible duplicate, never a silent loss.
 - Interrupted turns. «Processed» (a model response began) is not «finished»: a
   turn killed mid-tool may already have had side effects, so it is never
   redelivered. The ledger keeps an entry until its turn finishes (claude: an
-  assistant record with a terminal `stop_reason`; codex: `task_complete`;
-  opencode: a completed assistant message for it with a finish other than
-  `tool-calls`); a finished later message covers earlier ones. If the session
+  assistant record with a terminal `stop_reason`, or claude's own interrupt
+  marker `[Request interrupted by user…]`; codex: `task_complete` or
+  `turn_aborted`; opencode: a completed assistant message for it with a finish
+  other than `tool-calls`); a finished later message covers earlier ones. An
+  operator interrupt is a finished turn, not a death (18.10: a turn the owner had
+  stopped was reported «INTERRUPTED» when the session later died for another
+  reason). A session that ends ITSELF (`self-fresh`) leaves a `<identity>.self-ended`
+  marker with its hosting token; the daemon's sweep settles that session's started
+  entries silently instead of notifying their senders (the peer declared the work
+  done); not-yet-started entries are redelivered to the fresh session as usual. If the session
   dies with the turn unfinished, the sender gets an explicit notice from iapeer
   («the turn was INTERRUPTED and its result is not guaranteed»), logged as
   `ev=inflight-interrupted`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.131",
+  "version": "0.4.133",
   "description": "Run Claude Code and Codex CLI as local background agents that message each other, wake on demand, and share one memory.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/cli/index.ts

@@ -482,6 +482,13 @@ export async function addRuntime(
       const warns: string[] = []
       const repair = p.runtimes.includes(runtime as Runtime)
       await initPeer({ cwd: p.cwd, runtime: runtime as Runtime, env: cleanEnv, warn: m => warns.push(m) })
+      // OpenCode inherits the peer's MCP set from its claude/codex declarations (+ enabled plugins) —
+      // the same set, verify-clean, no hand edit (docs/20 §Peer MCP).
+      if (runtime === 'opencode') {
+        const { syncOpencodePeerMcp } = await import('../opencode/peerMcp.ts')
+        const r = syncOpencodePeerMcp(p.personality, p.cwd, [...p.runtimes, 'opencode'], { env: cleanEnv })
+        if (r.projected.length) warns.push(`MCP projected: ${r.projected.join(', ')}`)
+      }
       out.push({
         personality: p.personality,
         action: 'added',
@@ -2354,6 +2361,21 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         // MCP parity across the peer's agent runtimes: a server on one endpoint and missing on another
         // leaves the SAME peer silently weaker there (incident 17.10 — domain MCPs only in codex config).
         const { mcpParity } = await import('../verify/mcpParity.ts')
+        // --fix: re-project every OpenCode endpoint's peer MCP from its claude/codex sources FIRST, so
+        // the parity report below is the post-fix truth (the one-shot alignment of peers whose opencode
+        // runtime predates the projection — boris 18.10). Sources are never edited.
+        if (flags.fix === true) {
+          const { syncOpencodePeerMcp } = await import('../opencode/peerMcp.ts')
+          for (const peer of index.peers) {
+            if (!peer.runtimes.includes('opencode')) continue
+            try {
+              const r = syncOpencodePeerMcp(peer.personality, peer.cwd, peer.runtimes, { env })
+              if (r.changed) out(`opencode MCP projected for ${peer.personality}: [${r.projected.join(', ')}] (takes effect on the next opencode launch)\n`)
+            } catch (e) {
+              errOut(`opencode MCP projection failed for ${peer.personality}: ${e instanceof Error ? e.message : String(e)}\n`)
+            }
+          }
+        }
         let mcpDrift = 0
         for (const peer of index.peers) {
           for (const issue of mcpParity(peer.personality, peer.cwd, peer.runtimes, { env })) {
@@ -2984,6 +3006,16 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         // see a dead session with no .new-eager → a plain reaped-gone (lazy fresh on the
         // next message), not the eager relaunch — degrade gracefully, never lose the mark.
         setNewEager(cfg, identity)
+        // The peer ends ITS OWN turn: tell the daemon's OC07 sweep this session ended itself, so the
+        // entries it had started are settled — not reported to their senders as INTERRUPTED.
+        try {
+          const { hostSessionToken } = await import('../launch/ptyHost.ts')
+          const { markSelfEnded } = await import('../lifecycle/inflight.ts')
+          const token = hostSessionToken(identity, env)
+          if (token) markSelfEnded(cfg.stateDir, identity, token)
+        } catch {
+          /* best-effort: without it the sender merely gets a false INTERRUPTED notice */
+        }
         out(`self-fresh: marked ${identity} for eager fresh re-launch; self-killing session\n`)
         const sock = buildSocketPath(addr.runtime, addr.personality, cfg.sockDir)
         killSession(sock, identity, env)

package/src/daemon/main.ts

@@ -81,7 +81,7 @@ import { startGoalWatch } from './goalwatch.ts'
 import { ActivityBoard, startTurnWatch } from './turnwatch.ts'
 import { defaultDaemonSocketPath, startDaemon, type DaemonHandle } from './index.ts'
 import { randomBytes } from 'crypto'
-import { listInflightIdentities, listInterruptedIdentities, listOrphanIdentities, recordInflight, sweepInflight, takeInterrupted, takeOrphans, type InflightEntry } from '../lifecycle/inflight.ts'
+import { clearSelfEnded, listInflightIdentities, listInterruptedIdentities, listOrphanIdentities, readSelfEnded, recordInflight, sweepInflight, takeInterrupted, takeOrphans, type InflightEntry } from '../lifecycle/inflight.ts'
 import { hostSessionAlive, hostSessionToken } from '../launch/ptyHost.ts'
 
 /** Default TCP loopback port for the always-on router. Real http MCP clients
@@ -321,13 +321,17 @@ export async function processInflight(
     }
   }
   for (const identity of listInflightIdentities(cfg.stateDir)) {
+    const selfEnded = readSelfEnded(cfg.stateDir, identity)
+    const current = hostSessionAlive(identity, env) ? hostSessionToken(identity, env) : null
     const n = sweepInflight(cfg.stateDir, identity, {
-      sessionToken: id => (hostSessionAlive(id, env) ? hostSessionToken(id, env) : null),
+      sessionToken: () => current,
+      selfEndedToken: selfEnded,
       processed,
       completed: seam.completed ?? ((e: InflightEntry) => deliveryCompleted(e, env)),
       landed: seam.landed ?? ((e: InflightEntry) => deliveryLanded(e, env)),
     })
     if (n > 0) appendLifecycleEvent(cfg.eventLogDir, { ev: 'inflight-orphaned', identity, count: n }, { env })
+    if (selfEnded && current !== selfEnded) clearSelfEnded(cfg.stateDir, identity) // that session is gone — settled
   }
   // A turn the session STARTED on a message but did not finish before dying: never redelivered (its side
   // effects may already have happened) — the sender is told explicitly that the result is not guaranteed.

package/src/launch/adapters/opencode.ts

@@ -21,6 +21,8 @@ import { randomBytes } from 'node:crypto'
 import { existsSync, readFileSync, statSync } from 'node:fs'
 import { composeOpencodeConfig, hasExplicitModel, OPENCODE_AGENT, OPENCODE_PLUGIN_SOURCE, opencodePaths, writeOpencodePlugin } from '../../opencode/config.ts'
 import { opencodeControl } from '../../opencode/control.ts'
+import { syncOpencodePeerMcp } from '../../opencode/peerMcp.ts'
+import { findPeer, readPeersIndex } from '../../registry/index.ts'
 import { fileMtimeMs, readJournalFrom, readOpencodeState } from '../../opencode/journal.ts'
 import { resolveDaemonMcpUrl } from '../../storage/index.ts'
 import { resolveFleetBase } from '../../approval/brokerClient.ts'
@@ -80,6 +82,15 @@ export const opencodeAdapter: RuntimeAdapter = {
     const doctrine = readFileSync(spec.systemPromptFile, 'utf8')
     const p = paths(spec.personality, env)
     writeOpencodePlugin(spec.personality, OPENCODE_PLUGIN_SOURCE, { env })
+    // Re-project the peer's claude/codex MCP servers on every launch: the projection follows its
+    // sources (a server added to .mcp.json later reaches OpenCode on the next launch, no drift).
+    // Best-effort — a malformed source must not block the launch (verify reports the gap).
+    try {
+      const rec = findPeer(readPeersIndex({ env }), spec.personality)
+      syncOpencodePeerMcp(spec.personality, spec.cwd, rec?.runtimes ?? ['opencode'], { env })
+    } catch {
+      /* verify surfaces any resulting MCP gap */
+    }
     const config = composeOpencodeConfig(
       {
         personality: spec.personality,

package/src/lifecycle/index.ts

@@ -1652,17 +1652,38 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
 export async function processEagerRelaunches(
   cfg: LifecycleConfig,
   outcomes: SuperviseOutcome[],
-  deps: WakeDeps & { wakeFn?: (args: WakeArgs, deps: WakeDeps) => Promise<WakeResult> } = {},
+  deps: WakeDeps & { wakeFn?: (args: WakeArgs, deps: WakeDeps) => Promise<WakeResult>; sessionAliveFn?: (identity: string) => boolean } = {},
 ): Promise<WakeResult[]> {
   const wake = deps.wakeFn ?? wakeOrSpawn
+  const env = deps.env ?? process.env
+  const alive = deps.sessionAliveFn ?? ((identity: string) => sessionAlive('', identity, env))
   const results: WakeResult[] = []
-  for (const o of outcomes) {
-    if (o.action !== 'needs-eager-fresh' || !o.personality) continue
+  const eager = outcomes.filter(o => o.action === 'needs-eager-fresh' && !!o.personality)
+  for (const o of eager) {
     clearNewEager(cfg, o.identity) // consume the eager mark — the relaunch is fresh by construction
+    // WHICH endpoint comes back. Two invariants meet here:
+    //  • H5 fleet-switch (12.06): a peer whose ONLY session self-freshes after `default-runtime` was
+    //    flipped must come back on the NEW default → re-resolve (no runtime pinned).
+    //  • Parallel endpoints (18.10): a peer live on several runtimes at once whose NON-default
+    //    endpoint self-freshes must get THAT endpoint back — re-resolving woke the default (already
+    //    live → no-op) and the claude endpoint of oc-test-nemo lay down.
+    // So: pin the dead endpoint's runtime when it is the default, or when the peer keeps another
+    // session (live now, or relaunched in this same batch); otherwise it was the peer's only
+    // session → re-resolve to the registry default.
+    let runtime: string | undefined
+    try {
+      const rec = findPeer(readPeersIndex({ env }), o.personality!)
+      const others = (rec?.runtimes ?? []).filter(rt => rt !== o.runtime)
+      const otherAlive = others.some(rt => alive(`${rt}-${o.personality}`))
+      const otherInBatch = eager.some(x => x !== o && x.personality === o.personality)
+      if (o.runtime && (o.runtime === rec?.runtime || otherAlive || otherInBatch)) runtime = o.runtime
+    } catch {
+      runtime = undefined // registry unreadable → the H5 default path
+    }
     try {
       results.push(
         await wake(
-          { personality: o.personality, task: '', resume: false },
+          { personality: o.personality!, ...(runtime ? { runtime } : {}), task: '', resume: false },
           { cfg, env: deps.env },
         ),
       )

package/src/lifecycle/inflight.ts

@@ -87,6 +87,9 @@ export function readInflight(stateDir: string, identity: string): InflightEntry[
 }
 
 export interface InflightSweepDeps {
+  /** Hosting token of a session that ENDED ITSELF (self-fresh) — its started entries are settled, not
+   *  reported interrupted. Absent → none. */
+  selfEndedToken?: string | null
   /** Current hosting token of the identity's session (null = no live session). */
   sessionToken: (identity: string) => string | null
   /** Did the receiving session answer this entry? */
@@ -138,6 +141,7 @@ export function sweepInflight(stateDir: string, identity: string, deps: Inflight
       // Answered but its turn did not finish: live → still working; gone → INTERRUPTED (side effects
       // may have happened — never redelivered, the sender is told).
       if (current !== null && current === e.sessionToken) keep.push(e)
+      else if (deps.selfEndedToken && e.sessionToken === deps.selfEndedToken) continue // the peer ended it itself
       else interrupted.push(e)
       continue
     }
@@ -207,3 +211,29 @@ export function purgeInflight(stateDir: string, identity: string): void {
   rmSync(orphansPath(stateDir, identity), { force: true })
   rmSync(interruptedPath(stateDir, identity), { force: true })
 }
+
+
+const selfEndedPath = (stateDir: string, identity: string) => join(stateDir, `${identity}.self-ended`)
+
+/**
+ * self-fresh: the peer's OWN turn declares its work done and ends its session. The CLI only drops this
+ * marker (the hosting token of the session that chose to end); the DAEMON's sweep — the single writer
+ * of the ledger — then closes that session's started entries instead of reporting them INTERRUPTED
+ * (false: the peer itself ended; live parity run 18.10). Not-yet-started entries are untouched and are
+ * redelivered to the fresh session as usual. No read-modify-write of the ledger outside the daemon.
+ */
+export function markSelfEnded(stateDir: string, identity: string, sessionToken: string): void {
+  writeFileSync(selfEndedPath(stateDir, identity), `${sessionToken}\n`, { mode: 0o600 })
+}
+
+export function readSelfEnded(stateDir: string, identity: string): string | null {
+  try {
+    return readFileSync(selfEndedPath(stateDir, identity), 'utf8').trim() || null
+  } catch {
+    return null
+  }
+}
+
+export function clearSelfEnded(stateDir: string, identity: string): void {
+  rmSync(selfEndedPath(stateDir, identity), { force: true })
+}

package/src/mcp/peerServers.ts

@@ -0,0 +1,236 @@
+// The MCP servers a peer's runtime ACTUALLY sees at launch — the peer's own declarations PLUS the
+// servers its enabled plugins bring (boris 18.10: verify read only <cwd>/.codex/config.toml, so
+// voice-connect, whose server reaches codex through the enabled host plugin voice-connect@agfpd,
+// was a false ✗ — and a false ✗ is worse than no check: owners start duplicating servers).
+//
+// Normalized to one shape so the two consumers agree by construction:
+//   • verify's MCP parity compares the NAMES per runtime;
+//   • add-runtime / launch / `verify --fix` project the SPECS into OpenCode (docs/20 §Peer MCP).
+//
+// Sources (read-only; nothing here writes):
+//   claude — <cwd>/.mcp.json `mcpServers`; plugins enabled in ~/.claude/settings.json,
+//            <cwd>/.claude/settings.json, <cwd>/.claude/settings.local.json (`enabledPlugins`,
+//            later wins), installed per ~/.claude/plugins/installed_plugins.json (fallback: newest
+//            ~/.claude/plugins/cache/<market>/<name>/<version>); servers from the plugin's
+//            .claude-plugin/plugin.json `mcpServers` (object or relative path) else <root>/.mcp.json.
+//            `${CLAUDE_PLUGIN_ROOT}` resolves to the plugin root.
+//   codex  — <cwd>/.codex/config.toml `[mcp_servers.*]`; plugins `[plugins."<name>@<market>"]
+//            enabled` in $CODEX_HOME/config.toml, overridden by the peer's own config; installed at
+//            $CODEX_HOME/plugins/cache/<market>/<name>/<newest version>/; servers from
+//            .codex-plugin/plugin.json `mcpServers` else <root>/.mcp.json.
+// `codex mcp list` would be the authoritative read, but it was measured to hang > 2 min on this
+// host — unusable inside verify. The same files it reads are read here instead.
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { isAbsolute, join, resolve } from 'node:path'
+
+/** `peer` — declared by the peer itself (its own files, or a plugin enabled in the peer's own
+ *  settings); `host` — reaches every peer of that runtime through a HOST-wide plugin enable. A host
+ *  server is real for the runtime (it satisfies a peer declaration) but is not a fact about the
+ *  peer: its absence on another runtime is a host decision, not peer drift, and it is not projected. */
+export type McpScope = 'peer' | 'host'
+
+export type McpSpec = { scope: McpScope } & (
+  | { kind: 'local'; command: string; args: string[]; env: Record<string, string>; source: string }
+  | { kind: 'remote'; url: string; headers: Record<string, string>; source: string }
+)
+
+type Obj = Record<string, unknown>
+
+function readJson(path: string): Obj | null {
+  try {
+    const v = JSON.parse(readFileSync(path, 'utf8'))
+    return v && typeof v === 'object' && !Array.isArray(v) ? (v as Obj) : null
+  } catch {
+    return null
+  }
+}
+
+function readToml(path: string): Obj | null {
+  try {
+    return Bun.TOML.parse(readFileSync(path, 'utf8')) as Obj
+  } catch {
+    return null
+  }
+}
+
+function strMap(v: unknown): Record<string, string> {
+  const out: Record<string, string> = {}
+  if (v && typeof v === 'object' && !Array.isArray(v)) for (const [k, x] of Object.entries(v)) if (typeof x === 'string' || typeof x === 'number') out[k] = String(x)
+  return out
+}
+
+/** A claude-style `${VAR}` / `${VAR:-default}` reference → OpenCode's `{env:VAR}`. The default is
+ *  dropped (OpenCode has no default syntax) — the caller records it as a lossy conversion. */
+export function claudeVarsToOpencode(s: string, pluginRoot?: string): string {
+  let out = pluginRoot ? s.replaceAll('${CLAUDE_PLUGIN_ROOT}', pluginRoot) : s
+  out = out.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-[^}]*)?\}/g, (_m, v: string) => `{env:${v}}`)
+  return out
+}
+
+/** One claude `.mcp.json` server entry → spec. */
+export function specFromClaude(entry: unknown, source: string, pluginRoot?: string, scope: McpScope = 'peer'): McpSpec | null {
+  if (!entry || typeof entry !== 'object') return null
+  const e = entry as Obj
+  const sub = (s: string): string => claudeVarsToOpencode(s, pluginRoot)
+  if (typeof e.url === 'string' || e.type === 'http' || e.type === 'sse') {
+    if (typeof e.url !== 'string') return null
+    const headers = strMap(e.headers)
+    for (const k of Object.keys(headers)) headers[k] = sub(headers[k]!)
+    return { scope, kind: 'remote', url: sub(e.url), headers, source }
+  }
+  if (typeof e.command !== 'string' || !e.command) return null
+  const env = strMap(e.env)
+  for (const k of Object.keys(env)) env[k] = sub(env[k]!)
+  return { scope, kind: 'local', command: sub(e.command), args: Array.isArray(e.args) ? e.args.map(a => sub(String(a))) : [], env, source }
+}
+
+/** One codex `[mcp_servers.<name>]` table → spec. */
+export function specFromCodex(entry: unknown, source: string, scope: McpScope = 'peer'): McpSpec | null {
+  if (!entry || typeof entry !== 'object') return null
+  const e = entry as Obj
+  if (typeof e.url === 'string') {
+    const headers = strMap(e.http_headers)
+    for (const [h, v] of Object.entries(strMap(e.env_http_headers))) headers[h] = `{env:${v}}`
+    if (typeof e.bearer_token_env_var === 'string' && e.bearer_token_env_var) headers.Authorization = `Bearer {env:${e.bearer_token_env_var}}`
+    return { scope, kind: 'remote', url: e.url, headers, source }
+  }
+  if (typeof e.command !== 'string' || !e.command) return null
+  return { scope, kind: 'local', command: e.command, args: Array.isArray(e.args) ? e.args.map(String) : [], env: strMap(e.env), source }
+}
+
+function newestDir(dir: string): string | null {
+  try {
+    const subs = readdirSync(dir)
+      .map(n => join(dir, n))
+      .filter(p => {
+        try {
+          return statSync(p).isDirectory()
+        } catch {
+          return false
+        }
+      })
+    if (!subs.length) return null
+    return subs.sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)[0]!
+  } catch {
+    return null
+  }
+}
+
+/** A plugin's declared servers: manifest `mcpServers` (object, or a path relative to the root),
+ *  else <root>/.mcp.json. */
+function pluginServers(root: string, manifestRel: string): Obj {
+  const manifest = readJson(join(root, manifestRel))
+  const m = manifest?.mcpServers
+  if (m && typeof m === 'object' && !Array.isArray(m)) return m as Obj
+  const file = typeof m === 'string' ? (isAbsolute(m) ? m : resolve(root, m)) : join(root, '.mcp.json')
+  const o = readJson(file)
+  const servers = o?.mcpServers ?? o
+  return servers && typeof servers === 'object' && !Array.isArray(servers) ? (servers as Obj) : {}
+}
+
+function splitKey(key: string): { name: string; market: string } | null {
+  const i = key.lastIndexOf('@')
+  return i > 0 ? { name: key.slice(0, i), market: key.slice(i + 1) } : null
+}
+
+export interface PeerServerOptions {
+  env?: NodeJS.ProcessEnv
+}
+
+function homeOf(env: NodeJS.ProcessEnv): string {
+  return env.HOME?.trim() || homedir()
+}
+
+export function claudeServers(cwd: string, opts: PeerServerOptions = {}): Map<string, McpSpec> {
+  const env = opts.env ?? process.env
+  const home = homeOf(env)
+  const claudeDir = env.CLAUDE_CONFIG_DIR?.trim() || join(home, '.claude')
+  const out = new Map<string, McpSpec>()
+  const direct = readJson(join(cwd, '.mcp.json'))?.mcpServers
+  if (direct && typeof direct === 'object') {
+    for (const [n, e] of Object.entries(direct as Obj)) {
+      const s = specFromClaude(e, '.mcp.json')
+      if (s) out.set(n, s)
+    }
+  }
+  const enabled = new Map<string, { on: boolean; scope: McpScope }>()
+  const layers: Array<[string, McpScope]> = [
+    [join(claudeDir, 'settings.json'), 'host'],
+    [join(cwd, '.claude', 'settings.json'), 'peer'],
+    [join(cwd, '.claude', 'settings.local.json'), 'peer'],
+  ]
+  for (const [f, scope] of layers) {
+    const ep = readJson(f)?.enabledPlugins
+    if (ep && typeof ep === 'object') for (const [k, v] of Object.entries(ep as Obj)) enabled.set(k, { on: v === true, scope })
+  }
+  const installed = (readJson(join(claudeDir, 'plugins', 'installed_plugins.json'))?.plugins ?? {}) as Obj
+  for (const [key, { on, scope }] of enabled) {
+    if (!on) continue
+    const kv = splitKey(key)
+    if (!kv) continue
+    const rec = installed[key]
+    const first = Array.isArray(rec) ? (rec[0] as Obj | undefined) : (rec as Obj | undefined)
+    const root =
+      (typeof first?.installPath === 'string' && existsSync(first.installPath) ? first.installPath : null) ??
+      newestDir(join(claudeDir, 'plugins', 'cache', kv.market, kv.name))
+    if (!root) continue
+    for (const [n, e] of Object.entries(pluginServers(root, join('.claude-plugin', 'plugin.json')))) {
+      if (out.has(n)) continue // the peer's own declaration wins
+      const s = specFromClaude(e, `plugin ${key}`, root, scope)
+      if (s) out.set(n, s)
+    }
+  }
+  return out
+}
+
+export function codexServers(cwd: string, opts: PeerServerOptions = {}): Map<string, McpSpec> {
+  const env = opts.env ?? process.env
+  const codexHome = env.CODEX_HOME?.trim() || join(homeOf(env), '.codex')
+  const out = new Map<string, McpSpec>()
+  const peer = readToml(join(cwd, '.codex', 'config.toml'))
+  const direct = peer?.mcp_servers
+  if (direct && typeof direct === 'object') {
+    for (const [n, e] of Object.entries(direct as Obj)) {
+      if ((e as Obj | undefined)?.enabled === false) continue
+      const s = specFromCodex(e, '.codex/config.toml')
+      if (s) out.set(n, s)
+    }
+  }
+  const enabled = new Map<string, { on: boolean; scope: McpScope }>()
+  const layers: Array<[Obj | null, McpScope]> = [[readToml(join(codexHome, 'config.toml')), 'host'], [peer, 'peer']]
+  for (const [cfg, scope] of layers) {
+    const pl = cfg?.plugins
+    if (pl && typeof pl === 'object') for (const [k, v] of Object.entries(pl as Obj)) enabled.set(k, { on: (v as Obj | undefined)?.enabled === true, scope })
+  }
+  for (const [key, { on, scope }] of enabled) {
+    if (!on) continue
+    const kv = splitKey(key)
+    if (!kv) continue
+    const root = newestDir(join(codexHome, 'plugins', 'cache', kv.market, kv.name))
+    if (!root) continue
+    for (const [n, e] of Object.entries(pluginServers(root, join('.codex-plugin', 'plugin.json')))) {
+      if (out.has(n)) continue
+      // Plugin manifests use the claude-style JSON shape even on the codex side.
+      const s = specFromClaude(e, `plugin ${key}`, root, scope)
+      if (s) out.set(n, s)
+    }
+  }
+  return out
+}
+
+/** OpenCode's own MCP entry for a spec (docs: `type local|remote`). */
+export function toOpencodeMcp(s: McpSpec): Obj {
+  // (scope is ours, not OpenCode's — never emitted)
+  // oauth:false — a headless peer must never stall in an interactive OAuth flow (the core's own
+  // iapeer entry does the same). timeout 30 s on local servers: a first `npx -y` start fetches the
+  // package and blows OpenCode's 5 s tool-listing default.
+  if (s.kind === 'remote') return { type: 'remote', url: s.url, enabled: true, oauth: false, ...(Object.keys(s.headers).length ? { headers: s.headers } : {}) }
+  return {
+    type: 'local',
+    command: [s.command, ...s.args],
+    enabled: true,
+    timeout: 30_000,
+    ...(Object.keys(s.env).length ? { environment: s.env } : {}),
+  }
+}

package/src/opencode/config.ts

@@ -11,6 +11,8 @@ import { listCapabilities } from '../capability/index.ts'
 export const OPENCODE_AGENT = 'iapeer'
 /** The memory provider's private fragment stem (docs/20 §Memory-provider ABI). */
 export const OPENCODE_MEMORY_FRAGMENT = 'iapeer-memory'
+/** The core-owned projection of the peer's claude/codex MCP servers (docs/20 §Peer MCP). */
+export const OPENCODE_PEER_MCP_FRAGMENT = 'peer-mcp'
 type JsonObject = Record<string, unknown>
 
 export function opencodePaths(personality: string, options: StorageOptions = {}) {
@@ -22,6 +24,7 @@ export function opencodePaths(personality: string, options: StorageOptions = {})
     state: join(dir, 'state.json'),
     events: join(dir, 'events.jsonl'),
     config: join(dir, 'opencode.json'), // optional operator-owned provider/model config
+    peerMcp: join(dir, `${OPENCODE_PEER_MCP_FRAGMENT}.json`), // core-owned projection, regenerated
   }
 }
 
@@ -121,6 +124,9 @@ export function composeOpencodeConfig(input: ComposeOpencodeConfigInput, options
   // Host default first (docs/20 §Host-default provider), then the peer's own config overrides it.
   const hostPath = opencodeHostConfigPath(options)
   let result: JsonObject = existsSync(hostPath) ? object(JSON.parse(readFileSync(hostPath, 'utf8')), hostPath) : {}
+  // The peer's own MCP servers projected from its claude/codex declarations — BEFORE the peer's
+  // opencode config, so an operator's explicit entry always wins over the projection.
+  if (existsSync(paths.peerMcp)) result = mergeOpencodeConfig(result, readOpencodeExtension(paths.peerMcp))
   if (existsSync(paths.config)) result = mergeOpencodeConfig(result, object(JSON.parse(readFileSync(paths.config, 'utf8')), paths.config))
   if (input.inline !== undefined) result = mergeOpencodeConfig(result, object(JSON.parse(input.inline), 'OPENCODE_CONFIG_CONTENT'))
   // Fragment owners: the memory provider + every REGISTERED capability (docs/21) — never a

package/src/opencode/peerMcp.ts

@@ -0,0 +1,88 @@
+// Peer MCP projection into OpenCode (docs/20 §Peer MCP). Invariant (boris 18.10): after add-runtime
+// the peer on its new runtime sees the SAME MCP set as on its other runtimes, and verify is clean
+// with no hand edit. The source of truth stays the peer's claude/codex declarations (+ their enabled
+// plugins, src/mcp/peerServers.ts); OpenCode gets a core-owned PROJECTION of them — never a hand-kept
+// copy. It is regenerated on add-runtime, on every OpenCode launch and by `verify --fix`, so a server
+// added to `.mcp.json` later reaches OpenCode on the next launch instead of drifting.
+//
+// Ownership: `<private dir>/peer-mcp.json` is the core's; operator entries live in the peer's own
+// opencode.json and win over the projection (merge order in composeOpencodeConfig). Names already
+// supplied by another OpenCode source (host default, peer config, memory/capability fragments) are NOT
+// projected — a deep merge of two definitions of one server would mix their fields. The core's own
+// `iapeer` server is never projected.
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { opencodeHostConfigPath, writeFileAtomic, type StorageOptions } from '../storage/index.ts'
+import { OPENCODE_MEMORY_FRAGMENT, opencodePaths } from './config.ts'
+import { listCapabilities } from '../capability/index.ts'
+import { claudeServers, codexServers, toOpencodeMcp, type McpSpec } from '../mcp/peerServers.ts'
+
+const CORE_SERVER = 'iapeer'
+
+function mcpKeys(path: string): string[] {
+  try {
+    const o = JSON.parse(readFileSync(path, 'utf8')) as { mcp?: unknown }
+    return o.mcp && typeof o.mcp === 'object' && !Array.isArray(o.mcp) ? Object.keys(o.mcp) : []
+  } catch {
+    return []
+  }
+}
+
+/** Server names OpenCode already gets from a source OTHER than the projection. */
+export function opencodeOwnServers(personality: string, options: StorageOptions = {}): Set<string> {
+  const paths = opencodePaths(personality, options)
+  const stems = [OPENCODE_MEMORY_FRAGMENT, ...listCapabilities(options).declarations.map(d => d.capability)]
+  return new Set([
+    ...mcpKeys(opencodeHostConfigPath(options)),
+    ...mcpKeys(paths.config),
+    ...stems.flatMap(s => mcpKeys(join(paths.dir, `${s}.json`))),
+  ])
+}
+
+export interface PeerMcpSync {
+  /** Servers now projected into OpenCode. */
+  projected: string[]
+  /** Servers deliberately not projected (already supplied by another OpenCode source). */
+  ownedElsewhere: string[]
+  changed: boolean
+  path: string
+}
+
+/** The specs the peer declares on its claude/codex runtimes (claude's definition wins a name clash). */
+export function peerSourceServers(cwd: string, runtimes: readonly string[], env: NodeJS.ProcessEnv): Map<string, McpSpec> {
+  const out = new Map<string, McpSpec>()
+  // PEER-scope only: a server a host-wide plugin gives every peer of one runtime is a host decision,
+  // not this peer's — projecting it would silently widen OpenCode beyond what the peer declared.
+  if (runtimes.includes('claude')) for (const [n, s] of claudeServers(cwd, { env })) if (s.scope === 'peer') out.set(n, s)
+  if (runtimes.includes('codex')) for (const [n, s] of codexServers(cwd, { env })) if (s.scope === 'peer' && !out.has(n)) out.set(n, s)
+  out.delete(CORE_SERVER)
+  return out
+}
+
+/** Regenerate the projection. Idempotent: an unchanged result is not rewritten. */
+export function syncOpencodePeerMcp(personality: string, cwd: string, runtimes: readonly string[], options: StorageOptions = {}): PeerMcpSync {
+  const env = options.env ?? process.env
+  const paths = opencodePaths(personality, options)
+  const own = opencodeOwnServers(personality, options)
+  const mcp: Record<string, unknown> = {}
+  const ownedElsewhere: string[] = []
+  for (const [name, spec] of [...peerSourceServers(cwd, runtimes, env)].sort(([a], [b]) => a.localeCompare(b))) {
+    if (own.has(name)) {
+      ownedElsewhere.push(name)
+      continue
+    }
+    mcp[name] = toOpencodeMcp(spec)
+  }
+  const projected = Object.keys(mcp)
+  const prior = existsSync(paths.peerMcp) ? readFileSync(paths.peerMcp, 'utf8') : null
+  if (projected.length === 0) {
+    if (prior !== null) rmSync(paths.peerMcp, { force: true })
+    return { projected, ownedElsewhere, changed: prior !== null, path: paths.peerMcp }
+  }
+  const next = `${JSON.stringify({ mcp }, null, 2)}\n`
+  if (prior === next) return { projected, ownedElsewhere, changed: false, path: paths.peerMcp }
+  mkdirSync(paths.dir, { recursive: true, mode: 0o700 })
+  // 0600: the projected env carries the servers' own secrets, exactly as the source files do.
+  writeFileAtomic(paths.peerMcp, next, 0o600)
+  return { projected, ownedElsewhere, changed: true, path: paths.peerMcp }
+}

package/src/transport/index.ts

@@ -913,6 +913,13 @@ export function deliveryProcessed(probe: ProcessedProbe, env: NodeJS.ProcessEnv
  *   opencode — an assistant message for that user message with `time.completed` and a finish other
  *              than `tool-calls`.
  */
+/** claude's own record of an interrupted turn (user line whose text is the interrupt marker). */
+function isInterruptMarkerLine(o: { message?: unknown }): boolean {
+  const c = (o.message as { content?: unknown } | undefined)?.content
+  const texts = typeof c === 'string' ? [c] : Array.isArray(c) ? c.filter(b => b?.type === 'text').map(b => String(b.text ?? '')) : []
+  return texts.some(t => /^\[Request interrupted by user/.test(t.trim()))
+}
+
 export function deliveryCompleted(probe: ProcessedProbe, env: NodeJS.ProcessEnv = process.env): boolean {
   const needles = confirmNeedles(probe.rendered)
   if (!needles.length || needles.every(n => !n)) return false
@@ -968,6 +975,12 @@ export function deliveryCompleted(probe: ProcessedProbe, env: NodeJS.ProcessEnv
       }
       if (o.type === 'assistant' && ['end_turn', 'stop_sequence', 'max_tokens'].includes(o.message?.stop_reason ?? '')) return true
       if (o.type === 'event_msg' && o.payload?.type === 'task_complete') return true
+      // An operator INTERRUPT ends the turn too (claude: a `[Request interrupted by user…]` user line,
+      // codex: `turn_aborted`). Not counting it, a turn the owner had stopped was later reported to its
+      // sender as «INTERRUPTED by the session's death» once the session died for an unrelated reason
+      // (live parity run 18.10). OpenCode's abort already closes the assistant message, so it was right.
+      if (o.type === 'event_msg' && o.payload?.type === 'turn_aborted') return true
+      if (o.type === 'user' && isInterruptMarkerLine(o)) return true
     }
   }
   return false

package/src/verify/mcpParity.ts

@@ -5,16 +5,20 @@
 // without its tools and nobody noticed). This reads each runtime's PEER-LEVEL MCP declarations and
 // reports every server present on some runtime and missing on another.
 //
-// Sources (peer level only — host-wide runtime config is shared by all peers and not a peer fact):
-//   claude   — <cwd>/.mcp.json            mcpServers.<name>
-//   codex    — <cwd>/.codex/config.toml   [mcp_servers.<name>]
-//   opencode — host-default + per-peer opencode.json `mcp` and the registered fragments (docs/20)
+// Sources — what the runtime ACTUALLY sees at launch (src/mcp/peerServers.ts):
+//   claude   — <cwd>/.mcp.json mcpServers + servers of the plugins enabled for the peer
+//   codex    — <cwd>/.codex/config.toml [mcp_servers] + servers of the enabled codex plugins
+//              (host config.toml, overridden by the peer's) — a plugin-delivered server is real
+//              (boris 18.10: voice-connect was a false ✗ because only the peer file was read)
+//   opencode — host-default + per-peer opencode.json `mcp`, the core's peer-mcp projection and the
+//              registered fragments (docs/20)
 // The core's own `iapeer` server is excluded: it is wired by the core on every runtime by
 // construction (host-wide for codex), so comparing it would only produce false alarms.
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { opencodeHostConfigPath, type StorageOptions } from '../storage/index.ts'
-import { OPENCODE_MEMORY_FRAGMENT, opencodePaths } from '../opencode/config.ts'
+import { OPENCODE_MEMORY_FRAGMENT, OPENCODE_PEER_MCP_FRAGMENT, opencodePaths } from '../opencode/config.ts'
+import { claudeServers, codexServers } from '../mcp/peerServers.ts'
 import { listCapabilities } from '../capability/index.ts'
 
 const CORE_SERVER = 'iapeer'
@@ -36,25 +40,34 @@ export function codexMcpNames(toml: string): string[] {
   return [...out]
 }
 
-export function peerMcpServers(runtime: string, personality: string, cwd: string, options: StorageOptions = {}): string[] | null {
-  let names: string[]
-  if (runtime === 'claude') {
-    names = jsonKeys(join(cwd, '.mcp.json'), o => o.mcpServers)
-  } else if (runtime === 'codex') {
-    const p = join(cwd, '.codex', 'config.toml')
-    names = existsSync(p) ? codexMcpNames(readFileSync(p, 'utf8')) : []
-  } else if (runtime === 'opencode') {
+export interface RuntimeMcpView {
+  /** Servers the PEER declares on this runtime (its own files / peer-level plugin enables). */
+  declared: Set<string>
+  /** Everything the runtime actually sees: declared ∪ host-wide plugin servers. */
+  available: Set<string>
+}
+
+export function peerMcpView(runtime: string, personality: string, cwd: string, options: StorageOptions = {}): RuntimeMcpView | null {
+  const env = options.env ?? process.env
+  const drop = (names: Iterable<string>): Set<string> => new Set([...names].filter(n => n !== CORE_SERVER))
+  if (runtime === 'claude' || runtime === 'codex') {
+    const m = runtime === 'claude' ? claudeServers(cwd, { env }) : codexServers(cwd, { env })
+    return { declared: drop([...m].filter(([, s]) => s.scope === 'peer').map(([n]) => n)), available: drop(m.keys()) }
+  }
+  if (runtime === 'opencode') {
     const paths = opencodePaths(personality, options)
-    const stems = [OPENCODE_MEMORY_FRAGMENT, ...listCapabilities(options).declarations.map(d => d.capability)]
-    names = [
-      ...jsonKeys(opencodeHostConfigPath(options), o => o.mcp),
-      ...jsonKeys(paths.config, o => o.mcp),
-      ...stems.flatMap(s => jsonKeys(join(paths.dir, `${s}.json`), o => o.mcp)),
-    ]
-  } else {
-    return null // not an agent runtime with an MCP client
+    const stems = [OPENCODE_MEMORY_FRAGMENT, OPENCODE_PEER_MCP_FRAGMENT, ...listCapabilities(options).declarations.map(d => d.capability)]
+    const peerLevel = [...jsonKeys(paths.config, o => o.mcp), ...stems.flatMap(s => jsonKeys(join(paths.dir, `${s}.json`), o => o.mcp))]
+    const host = jsonKeys(opencodeHostConfigPath(options), o => o.mcp)
+    return { declared: drop(peerLevel), available: drop([...peerLevel, ...host]) }
   }
-  return [...new Set(names)].filter(n => n !== CORE_SERVER).sort()
+  return null // not an agent runtime with an MCP client
+}
+
+/** Back-compat: the names a runtime sees (available set), sorted. */
+export function peerMcpServers(runtime: string, personality: string, cwd: string, options: StorageOptions = {}): string[] | null {
+  const v = peerMcpView(runtime, personality, cwd, options)
+  return v ? [...v.available].sort() : null
 }
 
 export interface McpParityIssue {
@@ -63,19 +76,24 @@ export interface McpParityIssue {
   missingIn: string[]
 }
 
-/** Every server some agent runtime of the peer declares and another lacks. */
+/**
+ * Every server some agent runtime of the peer DECLARES and another runtime does not SEE. A server that
+ * only a host-wide plugin supplies is never an issue on its own (host decision, not peer drift), but it
+ * does satisfy a declaration elsewhere — voice-connect declares its server in .mcp.json and codex gets
+ * the same server from the enabled host plugin: present on both, no ✗ (boris 18.10).
+ */
 export function mcpParity(personality: string, cwd: string, runtimes: readonly string[], options: StorageOptions = {}): McpParityIssue[] {
-  const sets = new Map<string, Set<string>>()
+  const views = new Map<string, RuntimeMcpView>()
   for (const rt of runtimes) {
-    const names = peerMcpServers(rt, personality, cwd, options)
-    if (names) sets.set(rt, new Set(names))
+    const v = peerMcpView(rt, personality, cwd, options)
+    if (v) views.set(rt, v)
   }
-  if (sets.size < 2) return []
-  const all = new Set([...sets.values()].flatMap(s => [...s]))
+  if (views.size < 2) return []
+  const declaredAnywhere = new Set([...views.values()].flatMap(v => [...v.declared]))
   const issues: McpParityIssue[] = []
-  for (const server of [...all].sort()) {
-    const presentIn = [...sets].filter(([, s]) => s.has(server)).map(([rt]) => rt)
-    const missingIn = [...sets].filter(([, s]) => !s.has(server)).map(([rt]) => rt)
+  for (const server of [...declaredAnywhere].sort()) {
+    const presentIn = [...views].filter(([, v]) => v.available.has(server)).map(([rt]) => rt)
+    const missingIn = [...views].filter(([, v]) => !v.available.has(server)).map(([rt]) => rt)
     if (missingIn.length) issues.push({ server, presentIn, missingIn })
   }
   return issues