@agfpd/iapeer 0.4.124 → 0.4.125

package/docs/08-peer-management.md

@@ -53,7 +53,7 @@ iapeer verify          # report divergences
 iapeer verify --fix    # repair
 ```
 
-`verify` checks two things: profiles' conformance to the standard, and divergences between the registry and the local profiles. 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]`). 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.
 
 **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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.124",
+  "version": "0.4.125",
   "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

@@ -2336,6 +2336,17 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
             legacyRuntimeProfiles.push({ personality: peer.personality, cwd: peer.cwd })
           }
         }
+        // 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')
+        let mcpDrift = 0
+        for (const peer of index.peers) {
+          for (const issue of mcpParity(peer.personality, peer.cwd, peer.runtimes, { env })) {
+            errors++
+            mcpDrift++
+            lines.push(`✗ ${peer.personality}: MCP server "${issue.server}" is in [${issue.presentIn.join(', ')}] but MISSING in [${issue.missingIn.join(', ')}]`)
+          }
+        }
         const reconcile = reconcileIndex({ env })
         for (const r of reconcile) {
           if (r.drift === null) {
@@ -2346,7 +2357,7 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
           }
         }
         if (flags.json === true) {
-          out(JSON.stringify({ peers: index.peers.length, errors, drift: driftCount, reconcile }, null, 2) + '\n')
+          out(JSON.stringify({ peers: index.peers.length, errors, drift: driftCount, mcpDrift, reconcile }, null, 2) + '\n')
         } else {
           for (const l of lines) out(l + '\n')
           out(`\n${index.peers.length} peers · ${errors} error(s) · ${driftCount} index↔local drift(s)\n`)

package/src/verify/mcpParity.ts

@@ -0,0 +1,82 @@
+// MCP parity across a peer's agent runtimes (verify). One personality is one agent with several
+// endpoints; a tool server the peer has on one runtime but not on another makes the SAME peer silently
+// weaker there (incident 17.10: after a claude-side redeploy impact-finder / mrmechanic /
+// company-checker had their domain MCP servers only in .codex/config.toml — the claude session ran
+// 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)
+// 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 { listCapabilities } from '../capability/index.ts'
+
+const CORE_SERVER = 'iapeer'
+
+function jsonKeys(path: string, pick: (o: Record<string, unknown>) => unknown): string[] {
+  try {
+    const o = JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>
+    const v = pick(o)
+    return v && typeof v === 'object' && !Array.isArray(v) ? Object.keys(v as object) : []
+  } catch {
+    return []
+  }
+}
+
+/** `[mcp_servers.<name>]` / `[mcp_servers."<name>"]` table headers (sub-tables like `.env` ignored). */
+export function codexMcpNames(toml: string): string[] {
+  const out = new Set<string>()
+  for (const m of toml.matchAll(/^\s*\[\s*mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_-]+))\s*\]/gm)) out.add((m[1] ?? m[2])!)
+  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') {
+    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
+  }
+  return [...new Set(names)].filter(n => n !== CORE_SERVER).sort()
+}
+
+export interface McpParityIssue {
+  server: string
+  presentIn: string[]
+  missingIn: string[]
+}
+
+/** Every server some agent runtime of the peer declares and another lacks. */
+export function mcpParity(personality: string, cwd: string, runtimes: readonly string[], options: StorageOptions = {}): McpParityIssue[] {
+  const sets = new Map<string, Set<string>>()
+  for (const rt of runtimes) {
+    const names = peerMcpServers(rt, personality, cwd, options)
+    if (names) sets.set(rt, new Set(names))
+  }
+  if (sets.size < 2) return []
+  const all = new Set([...sets.values()].flatMap(s => [...s]))
+  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)
+    if (missingIn.length) issues.push({ server, presentIn, missingIn })
+  }
+  return issues
+}