@agfpd/iapeer 0.4.132 → 0.4.133

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.133",
   "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

@@ -3006,6 +3006,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/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