@agfpd/iapeer 0.2.81 → 0.2.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.81",
+  "version": "0.2.82",
   "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 last topic. 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 }
   })