@agfpd/iapeer 0.4.124 → 0.4.126

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.126",
   "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/launch/adapters/opencode.ts

@@ -108,6 +108,9 @@ export const opencodeAdapter: RuntimeAdapter = {
     const warnings = hasExplicitModel(config)
       ? []
       : [`opencode-implicit-provider: no explicit "model" in ${p.config} — OpenCode's own default provider receives the doctrine and messages`]
+    // Handed to the plugin too, so they reach runtime.ready / state.json / fleet runtimes[].warnings like
+    // the self-check findings (not only lifecycle.log).
+    if (warnings.length) out.IAPEER_OPENCODE_WARNINGS = JSON.stringify(warnings)
     return { env: out, readyToken: launchID, warnings }
   },
 

package/src/launch/index.ts

@@ -194,13 +194,17 @@ export const launch: LaunchFn = async (
     // Structural runtimes (opencode) prepare launch artifacts + extra env BEFORE spawn. The identity
     // ABI stays authoritative: prepared env never overrides PEER_PERSONALITY/RUNTIME/IDENTITY.
     let readyToken: string | undefined
+    const loggedWarnings = new Set<string>()
     if (adapter.prepareLaunch) {
       try {
         const prepared = adapter.prepareLaunch(spec, invocation.env, cfg)
         const { PEER_PERSONALITY, PEER_RUNTIME, PEER_IDENTITY } = invocation.env
         invocation.env = { ...invocation.env, ...prepared.env, PEER_PERSONALITY, PEER_RUNTIME, PEER_IDENTITY }
         readyToken = prepared.readyToken
-        for (const w of prepared.warnings ?? []) appendLifecycleEvent(cfg.exitLogDir, { ev: 'launch-warning', identity, warning: w }, { env })
+        for (const w of prepared.warnings ?? []) {
+          loggedWarnings.add(w)
+          appendLifecycleEvent(cfg.exitLogDir, { ev: 'launch-warning', identity, warning: w }, { env })
+        }
       } catch (e) {
         return fail(identity, `launch preparation failed: ${e instanceof Error ? e.message : String(e)}`)
       }
@@ -241,7 +245,9 @@ export const launch: LaunchFn = async (
       if (adapter.structuralReady && readyToken) {
         const r = await adapter.structuralReady(spec, readyToken, Date.now() + cfg.bootDeadlineSecs * 1000, () => hostSessionAlive(identity, env), env)
         if (!r.ok) return fail(identity, `never-became-ready (structural: ${r.reason ?? 'unknown'})`)
-        for (const w of r.warnings ?? []) appendLifecycleEvent(cfg.exitLogDir, { ev: 'launch-warning', identity, warning: w }, { env })
+        for (const w of r.warnings ?? []) {
+          if (!loggedWarnings.has(w)) appendLifecycleEvent(cfg.exitLogDir, { ev: 'launch-warning', identity, warning: w }, { env })
+        }
         if (firstMessage.trim().length === 0) return ready(identity)
         if (!adapter.deliver) return fail(identity, 'structural runtime has no deliver hook')
         const d = await adapter.deliver({ personality: spec.personality, identity }, firstMessage, env)

package/src/lifecycle/inflight.ts

@@ -119,17 +119,20 @@ export function sweepInflight(stateDir: string, identity: string, deps: Inflight
     }
   }
   // A session works its input in order: a FINISHED turn for a later message means every earlier one
-  // was handled too (bounds the ledger when a turn-end record is missed).
-  let finishedUpTo = -Infinity
+  // OF THE SAME SESSION was handled too (bounds the ledger when a turn-end record is missed). Strictly
+  // per session token: a turn finished in a NEW session says nothing about a dead session's queue —
+  // that cross-session shortcut silently dropped A and B in 0.4.122 (linus OC07 regression).
+  const finishedUpTo = new Map<string, number>()
   const finished = new Set<string>()
+  const sessionKey = (e: InflightEntry) => e.sessionToken ?? '∅'
   for (const e of entries) {
     if (safe(deps.completed, e, false) || (!deps.completed && safe(deps.processed, e, false))) {
       finished.add(e.id)
-      finishedUpTo = Math.max(finishedUpTo, e.ts)
+      finishedUpTo.set(sessionKey(e), Math.max(finishedUpTo.get(sessionKey(e)) ?? -Infinity, e.ts))
     }
   }
   for (const e of entries) {
-    if (finished.has(e.id) || e.ts < finishedUpTo) continue
+    if (finished.has(e.id) || e.ts < (finishedUpTo.get(sessionKey(e)) ?? -Infinity)) continue
     const done = safe(deps.processed, e, false)
     if (done) {
       // Answered but its turn did not finish: live → still working; gone → INTERRUPTED (side effects

package/src/opencode/iapeer-plugin.mjs

@@ -320,6 +320,10 @@ async function server(input) {
   }
   async function selfCheck() {
     const warnings = []
+    try {
+      const fromCore = JSON.parse(env.IAPEER_OPENCODE_WARNINGS || '[]') // launch-time facts (e.g. implicit provider)
+      if (Array.isArray(fromCore)) for (const w of fromCore) if (typeof w === 'string') warnings.push(w)
+    } catch {}
     try {
       const st = await client.mcp.status()
       for (const [name, s] of Object.entries((st && st.data) || {})) {

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
+}