@agfpd/iapeer 0.4.130 → 0.4.132

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/15-fleet-api.md

@@ -126,7 +126,8 @@ mtime, never a reconstruction:
 
 - **codex** — the rollout's `event_msg` payloads `task_started` → `working`, `task_complete` →
   `idle`; last one wins. Codex emits `task_complete` for a turn that ends on an error too, so
-  the terminal-error path needs no separate marker.
+  the terminal-error path needs no separate marker. An INTERRUPTED turn ends on `turn_aborted`
+  (no `task_complete` follows) → `idle`.
 - **claude** — the transcript's assistant `stop_reason`. **Only `tool_use` means the turn
   continues**; every other terminal reason (`end_turn`, `stop_sequence`, `max_tokens`, a future
   value, `null`) means it ended. The polarity is deliberately asymmetric: an unrecognised reason
@@ -134,7 +135,11 @@ mtime, never a reconstruction:
   tool_result to consume), but compaction summaries (`isCompactSummary`), sub-agent sidechains
   (`isSidechain`) and injected meta lines (`isMeta`) are excluded — each is a measured
   false-`working` vector, the worst being a `/compact` run while idle leaving a phantom
-  `working` forever.
+  `working` forever. An operator interrupt ends the turn with a user line whose text is
+  `[Request interrupted by user]` / `[Request interrupted by user for tool use]` → `idle` (it
+  used to read `working` forever on a stopped session, 18.10.2026).
+- **Attribution** — a session is the peer whose registered cwd is the session's cwd or its
+  nearest ancestor (a peer that `cd`-ed into a subdirectory stays itself).
 
 ### Bounds a client can rely on
 

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.130",
+  "version": "0.4.132",
   "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 })) {

package/src/daemon/turnwatch.ts

@@ -56,6 +56,7 @@
 // IDLE codex pane-log freezes (39s→46s). The signal means opposite things per runtime; one
 // clock that lies differently on each runtime is worse than no clock.
 
+import { peerByCwdPrefix } from './mutewatch.ts'
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import type { LifecycleConfig } from '../lifecycle/index.ts'
@@ -101,6 +102,13 @@ function toMs(ts: unknown): number | null {
   return Number.isFinite(ms) ? ms : null
 }
 
+/** Claude's own record of an interrupted turn: a user line whose text is the interrupt marker. */
+export function isClaudeInterruptMarker(d: Record<string, unknown>): boolean {
+  const c = (d.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()))
+}
+
 /**
  * The claude transcript's turn state, or null if the file states nothing usable.
  *
@@ -136,8 +144,12 @@ export function parseClaudeTurn(text: string): TurnState | null {
       state = msg?.stop_reason === 'tool_use' ? 'working' : 'idle'
     } else {
       // A real user line: a prompt to answer or a tool_result to consume — either way the
-      // model is on the hook. (The non-model user lines were filtered above.)
-      state = 'working'
+      // model is on the hook. (The non-model user lines were filtered above.) EXCEPT the
+      // interrupt marker: an operator interrupt (Escape / `iapeer interrupt`) ENDS the turn, and
+      // claude records that end as a user line `[Request interrupted by user]` / `… for tool
+      // use]` (real bytes 18.10.2026) — no assistant stop_reason follows. Read as working, it was
+      // a permanent phantom «working» on a stopped session.
+      state = isClaudeInterruptMarker(d) ? 'idle' : 'working'
     }
     found = { state, atMs, cwd }
   }
@@ -171,7 +183,7 @@ export function parseCodexTurn(text: string, head = ''): TurnState | null {
   let found: TurnState | null = null
   for (const line of text.split('\n')) {
     const s = line.trim()
-    if (!s.startsWith('{') || !s.includes('task_')) continue
+    if (!s.startsWith('{') || (!s.includes('task_') && !s.includes('turn_aborted'))) continue
     let d: { timestamp?: unknown; type?: unknown; payload?: { type?: unknown } }
     try {
       d = JSON.parse(s)
@@ -180,7 +192,9 @@ export function parseCodexTurn(text: string, head = ''): TurnState | null {
     }
     if (d.type !== 'event_msg') continue
     const p = d.payload?.type
-    if (p !== 'task_started' && p !== 'task_complete') continue
+    // `turn_aborted` (reason "interrupted") is how codex ends a turn the operator interrupted — NO
+    // task_complete follows (real rollouts). Without it an interrupted codex turn stayed «working».
+    if (p !== 'task_started' && p !== 'task_complete' && p !== 'turn_aborted') continue
     const atMs = toMs(d.timestamp)
     if (atMs === null) continue
     found = { state: p === 'task_started' ? 'working' : 'idle', atMs, cwd }
@@ -407,7 +421,7 @@ export function startTurnWatch(cfg: LifecycleConfig, board: ActivityBoard, opts:
           env,
           now,
           onError: opts.onError,
-          peerByCwd: (cwd: string) => byCwd.get(cwd.replace(/\/+$/, '').toLowerCase()),
+          peerByCwd: (cwd: string) => peerByCwdPrefix(byCwd, cwd),
         },
         since,
       ).sinceMs

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/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/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