@zhushanwen/pi-scheduler 0.3.4 → 0.4.1

package/src/backend.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import type { DeliveryHandle } from '@xyz-agent/session-delivery'
 
 import { replayFoldEntries, type SchedulerEntryLike } from './replay.js'
 import type { ScheduledTask, SchedulerEntryOp } from './types.js'
@@ -12,7 +13,7 @@ import type { ScheduledTask, SchedulerEntryOp } from './types.js'
  * - sendMessage: 到期 dispatch 的消息注入（生产实现委托 pi.sendMessage）
  * - appendEntry: 按 op 写 pi-scheduler:task custom entry（event sourcing）。
  *   生产实现委托 pi.appendEntry（同步落盘）。失败必须被调用方 try-catch（ER-APPEND-FAIL：
- *   runtime 捕获后 console.warn + 不 rethrow，内存态已更新，at-least-once 已知恶化窗口）
+ *   runtime 捕获后 logger.warn + 不 rethrow，内存态已更新，at-least-once 已知恶化窗口）
  * - getSessionFile: 当前 session JSONL 路径（addTask 构建 upsert op 的 ownerSessionFile 用；
  *   --no-session 模式返回 undefined，调用方 ?? '' 兜底）
  * - now: 时间源（测试可注入固定值）
@@ -33,6 +34,8 @@ export interface SchedulerBackend {
   appendEntry(op: SchedulerEntryOp): void
   getSessionFile(): string | undefined
   now(): number
+  /** 获取 delivery handle（装配点注入；未注入时 force 路径仍用 sendMessage 直投）。 */
+  getDeliveryHandle?(): DeliveryHandle | undefined
 }
 
 /**
@@ -59,6 +62,7 @@ export interface SchedulerBackendCtx {
 export class PiSchedulerBackend implements SchedulerBackend {
   private ctx: SchedulerBackendCtx
   private pi: Pick<ExtensionAPI, 'sendMessage' | 'appendEntry'>
+  private deliveryHandle: DeliveryHandle | undefined
 
   constructor(ctx: SchedulerBackendCtx, pi: Pick<ExtensionAPI, 'sendMessage' | 'appendEntry'>) {
     this.ctx = ctx
@@ -93,6 +97,18 @@ export class PiSchedulerBackend implements SchedulerBackend {
   now(): number {
     return Date.now()
   }
+
+  /**
+   * 注入 delivery handle（装配点创建后调用）。
+   * runtime 通过 getDeliveryHandle() 获取，非 force 任务走内核队列。
+   */
+  setDeliveryHandle(handle: DeliveryHandle): void {
+    this.deliveryHandle = handle
+  }
+
+  getDeliveryHandle(): DeliveryHandle | undefined {
+    return this.deliveryHandle
+  }
 }
 
 // ── 测试实现 ──
@@ -120,6 +136,7 @@ export class MockSchedulerBackend implements SchedulerBackend {
   fakeSessionFile: string | undefined = '/test/session.json'
   nowValue: number | undefined
   appendError: Error | null = null
+  deliveryHandle: DeliveryHandle | undefined
 
   async sendMessage(
     msg: { content: string; customType: string; display: boolean },
@@ -141,6 +158,10 @@ export class MockSchedulerBackend implements SchedulerBackend {
     return this.nowValue ?? Date.now()
   }
 
+  getDeliveryHandle(): DeliveryHandle | undefined {
+    return this.deliveryHandle
+  }
+
   /**
    * 读路径（非接口成员，与 PiSchedulerBackend.loadTasks 对称）：经 replayFoldEntries 折叠
    * fakeEntries + fakeSessionFile 恢复任务。测试用它验证 backend→replay 委托（TC-W-BACKEND-REPLAY）。

package/src/importer.ts

@@ -4,9 +4,12 @@ import * as path from 'node:path'
 
 import { getAgentDir } from '@earendil-works/pi-coding-agent'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { getLogger } from '@zhushanwen/pi-extension-logger'
 
 import type { ScheduledTask, SchedulerEntryOp, SchedulerStore, TaskSnapshot } from './types.js'
 
+const logger = getLogger('scheduler')
+
 /**
  * 获取旧 store 文件路径：scheduler/<root>/<segments>/scheduler.json，双候选探测。
  *
@@ -143,9 +146,9 @@ function importFromFile(
   // 空 store（0 任务）无持久化依赖，直接删；resumed session（sessionFile 已存在）已即时落盘，删
   if (tasks.length === 0 || fs.existsSync(currentSessionFile)) {
     fs.unlinkSync(importedPath)
-    // 内部诊断日志（非用户可见消息）：用 console.warn 而非 console.log（项目 convention：
-    // extensions 禁 console.log/info 防泄漏到 TUI；诊断输出统一 console.warn）
-    console.warn(`[scheduler] imported ${tasks.length} legacy tasks from ${importedPath}`)
+    // 内部诊断日志（非用户可见消息）：经共享 logger.warn → appendEntry 持久化为 custom entry，
+    // 不污染 TUI（logging-conventions SSOT：诊断走 logger.warn，禁裸 console）。
+    logger.warn('imported legacy tasks', { count: tasks.length, path: importedPath })
     return undefined
   }
 
@@ -155,9 +158,10 @@ function importFromFile(
   // 出现 → 删；仍未 flush → 静默保留 .imported 供下次 session_start 的 handleImportedResidue
   // 崩溃恢复重导入。跨 session 重导入窗口 = session_start → 首个 turn_end（秒级）：turn_end 后
   // .imported 已删，后续 session 启动看不到残留 → 双导入窗口闭合（R-CONCURRENT-IMPORT 已更新）
-  console.warn(
-    `[scheduler] imported ${tasks.length} legacy tasks (session not flushed; deferring ${importedPath} removal)`,
-  )
+  logger.warn('imported legacy tasks (session not flushed; deferring removal)', {
+    count: tasks.length,
+    path: importedPath,
+  })
   return () => {
     // 幂等：已删（本进程或并发另一进程已处理）→ no-op。cleanup 在每次 turn_end 都会调用，重复调用安全
     if (!fs.existsSync(importedPath)) return
@@ -216,7 +220,7 @@ function handleImportedResidue(
  * 内存 fileEntries，紧接的 loadTasks replay 统一重放读到导入任务（pi _appendEntry 同步 push
  * fileEntries，design-review 已实测验证）。
  *
- * 整体降级（C1）：read/parse/appendEntry 任一异常 → console.warn + 不 rethrow，不让
+ * 整体降级（C1）：read/parse/appendEntry 任一异常 → logger.warn + 不 rethrow，不让
  * session_start 崩溃（与 replay gap4 / ER-APPEND-FAIL 同款降级语义）。append 中途失败时
  * .imported 保留（不 unlink）——下次 session 的 handleImportedResidue 会重导入全部任务，
  * 已成功 append 的子集可能跨 session 双触发；取舍：删除则失败任务永久丢失（更糟），
@@ -255,9 +259,7 @@ export function importLegacyStore(
     return importFromFile(importedPath, pi, currentSessionFile)
   } catch (err) {
     // C1 整体降级：read/parse/appendEntry 任一异常不崩 session_start
-    console.warn(
-      `[scheduler] import failed: ${err instanceof Error ? err.message : String(err)}`,
-    )
+    logger.warn('import failed', { error: err instanceof Error ? err.message : String(err) })
     return undefined
   }
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import { createDelivery, type DeliveryHandle, type DeliveryMessage } from '@xyz-agent/session-delivery'
 
 import { PiSchedulerBackend } from './backend.js'
 import { registerScheduleCommand } from './commands.js'
@@ -43,6 +44,7 @@ let sessionGeneration = 0
  */
 export default function schedulerExtension(pi: ExtensionAPI): void {
   let service: SchedulerService | null = null
+  let deliveryHandle: DeliveryHandle | undefined
   // IMPORT-FLUSH-GUARD（MF-1）：importLegacyStore 对未 flush 的新 session 返回延迟删除 .imported
   // 的 cleanup——turn_end / session_shutdown 时执行：确认 flush（sessionFile 已出现）则删，
   // 未 flush 保留供崩溃恢复重导入（否则未 flush 即退出 → 全部旧任务丢失且源文件已销毁）。
@@ -66,15 +68,58 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
     // 窗口与 session 替换交错时旧 session_shutdown 可能永远等不到（timer 泄漏源头）。stopScheduler 幂等，
     // shutdown 已停过再停一次无副作用。
     service?.runtime.stopScheduler()
+    // 销毁旧 delivery handle（清队列 + 清 timer + 退订 settled）
+    deliveryHandle?.dispose()
     // 装配点：backend（ctx.sessionManager 读 entries / pi.appendEntry 写 op）→ runtime（内存态 + 调度）→ service（业务入口）
     const backend = new PiSchedulerBackend(ctx, pi)
     // 旧 store 原子导入（CL3 方案A）：必须在 backend.loadTasks() 之前执行——
     // append 的 upsert entry 进入 pi 内存 fileEntries，紧接的 loadTasks replay 统一重放读到导入任务。
     // ctx.cwd 类型为 string（SDK ExtensionContext 必填），无需 ?? process.cwd() 兜底（CL2）。
     importCleanup = importLegacyStore(ctx.cwd, pi, ctx.sessionManager.getSessionFile())
+    // 创建 delivery handle（U4：scheduler 切换内核）
+    // busyPolicy: 'park'（busy 入队不重试，等 tick 外部 flush）
+    // intent: 'after-run'（保持 followUp 语义）
+    // onSettled：延迟绑定——runtime 创建后填充（闭包变量）
+    // #11：整条 msg 透传（runtime 按 msg.dedupeKey=task.id 精确反查，不再 content 匹配）
+    const settledHandlerRef: { current: ((msg: DeliveryMessage, outcome: 'delivered' | 'rejected') => void) | undefined } = { current: undefined }
+    deliveryHandle = createDelivery({
+      supportedPayloads: ['custom'],
+      isIdle: () => ctx.isIdle(),
+      hasPendingMessages: () => ctx.hasPendingMessages(),
+      subscribeSettled: (cb) => {
+        // 无退订语义（pi 0.84.1 `pi.on(...)` 全重载返回 void、无 off——实装锚点：
+        // node_modules @earendil-works/pi-coding-agent dist/core/extensions/types.d.ts
+        // `on()` 系列，0.84.1 实测）；disposed 标志包装兑现退订（notifier.ts 同款）
+        let disposed = false
+        pi.on('agent_settled', () => { if (!disposed) cb() })
+        return () => { disposed = true }
+      },
+      send: (msg, intent) => {
+        const piOpts = intent === 'interrupt-at-turn-boundary'
+          ? { triggerTurn: true, deliverAs: 'steer' as const }
+          : { triggerTurn: true, deliverAs: 'followUp' as const }
+        // supportedPayloads 已收窄到 'custom'，payload.kind 恒为 'custom'
+        const content = msg.payload.content
+        return pi.sendMessage(
+          { content, customType: 'pi-scheduler:dispatched', display: true },
+          piOpts,
+        )
+      },
+    }, {
+      intent: 'after-run',
+      busyPolicy: 'park',
+      onSettled: (msg, outcome) => {
+        // 委托给 runtime 的 settledHandler（延迟绑定）
+        settledHandlerRef.current?.(msg, outcome)
+      },
+    })
+    backend.setDeliveryHandle(deliveryHandle)
+
     // G1：注入代际比对（本 runtime 建立时的代数 vs 实时代数），供 tick 前置检查与
     // F2 catch 分诊判定 stale——不依赖 pi 错误文案。
     const runtime = new SchedulerRuntime(backend, ctx, () => sessionGeneration !== myGeneration)
+    // 延迟绑定：runtime 的 handleSettled 绑定到 delivery onSettled 回调
+    settledHandlerRef.current = (msg, outcome) => runtime.handleSettled(msg, outcome)
     runtime.loadTasks(backend.loadTasks())
     // W2：tick 后回调刷新 widget（替代独立 widgetTimer + setInterval，节奏对齐 TICK_INTERVAL_MS）
     runtime.onAfterTick(() => refreshWidget(ctx))
@@ -100,6 +145,9 @@ export default function schedulerExtension(pi: ExtensionAPI): void {
     if (service) {
       service.runtime.stopScheduler()
     }
+    // 销毁 delivery handle（清队列 + 清 timer + 退订 settled）
+    deliveryHandle?.dispose()
+    deliveryHandle = undefined
     // IMPORT-FLUSH-GUARD（MF-1）：兜底清理——正常路径已由首个 turn_end 完成；此处覆盖
     // 从未产生 turn 的 session（打开未发消息即关闭）。cleanup 确认 flush（sessionFile 已出现）
     // 则删 .imported，未 flush 保留供崩溃恢复重导入

package/src/replay.ts

@@ -1,5 +1,9 @@
+import { getLogger } from '@zhushanwen/pi-extension-logger'
+
 import type { ScheduledTask, SchedulerEntryOp, TaskSnapshot } from './types.js'
 
+const logger = getLogger('scheduler')
+
 /**
  * CustomEntry 的最小可识别形状（duck-typed，不依赖 @earendil-works/pi-coding-agent 的
  * 具体 SessionEntry 类型）。与 pending-notifications/state.ts、goal/ports.ts 同款：
@@ -33,7 +37,7 @@ const HISTORY_LIMIT = 20
  *
  * append-only 时序保证 nextRunAt 不回退（D1）：advance entry 按写入顺序折叠，自然取到最后推进值。
  *
- * getEntries 解析/迭代异常 → console.warn + 返回空 Map（gap4）：降级为无任务而非崩溃 session_start。
+ * getEntries 解析/迭代异常 → logger.warn + 返回空 Map（gap4）：降级为无任务而非崩溃 session_start。
  */
 export function replayFoldEntries(
   entries: Iterable<SchedulerEntryLike>,
@@ -82,9 +86,7 @@ export function replayFoldEntries(
         // MF-2：守卫已按变体校验必填字段，但嵌套数据损坏（如 upsert task.history 非数组 →
         // snapshotToTask 的 .map 抛）仍可能抛——逐条 try/catch 只跳过该条，
         // 不让外层整体 catch 把全部任务清成空 Map（一条损坏 entry 不得清空全部任务）
-        console.warn(
-          `[scheduler] skipping corrupted scheduler entry: ${err instanceof Error ? err.message : String(err)}`,
-        )
+        logger.warn('skipping corrupted scheduler entry', { error: err instanceof Error ? err.message : String(err) })
         continue
       }
     }
@@ -101,9 +103,7 @@ export function replayFoldEntries(
     return tasks
   } catch (err) {
     // gap4：session JSONL 损坏 / 迭代器抛错时降级为无任务，不让 session_start 崩溃。
-    console.warn(
-      `[scheduler] replayFoldEntries failed: ${err instanceof Error ? err.message : String(err)}`,
-    )
+    logger.warn('replayFoldEntries failed', { error: err instanceof Error ? err.message : String(err) })
     return new Map()
   }
 }

package/src/runtime.ts

@@ -1,4 +1,7 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent'
+import { getLogger } from '@zhushanwen/pi-extension-logger'
+
+import type { DeliveryHandle, DeliveryMessage } from '@xyz-agent/session-delivery'
 
 import type { SchedulerBackend } from './backend.js'
 import { autoName, generateTaskId } from './format.js'
@@ -11,7 +14,11 @@ import type {
   TaskSnapshot,
 } from './types.js'
 
+const logger = getLogger('scheduler')
+
 const MAX_TASKS = 50
+// 入队防重标记 TTL（合批非首条任务无终态回调，过期后放行重投；10 min >> 合批窗口）
+const QUEUE_DEDUPE_TTL_MS = 10 * 60 * 1000
 const RATE_LIMIT_PER_MINUTE = 6
 const TICK_INTERVAL_MS = 30_000
 const DEFAULT_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000 // 7 days
@@ -30,13 +37,21 @@ const STALE_CTX_MARKER = 'stale after session replacement'
 export class SchedulerRuntime {
   private tasks: Map<string, ScheduledTask> = new Map()
   private backend: SchedulerBackend
-  private ctx: Pick<ExtensionContext, 'isIdle' | 'hasPendingMessages'>
   private tickTimer: ReturnType<typeof setInterval> | null = null
   private dispatchTimestamps: number[] = []
   private onAfterTickCallback: (() => void) | null = null
   private readonly isCtxStale: (() => boolean) | undefined
   // R3-S1：同任务 dispatch 在途标记（Set<taskId>），见 dispatchTask 注释
   private readonly dispatchesInFlight = new Set<string>()
+  // 入队防重标记（Map<taskId, enqueuedAt>）：非 force 任务 send 进 delivery 内核后、
+  // 终态回调（handleSettled）前，nextRunAt 未推进——tick step2 会按 `now >= nextRunAt`
+  // 重新置 pending，若无此标记，agent busy 的每个 tick 都会再压一份同 prompt 副本进队列
+  // （合批后重复注入）。入队置位、delivered/rejected 清除；任务删除（delete/过期）同步清除。
+  // TTL 兜底：合批投递时 onSettled 只带首条 dedupeKey，非首条任务收不到终态回调——
+  // 标记过期后允许重投，保持 at-least-once（与旧「nextRunAt 未推进下 tick 重投」等价）。
+  private readonly queuedInDeliveryAt = new Map<string, number>()
+  // delivery handle（装配点注入；非 force 任务走内核队列）
+  private delivery: DeliveryHandle | undefined
 
   /**
    * 依赖反转构造：backend 承担 appendEntry/pi.sendMessage/时间源，runtime 只持有内存态。
@@ -48,12 +63,15 @@ export class SchedulerRuntime {
    */
   constructor(
     backend: SchedulerBackend,
-    ctx: Pick<ExtensionContext, 'isIdle' | 'hasPendingMessages'>,
+    ctx?: Pick<ExtensionContext, 'isIdle' | 'hasPendingMessages'>,
     isCtxStale?: () => boolean,
   ) {
     this.backend = backend
-    this.ctx = ctx
+    // ctx 不再存实例变量（gate 已交内核）；isCtxStale 保留用于代际检测
+    void ctx
     this.isCtxStale = isCtxStale
+    // 从 backend 获取 delivery handle（装配点注入）
+    this.delivery = backend.getDeliveryHandle?.()
   }
 
   // ── 任务 CRUD ──
@@ -161,6 +179,7 @@ export class SchedulerRuntime {
 
   deleteTask(id: string): boolean {
     const deleted = this.tasks.delete(id)
+    if (deleted) this.queuedInDeliveryAt.delete(id)
     if (deleted) {
       this.appendEntrySafe({ op: 'delete', taskId: id })
     }
@@ -199,7 +218,7 @@ export class SchedulerRuntime {
         if (this.isCtxStale?.() || message.includes(STALE_CTX_MARKER)) {
           this.retireStaleTimer()
         } else {
-          console.warn(`[scheduler] tick error: ${message}`)
+          logger.warn('tick error', { error: message })
         }
       })
     }, TICK_INTERVAL_MS)
@@ -218,7 +237,7 @@ export class SchedulerRuntime {
    * session_start 重建的新一代 runtime 接管。
    */
   private retireStaleTimer(): void {
-    console.warn(`[scheduler] tick stopped: stale extension ctx (session replaced); timer self-retired`)
+    logger.warn('tick stopped: stale extension ctx (session replaced); timer self-retired')
     this.stopScheduler()
   }
 
@@ -239,6 +258,7 @@ export class SchedulerRuntime {
     for (const [id, task] of this.tasks) {
       if (task.expiresAt && now >= task.expiresAt) {
         this.tasks.delete(id)
+        this.queuedInDeliveryAt.delete(id)
         this.appendEntrySafe({ op: 'delete', taskId: id })
       }
     }
@@ -264,6 +284,10 @@ export class SchedulerRuntime {
 
     // W2：tick 完成后刷新 widget（index.ts 注册 refreshWidget）
     this.onAfterTickCallback?.()
+
+    // delivery flush：park 模式下内核不主动重试，由 scheduler tick 外部触发 flush
+    // 让积压在队列中的消息在每个 tick 尝试投递
+    this.delivery?.flush()
   }
 
   // ── dispatch ──
@@ -282,7 +306,7 @@ export class SchedulerRuntime {
   async dispatchTask(task: ScheduledTask): Promise<boolean> {
     if (!task.enabled) return false
     if (this.dispatchesInFlight.has(task.id)) {
-      console.warn(`[scheduler] dispatch already in flight for task ${task.id}; skipping this tick`)
+      logger.warn('dispatch already in flight, skipping this tick', { taskId: task.id })
       return false
     }
     this.dispatchesInFlight.add(task.id)
@@ -302,17 +326,28 @@ export class SchedulerRuntime {
    * once 成功 → append delete。失败 dispatch 不 append（CL7 重试语义，transient 失败 nextRunAt 未推进）。
    */
   private async dispatchTaskInner(task: ScheduledTask): Promise<boolean> {
-    // 检查 force 或 idle
-    if (!task.force) {
-      if (!this.ctx.isIdle() || this.ctx.hasPendingMessages()) {
-        return false // 延迟到下次 tick
-      }
-    }
-
     // 检查速率限制
     if (!this.hasDispatchCapacity(this.backend.now())) return false
 
-    // 注入 message（await：async 错误必须被捕获，fire-and-forget 会漏）
+    if (task.force || !this.delivery) {
+      // force 任务或无 delivery handle 时直投（绕过内核队列）
+      return this.dispatchDirect(task)
+    }
+
+    // 已在内核队列中（入队后未终态且未过 TTL）——step2 会按未推进的 nextRunAt 重新置
+    // pending，此处拦截防重复入队（见 queuedInDeliveryAt 字段注释）
+    const queuedAt = this.queuedInDeliveryAt.get(task.id)
+    if (queuedAt !== undefined && this.backend.now() - queuedAt < QUEUE_DEDUPE_TTL_MS) return false
+
+    // 非 force 任务走 delivery 内核（park 模式：busy 入队等下次 tick flush）
+    return this.dispatchViaDelivery(task)
+  }
+
+  /**
+   * force 任务直投：绕过 delivery 内核队列，直接调 backend.sendMessage。
+   * 无 delivery handle 时也走此路径（向后兼容）。
+   */
+  private async dispatchDirect(task: ScheduledTask): Promise<boolean> {
     try {
       await this.backend.sendMessage(
         { content: task.prompt, customType: 'pi-scheduler:dispatched', display: true },
@@ -325,49 +360,111 @@ export class SchedulerRuntime {
       if (task.history.length > HISTORY_LIMIT) task.history.shift()
       return false
     }
+    return this.onDispatchSuccess(task)
+  }
+
+  /**
+   * 非 force 任务走 delivery 内核：入队后由内核 flush 时投递。
+   * gate（isIdle/hasPendingMessages）由内核管理，busy 时入队不重试（park 模式）。
+   * onSettled 回调处理成功/失败记账。
+   * 返回 true 表示已入队（非实际发送）。
+   */
+  private dispatchViaDelivery(task: ScheduledTask): boolean {
+    const delivery = this.delivery!
+
+    delivery.send({
+      payload: {
+        kind: 'custom',
+        customType: 'pi-scheduler:dispatched',
+        content: task.prompt,
+        display: true,
+      },
+      intent: 'after-run',
+      // #11：task.id 作为 onSettled 反查键（本 handle 未开 dedupe，dedupeKey 不驱动
+      // 去重，仅随消息透传给 onSettled 回调）。content 反查在同 prompt 多任务下错配。
+      dedupeKey: task.id,
+    })
 
-    // 更新状态（收敛到一个 now 值，避免多次 backend.now() 在真实时钟下漂移）
+    // send() 不 throw（park 模式下入队即返回）。
+    // 入队即挂防重标记 + 计入速率限制（nextRunAt 要等 delivered 后才推进，期间 step2
+    // 会持续重标 pending——防重标记拦截重复入队，速率记账覆盖入队侧消耗）。
+    // 成功/失败记账由 onSettled 回调异步处理。
+    this.queuedInDeliveryAt.set(task.id, this.backend.now())
+    this.dispatchTimestamps.push(this.backend.now())
+    task.pending = false
+    return true
+  }
+
+  /**
+   * dispatch 成功后的状态更新与持久化（dispatchDirect 成功后、onSettled delivered 后共用）。
+   * countRate=false 时不再计速率（delivery 路径入队时已计入，delivered 再计会双算）。
+   */
+  private async onDispatchSuccess(task: ScheduledTask, countRate = true): Promise<boolean> {
     const now = this.backend.now()
     task.runCount++
     task.lastRunAt = now
     task.lastStatus = 'success'
     task.pending = false
-    task.lastError = undefined // 成功 dispatch 后清除历史错误
+    task.lastError = undefined
     task.history.push({ at: now, status: 'success' })
     if (task.history.length > HISTORY_LIMIT) task.history.shift()
 
-    // 计算下次执行 + 持久化（append-only）
     if (task.kind === 'once') {
       this.tasks.delete(task.id)
-      // once 成功 → append delete（CL7：抵消 upsert，防 resume 复活已执行的 once 任务）
       this.appendEntrySafe({ op: 'delete', taskId: task.id })
     } else {
       const next = await computeNextRunAt(task.schedule, now)
       if (next === undefined) {
-        // ERR-2 fallback：cron 表达式失效 → 停用任务，避免 `?? now()` 死循环。
-        // 不 append advance（nextRunAt 未推进，CL7 重试语义）；cron 失效停用的 enabled=false
-        // 持久化缺口属 at-least-once 已知窗口（首个 tick 会再停用），非 must-fix
         task.enabled = false
         task.lastStatus = 'failed'
         task.lastError = 'cron expression invalid'
-        // nextRunAt 保留原值（enabled=false 后 tick 不再触发）
       } else {
         task.nextRunAt = next
-        // recurring 成功推进 nextRunAt → append advance（D1 核心：持久化新 nextRunAt，防 resume 回退重放）
         this.appendEntrySafe({
           op: 'advance',
           taskId: task.id,
           nextRunAt: next,
           at: now,
-          status: 'success', // CL8：对齐 TaskStatus，非 'ok'
+          status: 'success',
         })
       }
     }
 
-    this.dispatchTimestamps.push(now)
+    if (countRate) this.dispatchTimestamps.push(now)
     return true
   }
 
+  /**
+   * onSettled 回调入口（index.ts 装配点绑定）：delivery 内核投递终态时调用。
+   * delivered → 成功记账（onDispatchSuccess）；rejected → 失败记账。
+   * once 任务失败不删持久化（at-least-once 语义）。
+   * #11：按 msg.dedupeKey（dispatch 时挂的 task.id，见 dispatchViaDelivery）精确反查
+   * tasks Map——旧 content 反查在「同 prompt 多任务」下错配（find 取首个命中），
+   * 任务已删除时静默丢弃不误记。反查未命中（once 成功已删 / 批量合投非首条 /
+   * 非 scheduler 消息）直接返回。
+   * 已知限制：内核 busy 期间多条消息合投为一批时（doSend splice 全队列），onSettled
+   * 只收到保留首条 dedupeKey 的 composed 消息——非首条任务不记账，靠下个 tick 的
+   * nextRunAt 未推进重投（at-least-once 兜底），与旧 content 反查行为等价不劣化。
+   */
+  handleSettled(msg: DeliveryMessage, outcome: 'delivered' | 'rejected'): void {
+    const taskId = msg.dedupeKey
+    // 防重标记先清（任务可能已被删除，反查未命中也要清）
+    if (taskId !== undefined) this.queuedInDeliveryAt.delete(taskId)
+    const task = taskId !== undefined ? this.tasks.get(taskId) : undefined
+    if (!task) return // 任务已被删除（once 成功后删）或非 scheduler 发出的消息
+
+    if (outcome === 'delivered') {
+      // fire-and-forget：onDispatchSuccess 内部 catch 不 rethrow（countRate=false：入队时已计速率）
+      void this.onDispatchSuccess(task, false).catch(() => {})
+    } else {
+      // 失败记账
+      task.lastStatus = 'failed'
+      task.history.push({ at: this.backend.now(), status: 'failed' })
+      if (task.history.length > HISTORY_LIMIT) task.history.shift()
+      // once 任务失败不删持久化（at-least-once 语义）
+    }
+  }
+
   private hasDispatchCapacity(now: number): boolean {
     const oneMinuteAgo = now - 60_000
     this.dispatchTimestamps = this.dispatchTimestamps.filter(t => t > oneMinuteAgo)
@@ -384,7 +481,7 @@ export class SchedulerRuntime {
   // ── append-only 持久化辅助 ──
 
   /**
-   * 委托 backend.appendEntry。失败 → console.warn + 不 rethrow（ER-APPEND-FAIL）。
+   * 委托 backend.appendEntry。失败 → logger.warn + 不 rethrow（ER-APPEND-FAIL）。
    * 内存态已先行更新（at-least-once 已知恶化窗口：append 失败则该 op 丢失，resume 重放回退）。
    * 不再设 task.lastError='persist failed'（append 失败是 transient，不应污染业务态）。
    */
@@ -394,9 +491,7 @@ export class SchedulerRuntime {
     } catch (err) {
       // best-effort 降级（ER-APPEND-FAIL）：append-only 模型下 append 失败仅丢失该 op 的持久化，
       // 内存态已先行更新、不 rethrow，业务流程继续。at-least-once 已知恶化窗口（resume 重放回退）。
-      console.warn(
-        `[scheduler] appendEntry failed: ${err instanceof Error ? err.message : String(err)}`,
-      )
+      logger.warn('appendEntry failed', { error: err instanceof Error ? err.message : String(err) })
     }
   }