@agfpd/iapeer 0.4.123 → 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.123",
+  "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/daemon/mutewatch.ts

@@ -78,6 +78,8 @@ import { join } from 'node:path'
 import type { LifecycleConfig } from '../lifecycle/index.ts'
 import type { NoticeBoard } from './notices.ts'
 import { readSessionSlices } from './sessionfiles.ts'
+import { endpointPrivateDir } from '../storage/index.ts'
+import { readOpencodeState } from '../opencode/journal.ts'
 
 /** How much of a session file's tail is parsed. The evidence is always at the end. */
 const TAIL_BYTES = 256 * 1024
@@ -89,7 +91,7 @@ const CODEX_WALK_DEPTH = 3
 
 export interface MuteDetection {
   personality: string
-  runtime: 'claude' | 'codex'
+  runtime: 'claude' | 'codex' | 'opencode'
   /** The runtime's OWN taxonomy value — claude's `error`, codex's rate_limit_reached_type. */
   errorType: string
   model?: string
@@ -405,6 +407,41 @@ export interface MuteWatchPaths {
 export interface ScanDeps extends MuteWatchPaths {
   /** personality ← cwd. Built from the registry by the composition point. */
   peerByCwd: (cwd: string) => string | undefined
+  /** OpenCode endpoints: personality → its journal (core-owned private dir; docs/20). Optional:
+   *  absent → no opencode sweep (tests of the claude/codex paths). */
+  opencodeJournals?: () => Array<{ personality: string; events: string; model?: string }>
+}
+
+/**
+ * OpenCode (docs/20): the core plugin journals native `session.error` events unchanged. That IS the
+ * structural fact — the error's own `name` (APIError, ProviderAuthError, …) and status are the
+ * runtime's taxonomy, the message is verbatim. Read only events newer than the floor (by the journal
+ * line's own `time`, so an overlapping sweep re-reads the same occurrence without recounting).
+ */
+export function parseOpencodeJournal(tail: string, floorMs: number): Omit<RawDetection, 'cwd'> | null {
+  let last: Omit<RawDetection, 'cwd'> | null = null
+  for (const line of tail.split('\n')) {
+    if (!line.includes('"session.error"')) continue
+    let e: { type?: string; time?: number; sessionID?: string | null; properties?: { error?: { name?: string; data?: { message?: string; statusCode?: number } } } }
+    try {
+      e = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (e.type !== 'session.error' || typeof e.time !== 'number' || e.time < floorMs) continue
+    const err = e.properties?.error
+    if (!err) continue
+    const name = err.name ?? 'UnknownError'
+    if (name === 'MessageAbortedError') continue // an interrupt the operator asked for, not a failure
+    const status = err.data?.statusCode
+    last = {
+      errorType: status ? `${name}:${status}` : name,
+      content: err.data?.message ?? name,
+      ...(e.sessionID ? { sessionId: e.sessionID } : {}),
+      atMs: e.time,
+    }
+  }
+  return last
 }
 
 /**
@@ -442,6 +479,19 @@ export function scanMuteEvents(deps: ScanDeps, sinceMs: number): MuteDetection[]
     const t = readSessionSlices(file, TAIL_BYTES)
     if (t) push(parseCodexRollout(t.tail, floor, t.head), 'codex')
   }
+  // opencode: the core-owned journal per endpoint (personality is known — no cwd mapping needed).
+  for (const j of deps.opencodeJournals?.() ?? []) {
+    let mt = 0
+    try {
+      mt = statSync(j.events).mtimeMs
+    } catch {
+      continue
+    }
+    if (mt < floor) continue
+    const t = readSessionSlices(j.events, TAIL_BYTES)
+    const d = t ? parseOpencodeJournal(t.tail, floor) : null
+    if (d) out.push({ ...d, ...(j.model ? { model: j.model } : {}), cwd: '', personality: j.personality, runtime: 'opencode' })
+  }
   return out
 }
 
@@ -490,7 +540,7 @@ export interface StartMuteWatchOptions {
   /** Override the runtime session roots (tests). Default: resolveMuteWatchPaths(env). */
   paths?: MuteWatchPaths
   /** Override the registry read (tests). Default: a lazy import of the CLI's listPeers. */
-  listPeers?: () => Array<{ personality: string; cwd: string }>
+  listPeers?: () => Array<{ personality: string; cwd: string; runtimes?: string[] }>
   now?: () => number
   onError?: (err: unknown) => void
 }
@@ -516,7 +566,7 @@ export function startMuteWatch(cfg: LifecycleConfig, board: NoticeBoard, opts: S
     try {
       if (!listPeers) {
         const cli = await import('../cli/index.ts')
-        listPeers = () => cli.listPeers({ env }).map(p => ({ personality: p.personality, cwd: p.cwd }))
+        listPeers = () => cli.listPeers({ env }).map(p => ({ personality: p.personality, cwd: p.cwd, runtimes: p.runtimes.map(r => r.runtime) }))
       }
       const rows = listPeers()
       // cwd → personality. Compared case-insensitively: macOS paths are case-insensitive and
@@ -530,6 +580,15 @@ export function startMuteWatch(cfg: LifecycleConfig, board: NoticeBoard, opts: S
         now,
         onError: opts.onError,
         peerByCwd: (cwd: string) => byCwd.get(cwd.replace(/\/+$/, '').toLowerCase()),
+        opencodeJournals: () =>
+          rows
+            .filter(r => (r.runtimes ?? []).includes('opencode'))
+            .flatMap(r => {
+              const dir = endpointPrivateDir('opencode', r.personality, { env })
+              if (!dir) return []
+              const model = readOpencodeState(join(dir, 'state.json'))?.model
+              return [{ personality: r.personality, events: join(dir, 'events.jsonl'), ...(model ? { model } : {}) }]
+            }),
       }
       since = muteWatchTick(deps, since).sinceMs
     } catch (e) {

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