@agfpd/iapeer 0.4.118 → 0.4.120

package/docs/20-opencode.md

@@ -139,6 +139,19 @@ there. Owner policy (2026-10-18): this is allowed, but never silent.
 - The model actually used is reported by the plugin (`state.json` `model`) and
   appears as the fleet snapshot field `runtimes[].model` (docs/15).
 
+## Host-default provider
+
+`<root>/runtimes/opencode/opencode.json` (operator-owned) is the host default:
+every opencode peer starts from it, and the peer's own
+`<private_dir>/opencode.json` overrides it key by key (deep merge; the inline
+`OPENCODE_CONFIG_CONTENT` and fragments follow; provider pinning applies to the
+result). Credentials stay references (`{env:NVIDIA_API_KEY}`); their values live
+in the HOST launch.env `<root>/runtimes/opencode/launch.env`. Its env vars apply
+to every peer's session of that runtime, under the peer's own launch.env (the
+peer wins); launch directives (`PEER_START_ARGS`, `PEER_DISALLOWED_TOOLS`) stay
+per-peer. With a host default in place, `add-runtime opencode --all` yields
+working peers with no per-peer step.
+
 ## Durable inbound across a session death (OC07, all agent runtimes)
 
 Invariant: an inbound the core acknowledged is either processed by a later

package/package.json

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

@@ -48,6 +48,7 @@ import {
   killSession,
   loadLifecycleConfig,
   purgeIdentityState,
+  setLastDelivered,
   removeSessionState,
   resolvePeerRuntime,
   setEphemeralArmed,
@@ -1378,7 +1379,7 @@ export async function sendMessage(
   // unawaited in-process wake would die with it; the daemon's supervise-tick
   // drain scan (≤60 s) picks the queue up — the EXISTING retry path for failed
   // kicks, not a new mechanism.
-  const { makeArmEphemeralOnDelivered, makeEphemeralRouteDeps, makeNoteLiveTopic } = await import('../daemon/main.ts')
+  const { makeArmEphemeralOnDelivered, makeEphemeralRouteDeps, makeNoteInflight, makeNoteLiveTopic } = await import('../daemon/main.ts')
   const cfg = loadLifecycleConfig(env)
   const t0 = Date.now()
   const result = await routeSend(
@@ -1397,6 +1398,10 @@ export async function sendMessage(
       wake: cliWake,
       ephemeral: makeEphemeralRouteDeps(cfg, env, () => {}),
       noteLiveTopic: makeNoteLiveTopic(cfg, env),
+      // CLI-path parity: the idle-proxy floor (В7) and the inflight ledger (OC07) — the daemon tick
+      // redelivers a CLI-sent message too if its receiving session dies before answering.
+      noteDelivered: identity => setLastDelivered(cfg, identity),
+      noteInflight: makeNoteInflight(cfg),
       originGuardBypass: opts.originGuardBypass,
     },
   )

package/src/identity/index.ts

@@ -677,6 +677,16 @@ export function ensurePeerProfile(options: EnsurePeerProfileOptions): PeerProfil
     // preserved). resolvedIntelligence validates the explicit against the runtime's allowed set.
     intelligence = resolvedIntelligence(options.runtime)
   }
+  // OC01 — an EXPLICIT runtime the peer's nature does not allow is refused LOUDLY, exactly as on the
+  // new-profile branch (create). Before this, add-runtime <agentic> on a natural peer passed: the
+  // gate exempts the explicit runtime by design (an operator command is not discovery), so a human
+  // peer got an agent endpoint while its other agentic runtimes were dropped (linus 18.10).
+  if (!isIntelligenceAllowedForRuntime(options.runtime, intelligence)) {
+    throw new IapError(
+      `runtime "${options.runtime}" requires intelligence ∈ {${allowedIntelligencesForRuntime(options.runtime).join(', ')}}, ` +
+        `peer "${existing.personality}" is ${intelligence} — refusing to attach it`,
+    )
+  }
   // Merge AFTER the intelligence is final, and GATE the WHOLE merged set (not just the
   // fresh discoveries): for a natural/absent peer this both blocks a new agentic pickup
   // AND heals a previously-leaked one (the arthur claude-leak class) on the next
@@ -688,6 +698,13 @@ export function ensurePeerProfile(options: EnsurePeerProfileOptions): PeerProfil
     options.warn,
   )
   ensureLocalRuntimeScopes(cwd, mergedRuntimes)
+  const defaultRt = existing.runtime // the normalized default_runtime
+  if (defaultRt && !mergedRuntimes.includes(defaultRt)) {
+    options.warn?.(
+      `default_runtime "${defaultRt}" of "${existing.personality}" is not among its runtimes [${mergedRuntimes.join(', ')}] — ` +
+        `sends without a runtime will fail; set it with \`iapeer default-runtime <rt> --peer ${existing.personality}\``,
+    )
+  }
   // В36 — an explicit description on RE-provision updates the local profile too (H1 in
   // writePeerProfileAtomic still guards: absent/empty never wipes an existing value).
   const explicitDescription = options.description?.trim()

package/src/init/index.ts

@@ -558,18 +558,22 @@ export async function initPeer(opts: InitPeerOptions): Promise<InitPeerResult> {
   // exact file to fill, instead of letting the first wake be the first signal.
   if (provisioned.runtime === 'opencode') {
     const { opencodePaths } = await import('../opencode/config.ts')
+    const { opencodeHostConfigPath } = await import('../storage/index.ts')
     const cfgPath = opencodePaths(provisioned.personality, { env }).config
-    let model: unknown
-    try {
-      model = (JSON.parse(readFileSync(cfgPath, 'utf8')) as { model?: unknown }).model
-    } catch {
-      model = undefined
+    const modelOf = (path: string): unknown => {
+      try {
+        return (JSON.parse(readFileSync(path, 'utf8')) as { model?: unknown }).model
+      } catch {
+        return undefined
+      }
     }
+    // the peer's own config wins; else the host default (docs/20 §Host-default provider)
+    const model = modelOf(cfgPath) ?? modelOf(opencodeHostConfigPath({ env }))
     if (typeof model !== 'string' || !model.includes('/')) {
       opts.warn?.(
         `opencode provider not configured for "${provisioned.personality}": it will run on OpenCode's own default ` +
-          `provider (doctrine and messages go there) until ${cfgPath} names "model": "<provider>/<model>" ` +
-          `and that provider (docs/20 §Provider pinning)`,
+          `provider (doctrine and messages go there) until ${cfgPath} (per peer) or the host default ` +
+          `<root>/runtimes/opencode/opencode.json names "model": "<provider>/<model>" and that provider (docs/20)`,
       )
     }
   }

package/src/launch/invocation.ts

@@ -7,7 +7,7 @@
 // array straight to Bun.spawn — same argv, same env, different transport.
 import { homedir } from 'os'
 import { CODEX_BEARER_ENV_VAR, CODEX_DUMMY_BEARER } from '../core/constants.ts'
-import { readLaunchEnv } from '../storage/index.ts'
+import { readHostLaunchEnv, readLaunchEnv } from '../storage/index.ts'
 import type { LaunchAdapterConfig, LaunchSpec, RuntimeAdapter } from './types.ts'
 
 export interface LaunchInvocation {
@@ -46,6 +46,8 @@ export function buildLaunchInvocation(
   const argv = adapter.buildArgv(specWithArgs, cfg)
   const childEnv: NodeJS.ProcessEnv = {
     ...env,
+    // host-level launch.env of this runtime (e.g. a host-default provider credential), UNDER the peer's
+    ...readHostLaunchEnv(spec.runtime, { env }),
     ...launchEnv.env,
     // codex token-free MCP import: the bearer env var is set to the PUBLIC, non-secret stub so codex
     // flips authStatus unsupported→bearer_token and imports send_to_peer (the OPEN daemon ignores it,

package/src/opencode/config.ts

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { isValidName } from '../core/constants.ts'
-import { opencodePrivateDir, writeFileAtomic, type StorageOptions } from '../storage/index.ts'
+import { opencodeHostConfigPath, opencodePrivateDir, writeFileAtomic, type StorageOptions } from '../storage/index.ts'
 import pluginSource from './iapeer-plugin.mjs' with { type: 'text' }
 import { listCapabilities } from '../capability/index.ts'
 
@@ -118,7 +118,10 @@ export const OPENCODE_GATED_PERMISSION = { bash: 'ask', edit: 'ask', webfetch: '
 export function composeOpencodeConfig(input: ComposeOpencodeConfigInput, options: StorageOptions = {}): JsonObject {
   if (!input.doctrine.trim()) throw new Error('OpenCode requires a non-empty composed system prompt')
   const paths = opencodePaths(input.personality, options)
-  let result: JsonObject = existsSync(paths.config) ? object(JSON.parse(readFileSync(paths.config, 'utf8')), paths.config) : {}
+  // 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) : {}
+  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
   // hardcoded plugin list. An unregistered plugin's leftover fragment is not merged.

package/src/storage/index.ts

@@ -283,6 +283,32 @@ export function readLaunchEnv(cwd: string, runtime: Runtime): LaunchEnv {
   } catch {
     return { startArgs: [], env: {} }
   }
+  return parseLaunchEnv(text)
+}
+
+/** HOST-level launch.env of a runtime: `<root>/runtimes/<rt>/launch.env` (same format). Its env vars
+ *  apply to EVERY peer's session of that runtime, under the peer's own launch.env (the peer wins) — the
+ *  place for a host-default provider credential (docs/20 §Host-default provider). Directives
+ *  (PEER_START_ARGS / PEER_DISALLOWED_TOOLS) stay per-peer only. */
+export function hostLaunchEnvPath(runtime: Runtime, options: StorageOptions = {}): string {
+  return join(options.rootDir ?? resolveGlobalRoot(options.env), RUNTIMES_DIR, runtime, LAUNCH_ENV_FILE)
+}
+
+export function readHostLaunchEnv(runtime: Runtime, options: StorageOptions = {}): Record<string, string> {
+  try {
+    return parseLaunchEnv(readFileSync(hostLaunchEnvPath(runtime, options), 'utf8')).env
+  } catch {
+    return {}
+  }
+}
+
+/** The host-default OpenCode configuration (operator-owned): `<root>/runtimes/opencode/opencode.json`.
+ *  Every opencode peer starts from it; the peer's own `<private_dir>/opencode.json` overrides it. */
+export function opencodeHostConfigPath(options: StorageOptions = {}): string {
+  return join(options.rootDir ?? resolveGlobalRoot(options.env), RUNTIMES_DIR, 'opencode', 'opencode.json')
+}
+
+function parseLaunchEnv(text: string): LaunchEnv {
   const env: Record<string, string> = {}
   for (const rawLine of text.split(/\r?\n/)) {
     const line = rawLine.trim()

package/src/transport/index.ts

@@ -1080,12 +1080,31 @@ export interface ControlResult {
  * "specify runtime"). The clean-slash control namespace (interrupt/compact/…) is the
  * caller's; /alias_* expansions are message, not control (docs/Control §namespace).
  */
+/**
+ * Which session an operator control (interrupt / compact / …) WITHOUT a runtime acts on. An operator
+ * commands the DIALOGUE they see, not a session they must name: the dialogue a runtime-less send
+ * reaches is the peer's default_runtime (config-anchored, resolvePeerDeliveryTarget), so a LIVE
+ * default wins even when other runtimes are live too (incident 18.10: /stop on a peer with claude AND
+ * opencode live answered «specify runtime» while the opencode turn ran on). A dead default with
+ * exactly one live endpoint → that one (the only running session). Only a dead default with SEVERAL
+ * live endpoints stays ambiguous → explicit refusal. An explicit runtime is exact.
+ */
+export function resolveControlTarget(personality: string, runtime: string | undefined, env: NodeJS.ProcessEnv = process.env): Result<DeliveryTarget> {
+  if (runtime) return resolveDeliveryTarget({ personality, runtime, env })
+  const peer = findPeer(readPeersIndex({ env }), personality)
+  if (peer) {
+    const anchored = resolveDeliveryTarget({ personality, runtime: peer.runtime, env })
+    if (anchored.ok) return anchored
+  }
+  return resolveDeliveryTarget({ personality, env })
+}
+
 export async function routeControl(personality: string, runtime: string | undefined, command: ControlCommand): Promise<Result<ControlResult>> {
   if (!isValidName(personality)) {
     return err(`invalid personality "${personality}" — must match /^[a-z][a-z0-9-]{0,31}$/`)
   }
   if (runtime && !isRuntime(runtime)) return err(`invalid runtime "${runtime}"`)
-  const target = resolveDeliveryTarget({ personality, runtime })
+  const target = resolveControlTarget(personality, runtime)
   if (!target.ok) return err(`cannot control "${personality}": ${target.error.message}`)
   const done = await executeControlOnTarget(target.value, command)
   if (!done.ok) return done