@agfpd/iapeer 0.2.81 → 0.2.83

package/package.json

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

@@ -35,6 +35,7 @@ import {
   drainEphemeralQueue,
   enqueueEphemeralTask,
   isEphemeralPeer,
+  addTopic,
   loadLifecycleConfig,
   processEagerRelaunches,
   readTopic,
@@ -42,7 +43,6 @@ import {
   setEphemeralArmed,
   superviseTick,
   wakeOrSpawn,
-  writeTopic,
   type LifecycleConfig,
 } from '../lifecycle/index.ts'
 import { appendLifecycleEvent } from '../lifecycle/eventlog.ts'
@@ -135,8 +135,8 @@ export function makeNoteLiveTopic(
 ): (identity: string, topic: string) => void {
   return (identity, topic) => {
     try {
-      if (readTopic(cfg, identity) === topic) return
-      writeTopic(cfg, identity, topic)
+      if (readTopic(cfg, identity) === topic) return // unchanged most-recent → no shift, skip the note
+      addTopic(cfg, identity, topic) // accumulate into the session's topic set (a new live thread)
       appendLifecycleEvent(cfg.eventLogDir, { ev: 'topic-note', identity, topic }, { env })
     } catch {
       /* the marker is a discriminator hint — never fail a delivered message */

package/src/lifecycle/index.ts

@@ -376,27 +376,63 @@ function topicPath(cfg: LifecycleConfig, identity: string): string {
   return join(cfg.stateDir, `${identity}.topic`)
 }
 
-/** Read the stored topic of the current/last session (executor discriminator). '' if none. */
-export function readTopic(cfg: LifecycleConfig, identity: string): string {
+// Per-session TOPIC SET (executor resume discriminator). The `.topic` file holds the
+// topics this session lineage has touched — newline-separated, most-recent LAST, deduped
+// and capped. A peer can carry several threads in ONE session, so resume matches the
+// incoming topic against ANY topic in the set: a later ping on an earlier thread continues
+// that session's context instead of starting fresh and redoing work. The set is RESET on a
+// FRESH wake (new lineage) and ACCUMULATES on the wake topic + every live delivery topic.
+const MAX_SESSION_TOPICS = 16
+
+/** All topics the current session lineage has touched (most-recent last). [] if none. */
+export function readTopics(cfg: LifecycleConfig, identity: string): string[] {
   try {
-    return readFileSync(topicPath(cfg, identity), 'utf8').trim()
+    return readFileSync(topicPath(cfg, identity), 'utf8')
+      .split('\n')
+      .map(t => t.trim())
+      .filter(Boolean)
   } catch {
-    return ''
+    return []
   }
 }
 
-/** Store the session's working topic (raw string, best-effort). Two writers: the
- *  wake (boot topic, wakeOrSpawn) and live deliveries via the noteLiveTopic seam
- *  (makeNoteLiveTopic) — so the marker follows the work, not just the boot. */
-export function writeTopic(cfg: LifecycleConfig, identity: string, topic: string): void {
+/** The session's MOST-RECENT topic (last in the set), or '' — single-value back-compat read. */
+export function readTopic(cfg: LifecycleConfig, identity: string): string {
+  const t = readTopics(cfg, identity)
+  return t.length ? t[t.length - 1]! : ''
+}
+
+/** Is `topic` (non-empty) one of the session lineage's topics? Drives resume-vs-fresh. */
+export function hasTopic(cfg: LifecycleConfig, identity: string, topic: string): boolean {
+  const t = topic.trim()
+  return !!t && readTopics(cfg, identity).includes(t)
+}
+
+/** Add a topic to the session's set (most-recent-last, deduped, capped). Empty → no-op.
+ *  Two callers: the wake (boot topic, wakeOrSpawn) and live deliveries via the noteLiveTopic
+ *  seam (makeNoteLiveTopic) — so the set follows the work, not just the boot. Best-effort. */
+export function addTopic(cfg: LifecycleConfig, identity: string, topic: string): void {
+  const t = topic.trim()
+  if (!t) return
   mkdirSync(cfg.stateDir, { recursive: true, mode: 0o700 })
   try {
-    writeFileSync(topicPath(cfg, identity), topic, { mode: 0o600 })
+    const set = readTopics(cfg, identity).filter(x => x !== t)
+    set.push(t)
+    writeFileSync(topicPath(cfg, identity), set.slice(-MAX_SESSION_TOPICS).join('\n') + '\n', { mode: 0o600 })
   } catch {
     /* best-effort — topic is a discriminator hint, never blocks a wake */
   }
 }
 
+/** Drop the session's topic set — a FRESH wake starts a new lineage with no carried topics. */
+export function resetTopics(cfg: LifecycleConfig, identity: string): void {
+  try {
+    rmSync(topicPath(cfg, identity), { force: true })
+  } catch {
+    /* best-effort */
+  }
+}
+
 /**
  * Purge EVERY identity-keyed lifecycle artifact of `<identity>` from stateDir:
  * the marker files (`.stopped` / `.idle-reaped` / `.deaths` / `.topic` /
@@ -555,10 +591,17 @@ export function resolveWakeMode(
       ? { resume: true, resumeRef: r.ref, cause: 'idle-reaped-human' }
       : { resume: false, cause: 'idle-reaped-human-no-resume' }
   }
-  // executor: a NEW topic (non-empty and differing from the stored one) means new
-  // work → FRESH; same topic, or no incoming topic → continue the work → 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 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.
   const topic = incomingTopic?.trim() ?? ''
-  if (topic && topic !== readTopic(cfg, identity)) return { resume: false, cause: 'idle-reaped-new-topic' }
+  if (!topic) return { resume: false, cause: 'idle-reaped-no-topic' }
+  // RESUME if the incoming topic matches ANY thread this session lineage worked on — not
+  // just the last. Different threads accumulate in one session; a later ping on an earlier
+  // thread continues that context. A topic the session never touched → new work → FRESH.
+  if (!hasTopic(cfg, identity, topic)) return { resume: false, cause: 'idle-reaped-new-topic' }
   const r = resolveResume(cwd)
   return r.ok
     ? { resume: true, resumeRef: r.ref, cause: 'idle-reaped-resume' }
@@ -1053,9 +1096,12 @@ export async function wakeOrSpawn(args: WakeArgs, deps: WakeDeps = {}): Promise<
     // reply. ONLY here on the actual launch path, NEVER on the live-session fast path
     // above (a live session may be legitimately armed mid-quiet-window).
     clearEphemeralArmed(cfg, identity)
-    // Establish the session's topic (executor discriminator) and reset the crash-loop
-    // ring — a successful wake means this is NOT a tight crash loop. Best-effort.
-    writeTopic(cfg, identity, args.topic?.trim() ?? '')
+    // Establish/extend the session's topic SET (executor resume discriminator) and reset the
+    // crash-loop ring. A FRESH wake starts a new lineage → drop the old topic set; a RESUME
+    // keeps accumulating. The wake's own topic joins the set (no-op if empty). resolveWakeMode
+    // already read the OLD set above, so mutating here is safe. Best-effort.
+    if (!mode.resume) resetTopics(cfg, identity)
+    addTopic(cfg, identity, args.topic?.trim() ?? '')
     trimDeaths(cfg, identity, cfg.crashLoopWindowSecs, Date.now())
     return { status: 'READY', woke: true, runtime, process_address: identity, taskDelivered: true }
   })
@@ -1114,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
@@ -1140,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 —
@@ -1189,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`,
   )
 }