@agfpd/iapeer 0.4.132 → 0.4.134

package/docs/12-cli-reference.md

@@ -77,7 +77,7 @@ The full list of `iapeer <command>`. General rules: `--help` / `-h` anywhere in
 |---|---|
 | `enable <plugin> [peer] [--no-setup]` | Install and enable a capability plugin for a peer (across runtimes), run its setup step. |
 | `native-memory <off\|on> (--peer <p> \| --all)` | Turn off/restore a peer's runtimes' native memory. |
-| `trust-hooks <hooks.json> [--check]` | Pre-trust codex hooks from a file (without the modal). `--check` — a divergence report. |
+| `trust-hooks <hooks.json> [--check]` | Pre-trust codex hooks from a file (without the modal). `--check` — a divergence report. The core also re-asserts the trust of `<cwd>/.codex/hooks.json` on EVERY codex launch (idempotent), and `rename` / `approval-mode yolo` restore what must stay trusted — a codex peer boots to its input with no human even after its trust was wiped (18.10). |
 
 ## Agent self-calls
 

package/docs/20-opencode.md

@@ -212,16 +212,23 @@ process was SIGKILLed before any answer, and the fresh next session never saw it
   session is gone or was replaced become orphans and are redelivered through the
   normal route as their original sender, prefixed `[redelivered by iapeer: …]`
   (wake-on-miss and the crash-loop guard apply). If redelivery fails, the sender
-  receives an explicit notice from `iapeer`. Logged as `ev=inflight-orphaned`
+  receives an explicit notice from the core identity `iapeer-system`. Logged as `ev=inflight-orphaned`
   (lifecycle.log) and `ev=inflight-redelivered|inflight-undelivered`
   (delivery.log).
 - A false «not processed» costs a visible duplicate, never a silent loss.
 - Interrupted turns. «Processed» (a model response began) is not «finished»: a
   turn killed mid-tool may already have had side effects, so it is never
   redelivered. The ledger keeps an entry until its turn finishes (claude: an
-  assistant record with a terminal `stop_reason`; codex: `task_complete`;
-  opencode: a completed assistant message for it with a finish other than
-  `tool-calls`); a finished later message covers earlier ones. If the session
+  assistant record with a terminal `stop_reason`, or claude's own interrupt
+  marker `[Request interrupted by user…]`; codex: `task_complete` or
+  `turn_aborted`; opencode: a completed assistant message for it with a finish
+  other than `tool-calls`); a finished later message covers earlier ones. An
+  operator interrupt is a finished turn, not a death (18.10: a turn the owner had
+  stopped was reported «INTERRUPTED» when the session later died for another
+  reason). A session that ends ITSELF (`self-fresh`) leaves a `<identity>.self-ended`
+  marker with its hosting token; the daemon's sweep settles that session's started
+  entries silently instead of notifying their senders (the peer declared the work
+  done); not-yet-started entries are redelivered to the fresh session as usual. If the session
   dies with the turn unfinished, the sender gets an explicit notice from iapeer
   («the turn was INTERRUPTED and its result is not guaranteed»), logged as
   `ev=inflight-interrupted`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.132",
+  "version": "0.4.134",
   "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/approval/install.ts

@@ -161,6 +161,10 @@ export function removeCodexApproval(cwd: string, env: NodeJS.ProcessEnv = proces
     return path
   }
   writeFileAtomic(path, `${JSON.stringify(obj, null, 2)}\n`, 0o644)
+  // The trust wipe above is cwd-wide (codex keys state POSITIONALLY, so removing our group shifts the
+  // others' keys). Re-seed whatever hooks REMAIN — the memory provider's among them — or the next codex
+  // boot stops at «hooks need review» (incident 18.10).
+  preSeedCodexHooksTrust(path, env)
   return path
 }
 

package/src/cli/index.ts

@@ -1439,9 +1439,13 @@ export async function renamePeerCli(
       const { preTrustCodexCwd, removeCodexCwdTrust } = await import('../launch/nativeMemory.ts')
       preTrustCodexCwd(newCwd, env)
       removeCodexCwdTrust(oldCwd, env)
-      const { removeCodexHooksTrustUnder } = await import('../launch/codexHooksTrust.ts')
+      const { removeCodexHooksTrustUnder, preSeedCodexHooksTrust } = await import('../launch/codexHooksTrust.ts')
       removeCodexHooksTrustUnder(oldCwd, env)
-      sideEffects.push('codex-trust: re-trusted new cwd + cleaned old')
+      // Hooks trust is keyed by the hooks.json PATH, so it must move with the cwd — without this a
+      // rename round-trip (a→b→a) wiped it entirely and codex stopped at «hooks need review» (18.10).
+      const newHooks = join(newCwd, '.codex', 'hooks.json')
+      if (existsSync(newHooks)) preSeedCodexHooksTrust(newHooks, env)
+      sideEffects.push('codex-trust: re-trusted new cwd (+ hooks) + cleaned old')
     } catch (e) {
       sideEffects.push(`codex-trust: failed (${e instanceof Error ? e.message : String(e)})`)
     }
@@ -3006,6 +3010,16 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         // see a dead session with no .new-eager → a plain reaped-gone (lazy fresh on the
         // next message), not the eager relaunch — degrade gracefully, never lose the mark.
         setNewEager(cfg, identity)
+        // The peer ends ITS OWN turn: tell the daemon's OC07 sweep this session ended itself, so the
+        // entries it had started are settled — not reported to their senders as INTERRUPTED.
+        try {
+          const { hostSessionToken } = await import('../launch/ptyHost.ts')
+          const { markSelfEnded } = await import('../lifecycle/inflight.ts')
+          const token = hostSessionToken(identity, env)
+          if (token) markSelfEnded(cfg.stateDir, identity, token)
+        } catch {
+          /* best-effort: without it the sender merely gets a false INTERRUPTED notice */
+        }
         out(`self-fresh: marked ${identity} for eager fresh re-launch; self-killing session\n`)
         const sock = buildSocketPath(addr.runtime, addr.personality, cfg.sockDir)
         killSession(sock, identity, env)

package/src/daemon/main.ts

@@ -81,7 +81,7 @@ import { startGoalWatch } from './goalwatch.ts'
 import { ActivityBoard, startTurnWatch } from './turnwatch.ts'
 import { defaultDaemonSocketPath, startDaemon, type DaemonHandle } from './index.ts'
 import { randomBytes } from 'crypto'
-import { listInflightIdentities, listInterruptedIdentities, listOrphanIdentities, recordInflight, sweepInflight, takeInterrupted, takeOrphans, type InflightEntry } from '../lifecycle/inflight.ts'
+import { clearSelfEnded, listInflightIdentities, listInterruptedIdentities, listOrphanIdentities, readSelfEnded, recordInflight, sweepInflight, takeInterrupted, takeOrphans, type InflightEntry } from '../lifecycle/inflight.ts'
 import { hostSessionAlive, hostSessionToken } from '../launch/ptyHost.ts'
 
 /** Default TCP loopback port for the always-on router. Real http MCP clients
@@ -321,13 +321,17 @@ export async function processInflight(
     }
   }
   for (const identity of listInflightIdentities(cfg.stateDir)) {
+    const selfEnded = readSelfEnded(cfg.stateDir, identity)
+    const current = hostSessionAlive(identity, env) ? hostSessionToken(identity, env) : null
     const n = sweepInflight(cfg.stateDir, identity, {
-      sessionToken: id => (hostSessionAlive(id, env) ? hostSessionToken(id, env) : null),
+      sessionToken: () => current,
+      selfEndedToken: selfEnded,
       processed,
       completed: seam.completed ?? ((e: InflightEntry) => deliveryCompleted(e, env)),
       landed: seam.landed ?? ((e: InflightEntry) => deliveryLanded(e, env)),
     })
     if (n > 0) appendLifecycleEvent(cfg.eventLogDir, { ev: 'inflight-orphaned', identity, count: n }, { env })
+    if (selfEnded && current !== selfEnded) clearSelfEnded(cfg.stateDir, identity) // that session is gone — settled
   }
   // A turn the session STARTED on a message but did not finish before dying: never redelivered (its side
   // effects may already have happened) — the sender is told explicitly that the result is not guaranteed.

package/src/launch/adapters/codex.ts

@@ -41,10 +41,11 @@
 
 import { homedir } from 'os'
 import { join } from 'path'
-import { readdirSync, realpathSync, statSync } from 'fs'
+import { existsSync, readdirSync, realpathSync, statSync } from 'fs'
+import { preSeedCodexHooksTrust } from '../codexHooksTrust.ts'
 import { codexSessionCwd, lastTimestampedEntryMs } from './transcriptTail.ts'
 import { detectNumberedModal } from './modalDetect.ts'
-import type { ApprovalMode, ControlCommand, ControlPlan, LaunchAdapterConfig, LaunchSpec, RuntimeAdapter } from '../types.ts'
+import type { ApprovalMode, ControlCommand, ControlPlan, LaunchAdapterConfig, LaunchSpec, PreparedLaunch, RuntimeAdapter } from '../types.ts'
 
 /**
  * The `/goal` subcommands we will type into a live codex session (see executeControl → 'goal').
@@ -170,6 +171,27 @@ export const codexAdapter: RuntimeAdapter = {
   kind: 'tui',
   usesDoctrine: true,
 
+  /**
+   * Hooks trust, re-asserted on EVERY launch (incident 18.10: oc-test-nemo/codex stopped at «PostToolUse
+   * hooks — 1 hook needs review» after a rename round-trip had wiped its `[hooks.state]` — a fresh codex
+   * that meets an untrusted hook waits for a human forever). The invariant «a codex peer boots to its
+   * input with no human» therefore lives HERE, not only at provision time: whatever erased the trust
+   * (rename, an approval-mode flip, a hand edit of config.toml), the next launch restores it. The peer's
+   * `.codex/hooks.json` is operator/provider-owned configuration, trusted like its `.mcp.json`.
+   * Idempotent (no write when the hashes already match); a failure is a launch WARNING, never a block —
+   * the modal is still better than no session, and the warning names it.
+   */
+  prepareLaunch(spec, _baseEnv, cfg): PreparedLaunch {
+    const env = cfg.env ?? process.env
+    const hooks = join(spec.cwd, '.codex', 'hooks.json')
+    const warnings: string[] = []
+    if (existsSync(hooks)) {
+      const t = preSeedCodexHooksTrust(hooks, env)
+      if (t.state === 'failed') warnings.push(`codex hooks trust not seeded (${t.detail ?? 'unknown'}) — a review modal may block the boot`)
+    }
+    return { env: {}, ...(warnings.length ? { warnings } : {}) }
+  },
+
   /**
    * Delivery markers for submitIntoTui (docs/Рантайм codex "Доставка"):
    *   - promptGlyphs ['›'] — codex's input-row arrow (the same stable invariant as

package/src/lifecycle/index.ts

@@ -1652,17 +1652,38 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
 export async function processEagerRelaunches(
   cfg: LifecycleConfig,
   outcomes: SuperviseOutcome[],
-  deps: WakeDeps & { wakeFn?: (args: WakeArgs, deps: WakeDeps) => Promise<WakeResult> } = {},
+  deps: WakeDeps & { wakeFn?: (args: WakeArgs, deps: WakeDeps) => Promise<WakeResult>; sessionAliveFn?: (identity: string) => boolean } = {},
 ): Promise<WakeResult[]> {
   const wake = deps.wakeFn ?? wakeOrSpawn
+  const env = deps.env ?? process.env
+  const alive = deps.sessionAliveFn ?? ((identity: string) => sessionAlive('', identity, env))
   const results: WakeResult[] = []
-  for (const o of outcomes) {
-    if (o.action !== 'needs-eager-fresh' || !o.personality) continue
+  const eager = outcomes.filter(o => o.action === 'needs-eager-fresh' && !!o.personality)
+  for (const o of eager) {
     clearNewEager(cfg, o.identity) // consume the eager mark — the relaunch is fresh by construction
+    // WHICH endpoint comes back. Two invariants meet here:
+    //  • H5 fleet-switch (12.06): a peer whose ONLY session self-freshes after `default-runtime` was
+    //    flipped must come back on the NEW default → re-resolve (no runtime pinned).
+    //  • Parallel endpoints (18.10): a peer live on several runtimes at once whose NON-default
+    //    endpoint self-freshes must get THAT endpoint back — re-resolving woke the default (already
+    //    live → no-op) and the claude endpoint of oc-test-nemo lay down.
+    // So: pin the dead endpoint's runtime when it is the default, or when the peer keeps another
+    // session (live now, or relaunched in this same batch); otherwise it was the peer's only
+    // session → re-resolve to the registry default.
+    let runtime: string | undefined
+    try {
+      const rec = findPeer(readPeersIndex({ env }), o.personality!)
+      const others = (rec?.runtimes ?? []).filter(rt => rt !== o.runtime)
+      const otherAlive = others.some(rt => alive(`${rt}-${o.personality}`))
+      const otherInBatch = eager.some(x => x !== o && x.personality === o.personality)
+      if (o.runtime && (o.runtime === rec?.runtime || otherAlive || otherInBatch)) runtime = o.runtime
+    } catch {
+      runtime = undefined // registry unreadable → the H5 default path
+    }
     try {
       results.push(
         await wake(
-          { personality: o.personality, task: '', resume: false },
+          { personality: o.personality!, ...(runtime ? { runtime } : {}), task: '', resume: false },
           { cfg, env: deps.env },
         ),
       )

package/src/lifecycle/inflight.ts

@@ -87,6 +87,9 @@ export function readInflight(stateDir: string, identity: string): InflightEntry[
 }
 
 export interface InflightSweepDeps {
+  /** Hosting token of a session that ENDED ITSELF (self-fresh) — its started entries are settled, not
+   *  reported interrupted. Absent → none. */
+  selfEndedToken?: string | null
   /** Current hosting token of the identity's session (null = no live session). */
   sessionToken: (identity: string) => string | null
   /** Did the receiving session answer this entry? */
@@ -138,6 +141,7 @@ export function sweepInflight(stateDir: string, identity: string, deps: Inflight
       // Answered but its turn did not finish: live → still working; gone → INTERRUPTED (side effects
       // may have happened — never redelivered, the sender is told).
       if (current !== null && current === e.sessionToken) keep.push(e)
+      else if (deps.selfEndedToken && e.sessionToken === deps.selfEndedToken) continue // the peer ended it itself
       else interrupted.push(e)
       continue
     }
@@ -207,3 +211,29 @@ export function purgeInflight(stateDir: string, identity: string): void {
   rmSync(orphansPath(stateDir, identity), { force: true })
   rmSync(interruptedPath(stateDir, identity), { force: true })
 }
+
+
+const selfEndedPath = (stateDir: string, identity: string) => join(stateDir, `${identity}.self-ended`)
+
+/**
+ * self-fresh: the peer's OWN turn declares its work done and ends its session. The CLI only drops this
+ * marker (the hosting token of the session that chose to end); the DAEMON's sweep — the single writer
+ * of the ledger — then closes that session's started entries instead of reporting them INTERRUPTED
+ * (false: the peer itself ended; live parity run 18.10). Not-yet-started entries are untouched and are
+ * redelivered to the fresh session as usual. No read-modify-write of the ledger outside the daemon.
+ */
+export function markSelfEnded(stateDir: string, identity: string, sessionToken: string): void {
+  writeFileSync(selfEndedPath(stateDir, identity), `${sessionToken}\n`, { mode: 0o600 })
+}
+
+export function readSelfEnded(stateDir: string, identity: string): string | null {
+  try {
+    return readFileSync(selfEndedPath(stateDir, identity), 'utf8').trim() || null
+  } catch {
+    return null
+  }
+}
+
+export function clearSelfEnded(stateDir: string, identity: string): void {
+  rmSync(selfEndedPath(stateDir, identity), { force: true })
+}

package/src/transport/index.ts

@@ -913,6 +913,13 @@ export function deliveryProcessed(probe: ProcessedProbe, env: NodeJS.ProcessEnv
  *   opencode — an assistant message for that user message with `time.completed` and a finish other
  *              than `tool-calls`.
  */
+/** claude's own record of an interrupted turn (user line whose text is the interrupt marker). */
+function isInterruptMarkerLine(o: { message?: unknown }): boolean {
+  const c = (o.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()))
+}
+
 export function deliveryCompleted(probe: ProcessedProbe, env: NodeJS.ProcessEnv = process.env): boolean {
   const needles = confirmNeedles(probe.rendered)
   if (!needles.length || needles.every(n => !n)) return false
@@ -968,6 +975,12 @@ export function deliveryCompleted(probe: ProcessedProbe, env: NodeJS.ProcessEnv
       }
       if (o.type === 'assistant' && ['end_turn', 'stop_sequence', 'max_tokens'].includes(o.message?.stop_reason ?? '')) return true
       if (o.type === 'event_msg' && o.payload?.type === 'task_complete') return true
+      // An operator INTERRUPT ends the turn too (claude: a `[Request interrupted by user…]` user line,
+      // codex: `turn_aborted`). Not counting it, a turn the owner had stopped was later reported to its
+      // sender as «INTERRUPTED by the session's death» once the session died for an unrelated reason
+      // (live parity run 18.10). OpenCode's abort already closes the assistant message, so it was right.
+      if (o.type === 'event_msg' && o.payload?.type === 'turn_aborted') return true
+      if (o.type === 'user' && isInterruptMarkerLine(o)) return true
     }
   }
   return false