@agfpd/iapeer 0.4.127 → 0.4.128

package/docs/19-notices.md

@@ -456,7 +456,11 @@ five-hour wall at 04:55; claude painted «resets 8:30am», the daemon idle-reape
 3. **Nudge.** After `resetsAt + 3 min`, if the session made no progress since the event (claude: a
    real, non-`<synthetic>` assistant line after it; codex: a `task_complete` with a message whose
    `completed_at` is after it), the core delivers ONE continuation message through the normal
-   route — wake-on-miss resumes a reaped session (an idle reap is resume-eligible). Progress
+   route — wake-on-miss RESUMES a reaped session: the nudge carries an explicit continue-work
+   wake intent that satisfies the executor topic gate by itself (wake cause
+   `idle-reaped-continue`); it never outranks an owner `/new`, a soft-reload or a crash. Without
+   it the first live run (0.4.127) woke the peer FRESH (`idle-reaped-new-topic`) and the peer
+   answered «nothing to resume» — the very loss this section exists to prevent. Progress
    already made → the park is dropped without a message (no duplicate turn). A failed delivery is
    retried (5 min backoff, 3 attempts); an operator `stop` is never fought.
 4. **Sender** = the core's system identity `iapeer-system` (runtime `core`, intelligence

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.127",
+  "version": "0.4.128",
   "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/limitresume.ts

@@ -74,7 +74,10 @@ export async function processLimitResumes(
     }
     let reason: string
     try {
-      const r = await send(systemCaller(), { personality: p.personality, runtime: p.runtime, message: limitResumeMessage(p), topic: 'limit-resume' }, routeDeps)
+      // Topic = the stopped session's own thread (captured at park time), so the topic set still
+      // follows the work; the RESUME itself rides the explicit continue-work intent, not the topic.
+      const topic = p.topic || 'limit-resume'
+      const r = await send(systemCaller(), { personality: p.personality, runtime: p.runtime, message: limitResumeMessage(p), topic }, { ...routeDeps, wakeContinueWork: true })
       if (r.ok) {
         clearLimitPark(cfg, p.identity)
         log({ identity: p.identity, outcome: 'nudged', woke: String(r.value.woke), resets: new Date(p.resetsAtMs).toISOString() })

package/src/daemon/main.ts

@@ -140,7 +140,7 @@ const DAEMON_MAIN_PATH = fileURLToPath(import.meta.url)
 export function makeWakeFn(cfg: LifecycleConfig, env: NodeJS.ProcessEnv): WakeFn {
   return (req: WakeRequest): Promise<WakeOutcome> =>
     wakeOrSpawn(
-      { personality: req.personality, runtime: req.runtime, topic: req.topic, task: req.task },
+      { personality: req.personality, runtime: req.runtime, topic: req.topic, task: req.task, ...(req.continueWork ? { continueWork: true } : {}) },
       { cfg, env },
     )
 }
@@ -493,6 +493,7 @@ export async function startConfiguredDaemon(opts: ConfiguredDaemonOptions = {}):
         ...(d.file ? { file: d.file } : {}),
         ...(d.sessionId ? { sessionId: d.sessionId } : {}),
         errorType: d.errorType,
+        ...(readTopic(cfg, identity) ? { topic: readTopic(cfg, identity) } : {}),
       })
       if (fresh) appendLifecycleEvent(cfg.eventLogDir, { ev: 'limit-park', identity, resets: new Date(d.resetsAtMs).toISOString(), error_type: d.errorType }, { env })
     },

package/src/lifecycle/index.ts

@@ -653,6 +653,10 @@ export function resolveWakeMode(
    *  next resume/fresh decision (a crash-looping binary used to eat .idle-reaped, and after the fix the
    *  peer came back FRESH, its context lost). Absent → consume immediately (legacy/test callers). */
   defer?: (consume: () => void) => void,
+  /** The waking message is an explicit "continue THIS work" (the limit-resume nudge, docs/19 §9):
+   *  in the idle-reaped executor branch it satisfies the topic gate by itself. Never outranks an
+   *  owner's /new, a soft-reload, a folder-launch or a crash (those decide before 3b). */
+  continueWork?: boolean,
 ): WakeMode {
   const done = defer ?? ((f: () => void) => f())
   // 1. folder-launch → always fresh. Consume a standing .new-eager too — the mark's
@@ -725,6 +729,12 @@ export function resolveWakeMode(
   // 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 (continueWork) {
+    const r = resolveResume(cwd)
+    return r.ok
+      ? { resume: true, resumeRef: r.ref, cause: 'idle-reaped-continue' }
+      : { resume: false, cause: 'idle-reaped-no-resume' }
+  }
   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
@@ -967,6 +977,8 @@ export interface WakeArgs {
   /** First message delivered to the woken session (the routed envelope). */
   task: string
   resume?: boolean
+  /** Explicit "continue THIS work" intent — see resolveWakeMode `continueWork`. */
+  continueWork?: boolean
 }
 
 export interface WakeResult {
@@ -1124,6 +1136,7 @@ export async function wakeOrSpawn(args: WakeArgs, deps: WakeDeps = {}): Promise<
       c => adapter.resolveResume(c, { personality: args.personality, env }),
       args.topic,
       f => consumeOnUp.push(f),
+      args.continueWork,
     )
     const applyConsumed = (): void => {
       for (const f of consumeOnUp.splice(0)) {

package/src/lifecycle/limitpark.ts

@@ -42,6 +42,8 @@ export interface LimitPark {
   file?: string
   sessionId?: string
   errorType?: string
+  /** The session's most-recent topic when parked — the nudge continues that thread. */
+  topic?: string
   attempts?: number
   lastAttemptMs?: number
 }

package/src/transport/index.ts

@@ -1272,6 +1272,8 @@ export interface WakeRequest {
   topic?: string
   /** First message delivered to the woken session (the routed envelope). */
   task: string
+  /** Explicit "continue THIS work" intent (core-originated limit-resume only). */
+  continueWork?: boolean
 }
 export interface WakeOutcome {
   status: 'READY' | 'FAILED'
@@ -1347,6 +1349,9 @@ export interface ComposerQueueRouteDeps {
 }
 
 export interface RouteDeps {
+  /** A wake triggered by THIS send carries the "continue THIS work" intent (resume an idle-reaped
+   *  session regardless of topic). Set only by the core's limit-resume pass — never from a request. */
+  wakeContinueWork?: boolean
   /** Б7 — injected env sandboxes ALL of routeSend's env-resolved reads (the registry, the supervisor
    *  run-dir liveness/delivery). Default process.env (prod: env === process.env). Closes the daemon:286
    *  isolation invariant — a library/test daemon with an injected root no longer reads the real registry
@@ -1970,7 +1975,7 @@ async function routeSendInner(
         `(restart window outlasted the grace?) — message NOT delivered; retry`,
     )
   }
-  const woke = await deps.wake({ personality, runtime, topic, task: envelope })
+  const woke = await deps.wake({ personality, runtime, topic, task: envelope, ...(deps.wakeContinueWork ? { continueWork: true } : {}) })
   if (woke.status === 'FAILED') {
     // C1 — a durably STOPPED peer is a deliberate halt, not a transient miss:
     // surface the explicit "stopped" reason (no "offline and wake failed" wrapping).