@agfpd/iapeer 0.4.37 → 0.4.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.37",
+  "version": "0.4.38",
   "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/daemon/index.ts

@@ -192,6 +192,8 @@ export interface CallToolDeps {
    *  see transport.RouteDeps.noteLiveTopic. Injected so the daemon never imports
    *  lifecycle; the production main wires makeNoteLiveTopic. */
   noteLiveTopic?: (identity: string, topic: string) => void
+  /** В7 — confirmed-delivery stamp → the target's idle-proxy floor (see transport.RouteDeps.noteDelivered). */
+  noteDelivered?: (identity: string) => void
   /** Busy-human-composer queue — see transport.createComposerDeliveryQueue. */
   composerQueue?: ComposerQueueRouteDeps
   /** H4 launchd-managed detector — see transport.RouteDeps.isLaunchdManaged (the
@@ -219,6 +221,7 @@ export async function callTool(
       wake: deps.wake,
       ephemeral: deps.ephemeral,
       noteLiveTopic: deps.noteLiveTopic,
+      noteDelivered: deps.noteDelivered,
       composerQueue: deps.composerQueue,
       isLaunchdManaged: deps.isLaunchdManaged,
     })
@@ -390,6 +393,9 @@ export interface StartDaemonOptions extends StorageOptions {
    * main wires the lifecycle marker write (makeNoteLiveTopic).
    */
   noteLiveTopic?: (identity: string, topic: string) => void
+  /** В7 — confirmed-delivery stamp → the target's idle-proxy floor (setLastDelivered). OFF by default;
+   *  the production main wires it. */
+  noteDelivered?: (identity: string) => void
   /**
    * Busy-human-composer queue — async acceptance for live local TUI delivery when
    * an attached operator has non-dim text in the target composer. OFF by default
@@ -433,6 +439,7 @@ export async function startDaemon(opts: StartDaemonOptions = {}): Promise<Daemon
       onDelivered: opts.onDelivered,
       ephemeral: opts.ephemeral,
       noteLiveTopic: opts.noteLiveTopic,
+      noteDelivered: opts.noteDelivered,
       composerQueue: opts.composerQueue,
       isLaunchdManaged: opts.isLaunchdManaged,
     })

package/src/daemon/main.ts

@@ -42,6 +42,7 @@ import {
   readTopic,
   resolveWakeRuntime,
   setEphemeralArmed,
+  setLastDelivered,
   superviseTick,
   wakeOrSpawn,
   type LifecycleConfig,
@@ -222,6 +223,7 @@ export function makeComposerQueueRouteDeps(cfg: LifecycleConfig, env: NodeJS.Pro
     // flip + the shadow observer. tmux targets ignore it.
     logDir: cfg.logDir,
     noteLiveTopic,
+    noteDelivered: identity => setLastDelivered(cfg, identity),
     onDelivered,
     notifyFailed: async (job, reason) => {
       const index = readPeersIndex({ env })
@@ -330,6 +332,9 @@ export async function startConfiguredDaemon(opts: ConfiguredDaemonOptions = {}):
     // the wake resolver's executor discriminator then compares against the topic
     // the session last WORKED ON, not the one it woke with.
     noteLiveTopic,
+    // В7 — a confirmed live delivery floors the target's idle proxy (setLastDelivered), so a
+    // just-delivered message is never reaped away before its turn record lands.
+    noteDelivered: identity => setLastDelivered(cfg, identity),
     // Busy-human-composer queue: fast queued ack, async drain, fail all pending
     // on daemon close/update so a queued envelope is never silently lost.
     composerQueue,

package/src/lifecycle/index.ts

@@ -292,6 +292,34 @@ export function clearIdleReaped(cfg: LifecycleConfig, identity: string): void {
   }
 }
 
+function lastDeliveredPath(cfg: LifecycleConfig, identity: string): string {
+  return join(cfg.stateDir, `${identity}.last-delivered`)
+}
+
+/** Stamp the moment a live delivery to this session was CONFIRMED (В7). superviseTick folds this into
+ *  the idle proxy so a message delivered just as the session crosses idleSecs cannot be reaped out from
+ *  under the just-delivered message before the runtime writes its turn record — the receiver's own
+ *  process may not have appended the user-turn yet (codex socket-ack lands ok BEFORE ingest), so the
+ *  transcript proxy alone would miss it and the reap would silently drop the message behind ok:true. */
+export function setLastDelivered(cfg: LifecycleConfig, identity: string, nowMs: number = Date.now()): void {
+  mkdirSync(cfg.stateDir, { recursive: true, mode: 0o700 })
+  try {
+    writeFileSync(lastDeliveredPath(cfg, identity), String(nowMs), { mode: 0o600 })
+  } catch {
+    /* best-effort — the transcript proxy still governs; this only ADDS a floor, never removes one */
+  }
+}
+
+/** Epoch-ms of the last confirmed live delivery to this session, or 0 when none/unreadable. */
+export function readLastDelivered(cfg: LifecycleConfig, identity: string): number {
+  try {
+    const n = parseInt(readFileSync(lastDeliveredPath(cfg, identity), 'utf8').trim(), 10)
+    return Number.isFinite(n) && n > 0 ? n : 0
+  } catch {
+    return 0
+  }
+}
+
 function newEagerPath(cfg: LifecycleConfig, identity: string): string {
   return join(cfg.stateDir, `${identity}.new-eager`)
 }
@@ -1328,7 +1356,11 @@ function superviseOnePeer(s: SessionState, ctx: SuperviseCtx): SuperviseOutcome
   const ephemeral = isEphemeralPeer(s.cwd)
   let lt = 0
   try { lt = lastTurnMt(s.runtime, s.cwd) ?? 0 } catch { /* unreadable → wokeAt floor */ }
-  const mt = Math.max(lt, s.wokeAt)
+  // В7 — fold in the last CONFIRMED live delivery. A message delivered just as the session crosses
+  // idleSecs (codex acks BEFORE it writes the turn record) would otherwise be reaped out from under the
+  // just-delivered message before lt catches up — a silent loss behind ok:true. lastDelivered only ever
+  // RAISES the floor (a delivery is activity), so it can never keep a genuinely idle session alive.
+  const mt = Math.max(lt, s.wokeAt, readLastDelivered(cfg, s.identity))
   const ageSecs = Math.floor((nowMs - mt) / 1000)
   // wake_policy:ephemeral M2 — die-after-reply: an ARMED ephemeral session (the
   // daemon routed its outbound reply) is reaped after a QUIET window, checked

package/src/transport/index.ts

@@ -217,13 +217,37 @@ export interface WarmDeliverSeam {
  *     via launchd KeepAlive).
  * See `deliverViaHost`.
  */
+// В6 — per-target delivery serialization. deliverToHost is paste → 300ms settle → CR over the pty; two
+// CONCURRENT deliveries to the SAME hosted session interleave their frames (paste2 lands inside paste1's
+// settle window → CR1 submits the SPLICED "envelope1envelope2" as one turn, CR2 submits an empty
+// composer; for a router target the splice breaks the mate's per-envelope framing). Chain deliveries per
+// address so each paste+settle+CR (and its confirm) completes as a UNIT before the next to that address
+// starts. Different addresses stay parallel. Covers the DOMINANT path — every agent send_to_peer routes
+// through the SINGLE daemon process; a rare CLI in-process `iapeer send` is a separate process this chain
+// does not span (fully hermetic serialization would live in the supervisor as a per-session transaction).
+const deliverTails = new Map<string, Promise<unknown>>()
+
 export async function deliverWarm(
   target: DeliveryTarget,
   envelope: string,
   cwd?: string,
   seam: WarmDeliverSeam = {},
 ): Promise<Result<void>> {
-  return deliverViaHost(target, envelope, cwd, seam)
+  const address = target.address
+  const prev = deliverTails.get(address) ?? Promise.resolve()
+  // run AFTER prev settles (success or failure) — a prior delivery's error must not stall the chain
+  const run = prev.then(
+    () => deliverViaHost(target, envelope, cwd, seam),
+    () => deliverViaHost(target, envelope, cwd, seam),
+  )
+  deliverTails.set(
+    address,
+    run.then(
+      () => {},
+      () => {},
+    ),
+  )
+  return run
 }
 
 async function deliverViaHost(
@@ -890,6 +914,10 @@ export interface RouteDeps {
    *  imports lifecycle (layering — main.ts is where the two meet); call sites
    *  swallow hook errors (a hook must never fail a delivered message). */
   noteLiveTopic?: (identity: string, topic: string) => void
+  /** В7 — stamp a CONFIRMED live delivery (target identity) so superviseTick's idle proxy floors on it
+   *  and cannot reap the session before the just-delivered message's turn record lands. Injected (same
+   *  layering as noteLiveTopic — lifecycle.setLastDelivered wired in main.ts). */
+  noteDelivered?: (identity: string) => void
   /** H4 launchd-managed detector (injected so transport never imports lifecycle —
    *  main.ts wires the real `isLaunchdManaged`). A MISS on a launchd-managed target is
    *  almost always a TRANSIENT restart window (router restart on connect / `iapeer
@@ -913,6 +941,16 @@ function noteTopic(deps: RouteDeps, identity: string, topic: string | undefined)
   }
 }
 
+/** Best-effort lastDelivered stamp (В7) — records a CONFIRMED live delivery so the idle-reap proxy
+ *  cannot reap the session out from under a just-delivered message before its turn record lands. */
+function noteDelivered(deps: RouteDeps, identity: string): void {
+  try {
+    deps.noteDelivered?.(identity)
+  } catch {
+    /* a post-delivery hook must never fail the delivery */
+  }
+}
+
 export interface ComposerDeliveryQueueOptions {
   env?: NodeJS.ProcessEnv
   pollMs?: number
@@ -938,6 +976,8 @@ export interface ComposerDeliveryQueueOptions {
   deliver?: (target: DeliveryTarget, envelope: string, cwd?: string) => Result<void> | Promise<Result<void>>
   notifyFailed: (job: ComposerQueuedDelivery, reason: string) => void | Promise<void>
   noteLiveTopic?: (identity: string, topic: string) => void
+  /** В7 — stamp a confirmed queued delivery (same seam as RouteDeps.noteDelivered). */
+  noteDelivered?: (identity: string) => void
   onDelivered?: (caller: ResolvedCaller) => void
 }
 
@@ -1078,6 +1118,11 @@ export function createComposerDeliveryQueue(opts: ComposerDeliveryQueueOptions):
         await notifyFailed(job, `queued delivery to ${job.target.personality} (${job.target.runtime}) failed: ${delivered.error.message}`)
       } else {
         noteTopic({ noteLiveTopic: opts.noteLiveTopic }, job.target.address, job.topic)
+        try {
+          opts.noteDelivered?.(job.target.address) // В7 — floor the idle proxy for the queued delivery too
+        } catch {
+          /* best-effort */
+        }
         try {
           opts.onDelivered?.(job.caller)
         } catch {
@@ -1279,6 +1324,7 @@ export async function routeSend(
     const delivered = await deliverWarm(target.value, envelope, peer.cwd)
     if (!delivered.ok) return delivered
     noteTopic(deps, target.value.address, topic)
+    noteDelivered(deps, target.value.address) // В7 — floor the idle proxy so this delivery isn't reaped away
     return ok({
       ok: true,
       delivered_to: { personality: target.value.personality, runtime: target.value.runtime },