@agfpd/iapeer 0.4.37 → 0.4.39

package/package.json

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

@@ -22,6 +22,7 @@ import {
   frame,
   makeFramer,
   parseSize,
+  splitDanglingEscape,
   stripQueries,
 } from './protocol.ts'
 import { attachedPath, geometryPath, pidPath, servePath, sockPath, writeGeometry } from './paths.ts'
@@ -86,6 +87,10 @@ const BOOT_DRIVE_MS = 120_000
 // survives the hold (our key did not take), the next tick re-fires, so retries stay bounded, not lost.
 const NAG_POLL_MS = 2000
 const NAG_COOLDOWN_MS = 4000
+// В25 — cap the attach-snapshot stabilization wait: under saturating output the model never goes quiet,
+// so without a budget firstAttach would never complete (frozen attach). On timeout we snapshot the
+// current model; live-forward delivers the rest once the gate lifts.
+const MODEL_STABLE_BUDGET_MS = 500
 
 // Bun-native PTY (Bun ≥1.3.5) is not yet in @types/bun — type the slice we use.
 interface PtyChild {
@@ -187,7 +192,7 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   // (same inode) so a normal cap never triggers a spurious reopen. Tied to output (no idle wakeups) —
   // exactly when the log matters.
   const healPaneLog = (): void => {
-    if (!opts.paneLogPath || paneLogFd < 0) return
+    if (!opts.paneLogPath) return
     const now = Date.now()
     if (now - paneLogCheckedMs < PANELOG_HEAL_MS) return
     paneLogCheckedMs = now
@@ -197,7 +202,12 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
     } catch {
       ino = -1 // path gone
     }
-    if (ino !== paneLogIno) openPaneLog()
+    // В19 — reopen when the fd is DEAD (initial open failed / a prior reopen failed) as well as when the
+    // path maps to a DIFFERENT inode (unlinked/replaced). The old `paneLogFd < 0` early-return above made
+    // a single failed open PERMANENT — the log stayed blind for the whole session (composer-busy detect,
+    // telegram typing, boot ready-gate all read this file). fd<0 with ino=-1 (path also gone) still needs
+    // a reopen attempt: openPaneLog recreates the file.
+    if (paneLogFd < 0 || ino !== paneLogIno) openPaneLog()
   }
   openPaneLog()
 
@@ -210,7 +220,11 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   // NO E3 capability) → smeared/overlapping scroll-up history. After the catch-up the supervisor does
   // NOTHING on resize — the child redraws its viewport (SIGWINCH) and the terminal reflows its own
   // scrollback, like a directly-launched claude.
-  const painted = new WeakSet<object>()
+  // В23 — a SET (not a WeakSet) so `.size` gates the .attached marker on INTERACTIVE clients only. A
+  // client is painted iff it sent a FRAME_RESIZE (runClient always does on connect; a deliver-client
+  // NEVER resizes). Using clients.size counted deliver-clients too → a delivery briefly marked "human
+  // attached", falsely holding a concurrent delivery in the composer queue. Kept in sync with removals.
+  const painted = new Set<object>()
   // INITIALIZING GATE (scrollback fix): a client is held OUT of live output-forwarding from connect until
   // its one-time attach snapshot has been sent. Without this, live frames (claude's relative-cursor
   // redraws) race ahead of the snapshot and corrupt the fresh terminal. The model still ingests those
@@ -223,6 +237,10 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   // write's parse-callback; `writeSeq` bumps on every write so the drain can detect new arrivals mid-await.
   let writeChain: Promise<void> = Promise.resolve()
   let writeSeq = 0
+  // В24 — a trailing INCOMPLETE escape sequence carried from one child-output chunk to the next, so a
+  // capability query split across a pty read boundary is detected/stripped as a whole (client-facing only;
+  // the model + pane-log always get the raw bytes immediately).
+  let queryTail = ''
   // ATTACHED-CLIENT MARKER (spawn-flip Ф0b-3 slice 3c): keep `<runDir>/<session>.attached` in sync with
   // clients.size — present iff ≥1 operator is attached. The warm-deliver path (a DIFFERENT process)
   // reads it to gate the hosted busy-composer hold: hold ONLY when a human is attached (their unfinished
@@ -231,7 +249,9 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   const attachedMarker = attachedPath(runDir, session)
   const syncAttached = (): void => {
     try {
-      if (clients.size > 0) writeFileSync(attachedMarker, '')
+      // В23 — gate on PAINTED (interactive) clients, not raw client count: a deliver-client connection
+      // must never read as "a human is attached".
+      if (painted.size > 0) writeFileSync(attachedMarker, '')
       else if (existsSync(attachedMarker)) unlinkSync(attachedMarker)
     } catch {
       /* */
@@ -253,7 +273,11 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   /** Backpressure-safe send to one client; drop it (and report false) if its socket is dead. */
   const sendClient = (s: { write(b: Buffer): number }, buf: Buffer): boolean => {
     const ok = writerFor(s).send(buf)
-    if (!ok) clients.delete(s)
+    if (!ok) {
+      clients.delete(s)
+      painted.delete(s as object) // В23 — keep the painted set (marker gate) in sync on every drop
+      syncAttached()
+    }
     return ok
   }
 
@@ -269,19 +293,26 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
         const buf = Buffer.isBuffer(d) ? d : typeof d === 'string' ? Buffer.from(d, 'utf8') : Buffer.from(d)
         // PANE-LOG: the RAW child bytes, exactly as pipe-pane writes them (before any query-stripping
         // for clients) — written as a Buffer, never a string. The `s` below is for query DETECTION only.
-        if (paneLogFd >= 0) {
-          healPaneLog() // reopen if the path was unlinked/replaced out from under us (Defect 2)
-          try {
-            writeSync(paneLogFd, buf)
-          } catch {
-            /* best-effort */
+        if (opts.paneLogPath) {
+          healPaneLog() // reopen if never-opened / unlinked / replaced out from under us (Defect 2 + В19)
+          if (paneLogFd >= 0) {
+            try {
+              writeSync(paneLogFd, buf)
+            } catch {
+              /* best-effort */
+            }
           }
         }
-        const s = buf.toString('latin1')
         writeSeq++ // a new write arrived (lets the attach drain detect bytes that land mid-await)
-        writeChain = new Promise<void>(resolve => xterm.write(buf, () => resolve())) // authoritative model (+ parse barrier)
-        for (const r of capabilityResponses(s)) child.terminal.write(r) // answer capability queries
-        const fwd = Buffer.from(stripQueries(s), 'latin1') // forward to clients sans queries (daemon is authoritative)
+        writeChain = new Promise<void>(resolve => xterm.write(buf, () => resolve())) // authoritative model (+ parse barrier) — RAW bytes
+        // В24 — run capability detect/strip over the chunk PLUS any carried tail, holding back a trailing
+        // INCOMPLETE escape for the next chunk so a query split across a pty read boundary is matched as a
+        // whole. The model + pane-log above get the RAW bytes immediately; only the client-facing detect/
+        // strip is tail-buffered (the held bytes reach the client next chunk, once complete).
+        const [complete, dangling] = splitDanglingEscape(queryTail + buf.toString('latin1'))
+        queryTail = dangling
+        for (const r of capabilityResponses(complete)) child.terminal.write(r) // answer capability queries
+        const fwd = Buffer.from(stripQueries(complete), 'latin1') // forward to clients sans queries (daemon is authoritative)
         if (fwd.length) {
           // Forward live output to every ATTACHED client — but NOT to one still INITIALIZING (its
           // snapshot hasn't been sent; these bytes are already in the model and will be in that snapshot,
@@ -337,6 +368,12 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   // bytes still land in the model and bump writeSeq — loop until the sequence holds steady so the snapshot
   // reflects every byte received so far (no stale screen, no dropped tail).
   const awaitModelParsedStable = async (): Promise<void> => {
+    // В25 — BOUND the stabilization. Under a saturating output stream (a big file dump, a verbose build,
+    // a tailing log) every await window sees a new write → seq never holds steady → firstAttach never
+    // completes, so the attaching operator sees a FROZEN blank screen while their keystrokes go to the
+    // child blind. Cap the wait: on timeout, snapshot the CURRENT model — bytes that land after are
+    // delivered by normal live-forward once the gate lifts (the model already ingests them).
+    const deadline = Date.now() + MODEL_STABLE_BUDGET_MS
     for (;;) {
       const seq = writeSeq
       try {
@@ -345,6 +382,7 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
         /* a write parse-callback should not reject */
       }
       if (seq === writeSeq) return
+      if (Date.now() > deadline) return // saturating output — snapshot now, live-forward catches the rest
     }
   }
   // Build + send the one-time attach SNAPSHOT (full resolved model: scrollback + screen + cursor + SGR colour
@@ -428,6 +466,7 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
       const sz = parseSize(payload)
       if (!painted.has(s as object)) {
         painted.add(s as object)
+        syncAttached() // В23 — this client is now INTERACTIVE (it resized) → the .attached marker reflects it
         void firstAttach(s, sz.cols, sz.rows) // split-resize: model → snapshot → gate-lift → child (clean frame0)
       } else {
         applyGeometry(sz.cols, sz.rows) // LATER resize: one real resize, no re-snapshot
@@ -458,16 +497,18 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
         framers.get(s)?.(d)
       },
       drain(s: object) {
-        if (!writers.get(s)?.flush()) { clients.delete(s); syncAttached() } // writable again → flush queued tail
+        if (!writers.get(s)?.flush()) { clients.delete(s); painted.delete(s); syncAttached() } // writable again → flush queued tail
       },
       close(s: object) {
         clients.delete(s)
+        painted.delete(s)
         writers.delete(s)
         syncAttached()
         restoreServeGeometryIfIdle() // last client gone → un-stick the pty from its size
       },
       error(s: object) {
         clients.delete(s)
+        painted.delete(s)
         writers.delete(s)
         syncAttached()
         restoreServeGeometryIfIdle()
@@ -542,8 +583,16 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
       } catch {
         return // transient model read — retry next tick
       }
+      // В21 — check the deadline FIRST, independent of the action. Previously the clearInterval only
+      // fired in the `else` branch, so a boot-dialog predicate that kept returning 'dialog' (a resume-
+      // picker whose layout changed after a claude update, a screen matching the dialog pattern) drove
+      // keystrokes into the pty EVERY tick for the whole session — the BOOT_DRIVE_MS backstop was dead.
+      if (Date.now() > driveDeadline) {
+        clearInterval(driver)
+        return
+      }
       if (action.kind === 'dialog') child.terminal.write(action.bytes)
-      else if (action.kind === 'ready' || Date.now() > driveDeadline) clearInterval(driver)
+      else if (action.kind === 'ready') clearInterval(driver)
     }, BOOT_POLL_MS)
     ;(driver as { unref?: () => void }).unref?.()
   }

package/src/supervisor/protocol.ts

@@ -70,6 +70,51 @@ export function stripQueries(s: string): string {
   return s.replace(QUERY_RE, '')
 }
 
+// ── chunk-boundary query buffering (В24) ────────────────────────────────────────
+// A capability query split across a pty read boundary (`\x1b[>` in one chunk, `q` in the next)
+// matches NEITHER chunk → the daemon neither answers nor strips it, and the fragment LEAKS to an
+// attached client whose real terminal answers it as keystrokes into the child. Before running the
+// capability detect/strip on a chunk, carry a trailing INCOMPLETE escape into the next one.
+
+const MAX_DANGLING = 16 // a real short query fits well within this — a longer trailing ESC is passed through
+
+function isCompleteEscape(seq: string): boolean {
+  if (seq.length < 2) return false // a bare ESC — could begin any sequence
+  switch (seq[1]) {
+    case '[': {
+      // CSI — parameter/intermediate bytes then a FINAL byte 0x40–0x7e
+      for (let i = 2; i < seq.length; i++) {
+        const c = seq.charCodeAt(i)
+        if (c >= 0x40 && c <= 0x7e) return true
+      }
+      return false
+    }
+    case ']':
+    case 'P':
+    case 'X':
+    case '^':
+    case '_':
+      // OSC / DCS / SOS / PM / APC — terminated by BEL or ST (\x1b\)
+      return seq.includes('\x07') || seq.includes('\x1b\\')
+    case 'O':
+      return seq.length >= 3 // SS3 (ESC O <byte>)
+    default:
+      return true // any other 2-byte escape (ESC + one final char) is complete once the 2nd byte arrives
+  }
+}
+
+/** Split `s` into [complete, dangling]: `dangling` is a trailing incomplete escape sequence to prepend
+ *  to the NEXT chunk before capability detect/strip. Bounded — a lone trailing ESC with no follow-up
+ *  never stalls the forward forever (it is passed through once it exceeds MAX_DANGLING). Pure/testable. */
+export function splitDanglingEscape(s: string): [string, string] {
+  const esc = s.lastIndexOf('\x1b')
+  if (esc < 0) return [s, '']
+  const tail = s.slice(esc)
+  if (tail.length > MAX_DANGLING) return [s, '']
+  if (isCompleteEscape(tail)) return [s, '']
+  return [s.slice(0, esc), tail]
+}
+
 // ── key-name → pty bytes (boot-driver, serving slice a) ─────────────────────────
 // Translate a tmux send-keys-style key list into the raw bytes a pty expects, so the supervisor
 // boot-driver can answer startup dialogs (codex trust/update/hooks, claude trust/resume-picker) off

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