fix(schedule): close review gaps

packages/schedule/tool-schedule/src/domain.ts

@@ -289,10 +289,10 @@ export function scheduleView(record: AfterScheduleRecord, now: number): Schedule
 
 /**
  * Derive the Web receipt for one dispatch from its owning stream segment.
- * A dispatch inside an inherited fork prefix folds that original prefix; a
- * child-owned dispatch folds only the child suffix, preserving the same
- * `seedLength` ownership rule as the live runtime while still allowing a
- * persisted parent receipt to render in child history.
+ * A dispatch inside an inherited fork prefix folds from its nearest preceding
+ * `session/end-seed` boundary; a child-owned dispatch folds only the child
+ * suffix. Nested forks can therefore reuse session-local ids without hiding a
+ * persisted ancestor receipt in descendant history.
  * @param events - Complete contiguous Session log.
  * @param dispatchSeq - Exact event seq to present.
  * @param seedLength - Inherited fork prefix length.
@@ -317,7 +317,9 @@ export function scheduleReminderPresentation(
   const dispatch = decodeScheduleChange(event.data)
   if (dispatch.operation !== 'dispatch') return undefined
 
-  const segmentStart = dispatchSeq < seedLength ? 0 : seedLength
+  const segmentStart = dispatchSeq < seedLength
+    ? events.slice(0, dispatchSeq).findLastIndex(candidate => candidate.type === 'session/end-seed') + 1
+    : seedLength
   const before = foldScheduleEvents(events.slice(segmentStart, dispatchSeq))
   const record = before.active.find(candidate => candidate.id === dispatch.id)
   if (record === undefined) {

packages/schedule/tool-schedule/src/runtime.ts

@@ -156,6 +156,22 @@ export class ScheduleOwner {
     )
   }
 
+  /** Fold the current exact owner suffix and contain a corrupt durable stream. */
+  private readEarliest(): AfterScheduleRecord | undefined {
+    try {
+      const folded = foldScheduleEvents(
+        this.agent.session.events,
+        this.agent.session.header.seedLength ?? 0,
+      )
+      return earliest(folded.active)
+    } catch (error: unknown) {
+      this.faulted = true
+      const detail = error instanceof ScheduleLogError ? error.message : renderThrown(error)
+      this.ctx.logger.warn(`tool-schedule: corrupt schedule log for agent "${this.agent.id}": ${detail}`)
+      return undefined
+    }
+  }
+
   /** Preflight, fold, arm, or dispatch the next active one-shot reminder. */
   private async driveOnce(): Promise<void> {
     this.clearTimer()
@@ -171,19 +187,7 @@ export class ScheduleOwner {
     // oxlint-disable-next-line typescript/no-unnecessary-condition -- disposal or replacement can win while persistence is awaited.
     if (this.stopping || !this.isLive()) return
 
-    let record: AfterScheduleRecord | undefined
-    try {
-      const folded = foldScheduleEvents(
-        this.agent.session.events,
-        this.agent.session.header.seedLength ?? 0,
-      )
-      record = earliest(folded.active)
-    } catch (error: unknown) {
-      this.faulted = true
-      const detail = error instanceof ScheduleLogError ? error.message : renderThrown(error)
-      this.ctx.logger.warn(`tool-schedule: corrupt schedule log for agent "${this.agent.id}": ${detail}`)
-      return
-    }
+    const record = this.readEarliest()
     if (record === undefined) return
 
     const target = Date.parse(record.scheduledAt)
@@ -193,47 +197,50 @@ export class ScheduleOwner {
       return
     }
 
-    const release = this.agent.reserveTurnAdmission()
-    if (release === undefined) {
-      this.waitForIdle()
+    let maintenance: Promise<boolean>
+    try {
+      maintenance = this.agent.runMaintenance(() => {
+        if (this.stopping || !this.isLive()) return Promise.resolve(false)
+        const claimedRecord = this.readEarliest()
+        if (claimedRecord === undefined) return Promise.resolve(false)
+        const claimedTarget = Date.parse(claimedRecord.scheduledAt)
+        const decisionNow = Date.now()
+        if (decisionNow < claimedTarget) {
+          this.arm(claimedTarget, decisionNow)
+          return Promise.resolve(false)
+        }
+        try {
+          const message = createUserMessage({
+            content: [{ type: 'text', text: renderReminderFraming(claimedRecord) }],
+            source: { kind: 'plugin', plugin: 'tool-schedule' },
+          })
+          this.agent.followup(message)
+        } catch (error: unknown) {
+          if (this.isLive()) {
+            this.ctx.logger.warn(`tool-schedule: framing or followup failed for agent "${this.agent.id}": ${renderThrown(error)}`)
+          }
+          return Promise.resolve(false)
+        }
+        try {
+          this.agent.session.append('schedule/change', {
+            version: 1,
+            operation: 'dispatch',
+            id: claimedRecord.id,
+          })
+        } catch (error: unknown) {
+          this.faulted = true
+          this.clearTimer()
+          this.ctx.logger.warn(`tool-schedule: dispatch append failed for agent "${this.agent.id}": ${renderThrown(error)}`)
+          return Promise.resolve(false)
+        }
+        return Promise.resolve(true)
+      })
+    } catch (_busy: unknown) {
+      // `runMaintenance` rejects synchronously only while another agent activity owns the idle phase.
+      if (this.isLive()) this.waitForIdle()
       return
     }
-
-    try {
-      // oxlint-disable-next-line typescript/no-unnecessary-condition -- reservation can invalidate the owner.
-      if (this.stopping || !this.isLive()) return
-      const decisionNow = Date.now()
-      if (decisionNow < target) {
-        this.arm(target, decisionNow)
-        return
-      }
-      const message = createUserMessage({
-        content: [{ type: 'text', text: renderReminderFraming(record) }],
-        source: { kind: 'plugin', plugin: 'tool-schedule' },
-      })
-      try {
-        this.agent.followup(message)
-      } catch (error: unknown) {
-        if (this.isLive()) {
-          this.ctx.logger.warn(`tool-schedule: followup failed for agent "${this.agent.id}": ${renderThrown(error)}`)
-        }
-        return
-      }
-      try {
-        this.agent.session.append('schedule/change', {
-          version: 1,
-          operation: 'dispatch',
-          id: record.id,
-        })
-      } catch (error: unknown) {
-        this.faulted = true
-        this.clearTimer()
-        this.ctx.logger.warn(`tool-schedule: dispatch append failed for agent "${this.agent.id}": ${renderThrown(error)}`)
-        return
-      }
-    } finally {
-      release()
-    }
+    if (!await maintenance) return
 
     try {
       await flushSchedulePersistence(this.ctx, this.agent.session)