@agfpd/iapeer 0.2.82 → 0.2.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.82",
+  "version": "0.2.83",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/lifecycle/index.ts

@@ -592,7 +592,7 @@ export function resolveWakeMode(
       : { resume: false, cause: 'idle-reaped-human-no-resume' }
   }
   // executor: RESUME is an INTENTIONAL "continue THIS work" signal — it happens ONLY when
-  // the incoming message carries a topic that matches the session's last topic. A DIFFERENT
+  // the incoming message carries a topic that matches the session's topic set. A DIFFERENT
   // topic (new work) OR NO topic at all → FRESH. Rationale: a topicless ping after an idle
   // gap is not a request to resume specific work; defaulting it to resume revived stale
   // context (e.g. a 3-day-old session). The sender opts INTO continuity by passing the topic.
@@ -1160,11 +1160,19 @@ export interface SuperviseOutcome {
 export interface SuperviseDeps {
   env?: NodeJS.ProcessEnv
   nowMs?: number
+  /** Activity proxy seam (default: the runtime adapter's transcript/session mtime). Tests inject a
+   *  controlled value to exercise the idle-age floor without a real transcript on disk. */
+  newestActivityMtime?: (runtime: string, cwd: string) => number | null
+  /** Liveness seam (default: the real `sessionAlive` = pty-host OR tmux-fallback). Tests inject a
+   *  fixed verdict so the idle path is exercised hermetically — no live tmux/pty session needed. */
+  sessionAlive?: (sock: string, identity: string) => boolean
 }
 
 export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): SuperviseOutcome[] {
   const env = deps.env ?? process.env
   const nowMs = deps.nowMs ?? Date.now()
+  const activityMtime = deps.newestActivityMtime ?? ((rt: string, c: string) => getAdapter(rt as Runtime).newestActivityMtime(c))
+  const isAlive = deps.sessionAlive ?? sessionAlive
   const verbose = superviseLogVerbose(env)
   // tmux command-log volume cap (killer-hunt socket-command layer, launch/cmdlog.ts):
   // a -v server log under a busy TUI grows ~7 KB/s, so each tick tail-keeps any log
@@ -1186,7 +1194,7 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
       continue
     }
     const sock = buildSocketPath(s.runtime, s.personality, cfg.sockDir)
-    if (!sessionAlive(sock, s.identity)) {
+    if (!isAlive(sock, s.identity)) {
       // A DELIBERATE stop is not a death: the stop verb parks clean
       // (.stopped + .idle-reaped) and kills the session itself. Catch-up branch for
       // a stop that raced this tick (or a pre-fix stop): drop the state quietly —
@@ -1235,14 +1243,19 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
       continue
     }
     // Idle accounting via the runtime adapter's activity proxy (claude transcript
-    // / codex session mtime); fall back to wokeAt so a session that produced zero
-    // further turns is still reaped, and when no adapter exists yet (codex/telegram
-    // pre-workflow-#2 — session-states are claude-only for now anyway).
+    // / codex session mtime), FLOORED at wokeAt: a session cannot be idle longer than
+    // it has been awake. A wake that produced no model turn (e.g. an attach-only resume)
+    // leaves the proxy at its PRE-wake value; the old `?? wokeAt` floored only the NULL
+    // case, so a stale-but-non-null proxy (older than this wake) made a freshly-woken
+    // session look idle for its entire prior life → idle-reaped on the very next tick,
+    // out from under an attaching operator. max(), not ??, is the fix — and it still
+    // reaps a session that produced zero further turns (mt=wokeAt → reaped idleSecs
+    // after the wake), and falls back to wokeAt when no adapter exists for the runtime.
     let mt = s.wokeAt
     try {
-      mt = getAdapter(s.runtime).newestActivityMtime(s.cwd) ?? s.wokeAt
+      mt = Math.max(activityMtime(s.runtime, s.cwd) ?? 0, s.wokeAt)
     } catch {
-      /* no adapter for this runtime yet → wokeAt fallback */
+      /* no adapter for this runtime yet → wokeAt baseline */
     }
     const ageSecs = Math.floor((nowMs - mt) / 1000)
     // wake_policy:ephemeral M2 — die-after-reply: an ARMED ephemeral session (the

package/src/transport/index.ts

@@ -494,7 +494,7 @@ export function deliverViaTmux(target: DeliveryTarget, envelope: string, cwd?: s
     } while (monotonicMs() < graceDeadline)
     return err(
       `peer "${target.personality}" (${target.runtime}) is listed live but did not accept the message ` +
-        `(no input-clear, no transcript advance within ${livenessGraceMs()}ms) — treated as dead; message NOT delivered`,
+        `(no input-clear, no transcript advance within ${livenessGraceMs()}ms) — live but unresponsive to this delivery (not dead); message NOT delivered`,
     )
   }
   sleepSync(PASTE_SETTLE_MS)
@@ -579,7 +579,7 @@ async function deliverViaHost(
   } while (monotonicMs() < graceDeadline)
   return err(
     `hosted peer "${target.personality}" (${target.runtime}) is listed live but did not accept the message ` +
-      `(no transcript advance within ${graceMs}ms) — treated as dead; message NOT delivered`,
+      `(no transcript advance within ${graceMs}ms) — live but unresponsive to this delivery (not dead); message NOT delivered`,
   )
 }