@zhushanwen/pi-scheduler 0.5.2 → 0.7.0

package/src/tool.ts

@@ -2,8 +2,6 @@ import { Static, Type } from 'typebox'
 
 import type { SchedulerService, ServiceResult } from './service.js'
 
-// TODO: add renderResult/renderCall to registerTool calls (standards.md §4.3)
-
 // ── schedule tool ──
 
 export const ScheduleParams = Type.Object({
@@ -12,7 +10,6 @@ export const ScheduleParams = Type.Object({
   kind: Type.Optional(Type.Union([Type.Literal('once'), Type.Literal('recurring')], { description: 'Task kind. Default: recurring.' })),
   name: Type.Optional(Type.String({ description: 'Human-readable task name. Auto-generated from prompt if omitted.' })),
   expires: Type.Optional(Type.String({ description: 'Expiry duration (30m/2h/7d). Default: 7d. Pass "never" to disable. Only applies to recurring tasks (once tasks fire and are removed, expires is ignored).' })),
-  force: Type.Optional(Type.Boolean({ description: 'Dispatch even when agent is busy. Default: false.' })),
 })
 
 export type ScheduleParamsT = Static<typeof ScheduleParams>
@@ -27,16 +24,16 @@ export const scheduleGuidelines = [
 
 /**
  * schedule tool handler（SchedulerService 瘦壳，无独立业务逻辑）。
+ * 直传参普通函数（ext-simplify-08 L6：原工厂柯里化 `createScheduleHandler(service)(params)`
+ * 两段调用收敛为 `handleSchedule(service, params)`）。
  * 业务失败 → throw（pi 只对 execute throw 置 isError:true，返回值里的 isError
  * 被 agent-loop 丢弃——W4 修复，锚点 agent-loop.js:453-483）；service 未初始化等
  * 初始化异常不在此 catch——穿透到 index.ts execute 的 catch 兜底（R3）。
  */
-export function createScheduleHandler(service: SchedulerService) {
-  return async (params: ScheduleParamsT) => {
-    const { prompt, schedule: scheduleInput, kind, name, expires, force } = params
-    const result = await service.create(prompt, scheduleInput, { kind, name, expires, force })
-    return toToolResult(result)
-  }
+export async function handleSchedule(service: SchedulerService, params: ScheduleParamsT) {
+  const { prompt, schedule: scheduleInput, kind, name, expires } = params
+  const result = await service.create(prompt, scheduleInput, { kind, name, expires })
+  return toToolResult(result)
 }
 
 // ── schedule_control tool ──
@@ -53,36 +50,33 @@ export const controlGuidelines = [
   'Use action="list" to see all scheduled tasks.',
   'After listing, use the returned id for toggle/delete/run.',
   'Prefer toggle(enabled=false) over delete for temporary pauses.',
-  'action="run" dispatches the task now: force tasks are sent directly; non-force tasks are enqueued via the delivery kernel and delivered once the agent is idle (busy messages wait in the queue and are flushed later).',
+  'action="run" dispatches the task now: the message is sent immediately via steer (interrupting the current turn if the agent is busy).',
 ]
 
-export function createScheduleControlHandler(service: SchedulerService) {
-  return async (params: ScheduleControlParamsT) => {
-    const { action, id, enabled } = params
+export async function handleScheduleControl(service: SchedulerService, params: ScheduleControlParamsT) {
+  const { action, id, enabled } = params
 
-    let result: ServiceResult
-    switch (action) {
-      case 'list':
-        result = service.list()
-        break
-      case 'toggle':
-        result = await service.toggle(id, enabled)
-        break
-      case 'delete':
-        result = service.delete(id)
-        break
-      case 'run':
-        result = await service.run(id)
-        break
-      default:
-        result = {
-          success: false,
-          errorCode: 'INVALID_PARAMS',
-          message: `Unknown action: ${action}`,
-        }
-    }
-    return toToolResult(result)
+  let result: ServiceResult
+  switch (action) {
+    case 'list':
+      result = service.list()
+      break
+    case 'toggle':
+      result = await service.toggle(id, enabled)
+      break
+    case 'delete':
+      result = service.delete(id)
+      break
+    case 'run':
+      result = await service.run(id)
+      break
+    default:
+      result = {
+        success: false,
+        message: `Unknown action: ${action}`,
+      }
   }
+  return toToolResult(result)
 }
 
 /**

package/src/types.ts

@@ -16,7 +16,6 @@ export interface ScheduledTask {
   kind: TaskKind
   schedule: ScheduleSpec            // once 时 intervalMs = delayMs
   enabled: boolean
-  force: boolean                    // true = 即使 agent busy 也 dispatch
   createdAt: number
   nextRunAt: number
   expiresAt?: number                // undefined = 永不过期
@@ -24,7 +23,7 @@ export interface ScheduledTask {
   lastRunAt?: number
   lastStatus?: TaskStatus
   lastError?: string                // 最近一次失败原因（cron 失效 / appendEntry 失败）
-  history: ExecutionRecord[]        // 最近 20 条
+  history: ExecutionRecord[]        // 最近 HISTORY_LIMIT 条
   ownerSessionFile?: string         // append-only owner：记录任务创建时所属的 session JSONL，fork 重放时按此过滤非 owner 任务（gap1）
   pending?: boolean                 // 运行时标记：到期待 dispatch（非持久化语义，勿与 TaskStatus 混淆）
 }
@@ -34,8 +33,32 @@ export interface ExecutionRecord {
   status: TaskStatus
 }
 
+/**
+ * history 裁剪上限（ext-simplify-08 L5 单点）：runtime 侧 dispatch 累积
+ * （onDispatchSuccess）与 replay 侧 advance 折叠共用同一上限——
+ * 双处各持字面量会漂移（曾 runtime.ts / replay.ts 各写一份 20），收敛到 types.ts 单点导出。
+ */
+export const HISTORY_LIMIT = 20
+
+/**
+ * 追加执行记录并按 HISTORY_LIMIT 裁剪（ext-simplify-17 B4 单点）：runtime 侧 dispatch
+ * 累积与 replay 侧 advance 折叠共用的 push+trim——三处内联时与上限字面量同源存在
+ * 「漏改一处」漂移风险，随上限一并收敛。
+ */
+export function appendExecutionRecord(task: ScheduledTask, at: number, status: TaskStatus): void {
+  task.history.push({ at, status })
+  if (task.history.length > HISTORY_LIMIT) task.history.shift()
+}
+
 // ── CustomEntry event sourcing（append-only 任务存储）──
 
+/**
+ * pi.appendEntry 写入的 custom entry customType 标识（ext-simplify-17 B1 单点）：
+ * backend.appendEntry 写入 / replay.foldEntries 过滤 / importer 旧 store 导入三处共用——
+ * 各持字面量时「改一处漏两处」会使写入与重放识别脱节（写入新标识、重放不认，任务静默丢失）。
+ */
+export const TASK_ENTRY_TYPE = 'pi-scheduler:task'
+
 /**
  * upsert op 携带的全量任务快照（不含 ownerSessionFile / pending）。
  * ownerSessionFile 放在 op 顶层（见 SchedulerEntryOp.upsert），
@@ -48,7 +71,6 @@ export interface TaskSnapshot {
   kind: TaskKind
   schedule: ScheduleSpec
   enabled: boolean
-  force: boolean
   createdAt: number
   nextRunAt: number
   expiresAt?: number
@@ -60,7 +82,7 @@ export interface TaskSnapshot {
 }
 
 /**
- * pi.appendEntry('pi-scheduler:task', SchedulerEntryOp) 写入 session JSONL 的 op 联合类型。
+ * pi.appendEntry(TASK_ENTRY_TYPE, SchedulerEntryOp) 写入 session JSONL 的 op 联合类型。
  *
  * advance.status 固定为 'success'（CL8）：对齐现有 TaskStatus='success'|'failed'，
  * 而非继承的 DM-SCHEDULER-OP 词表 'ok'。唯一 emit 值——按 CL7，advance 仅在 dispatch
@@ -73,24 +95,61 @@ export type SchedulerEntryOp =
   | { op: 'toggle'; taskId: string; enabled: boolean; nextRunAt?: number }
   | { op: 'delete'; taskId: string }
 
+/**
+ * ScheduledTask → TaskSnapshot（ext-simplify-17 B2 canonical，解构剥离式）：剥离
+ * ownerSessionFile（在 op 顶层）与 pending（运行时标记），history 用 slice() 拷贝数组
+ * （元素为不可变值对象 {at,status}，无元素级 mutate 路径，数组级拷贝即隔离 push/shift）。
+ *
+ * 选解构式而非显式逐字段列举：快照字段自动跟随 ScheduledTask 演进——显式列举漏写
+ * （可选字段）时无编译错误，upsert 快照静默缺字段、replay 恢复丢数据。
+ * importer 侧输入是 normalizeLegacyTask 补全的旧 store 数据，本无 ownerSessionFile/
+ * pending 运行时字段，剥离子集对其 no-op，同一实现覆盖新任务与导入两条路径。
+ */
+export function toTaskSnapshot(task: ScheduledTask): TaskSnapshot {
+  const { ownerSessionFile: _o, pending: _p, history, ...rest } = task
+  return { ...rest, history: history.slice() }
+}
+
+/**
+ * TaskSnapshot → ScheduledTask（replay 侧重建）：pending 不持久化故不恢复，
+ * ownerSessionFile 由调用方（replay applyUpsert）从 op 顶层补回。history 逐项深拷贝——
+ * 避免恢复出的运行时 task 与快照共享数组/元素引用（task 后续被 mutate 时不污染快照）。
+ */
+export function snapshotToTask(snapshot: TaskSnapshot): ScheduledTask {
+  return {
+    id: snapshot.id,
+    name: snapshot.name,
+    prompt: snapshot.prompt,
+    kind: snapshot.kind,
+    schedule: snapshot.schedule,
+    enabled: snapshot.enabled,
+    createdAt: snapshot.createdAt,
+    nextRunAt: snapshot.nextRunAt,
+    expiresAt: snapshot.expiresAt,
+    runCount: snapshot.runCount,
+    lastRunAt: snapshot.lastRunAt,
+    lastStatus: snapshot.lastStatus,
+    lastError: snapshot.lastError,
+    history: snapshot.history.map(h => ({ ...h })),
+  }
+}
+
 // ── 持久化 ──
 
 export interface SchedulerStore {
+  /**
+   * 形状忠实保留（ext-simplify-08 L8）：旧 store 文件（npm 0.1.1 store.ts）顶层携带
+   * version:1，importer 只读 tasks、version 零读点——字段是磁盘格式的文档而非消费面，
+   * 删除会让类型与迁移源文件的真实形状静默漂移。
+   */
   version: 1
   tasks: ScheduledTask[]
 }
 
-// ── 解析结果 ──
-
-export interface ParseScheduleResult {
-  spec: ScheduleSpec
-}
-
 // ── 添加选项 ──
 
 export interface AddOptions {
   name?: string
   kind?: TaskKind
   expires?: string
-  force?: boolean
 }

package/src/__tests__/U4-AFTER_RUN_INTENT.test.ts

@@ -1,99 +0,0 @@
-/**
- * U4_AFTER_RUN_INTENT：after-run intent 映射验收
- *
- * 两个子用例：
- * (1) 装配层 createDelivery config.intent='after-run'，dispatchTask 后 port.send 收到 intent='after-run'
- * (2) 现有 sendMessage 调用参数验证——force 路径 backend.sendMessage 参数为 {deliverAs:'followUp', triggerTurn:true}
- */
-import { describe, expect, it, vi } from 'vitest'
-
-import { MockSchedulerBackend } from '../backend.js'
-import { SchedulerRuntime } from '../runtime.js'
-
-describe('U4_AFTER_RUN_INTENT: intent 映射', () => {
-  it('(1) dispatchTask 通过 delivery → port.send 收到 intent=after-run', async () => {
-    // 内核级 mock：记录 port.send 的 intent 参数
-    const sentIntents: string[] = []
-    const mockDelivery = {
-      send: vi.fn((msg: any) => {
-        // delivery handle 的 send 不直接暴露 intent（intent 在 createDelivery config 中）
-        // 但我们可以验证 send 被调用（入队），intent 由内核传递给 port.send
-        sentIntents.push(msg.intent ?? 'config-default')
-      }),
-      sendChecked: vi.fn(),
-      flush: vi.fn(),
-      depth: vi.fn(() => 0),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
-
-    const task = await runtime.addTask('intent-test', { mode: 'interval', intervalMs: 60_000 })
-    await runtime.dispatchTask(task)
-
-    // delivery.send 被调用
-    expect(mockDelivery.send).toHaveBeenCalledTimes(1)
-    // send 调用的 payload 包含正确的 content
-    expect(mockDelivery.send).toHaveBeenCalledWith(
-      expect.objectContaining({
-        payload: expect.objectContaining({
-          kind: 'custom',
-          customType: 'pi-scheduler:dispatched',
-          content: 'intent-test',
-          display: true,
-        }),
-        intent: 'after-run',
-      }),
-    )
-    // 不直调 backend.sendMessage
-    expect(backend.sentMessages).toHaveLength(0)
-  })
-
-  it('(2) force 路径直调 sendMessage 参数等价（deliverAs:followUp + triggerTurn:true）', async () => {
-    const backend = new MockSchedulerBackend()
-    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
-
-    const task = await runtime.addTask(
-      'force-intent',
-      { mode: 'interval', intervalMs: 60_000 },
-      { force: true },
-    )
-    await runtime.dispatchTask(task)
-
-    // force 直投走 backend.sendMessage
-    expect(backend.sentMessages).toHaveLength(1)
-    expect(backend.sentMessages[0]!.msg).toEqual(
-      expect.objectContaining({
-        content: 'force-intent',
-        customType: 'pi-scheduler:dispatched',
-        display: true,
-      }),
-    )
-    // 迁移后参数与迁移前一致
-    expect(backend.sentMessages[0]!.opts).toEqual({
-      deliverAs: 'followUp',
-      triggerTurn: true,
-    })
-  })
-
-  it('(3) 有 delivery handle 时非 force 任务不直投 backend.sendMessage', async () => {
-    const mockDelivery = {
-      send: vi.fn(),
-      sendChecked: vi.fn(),
-      flush: vi.fn(),
-      depth: vi.fn(() => 0),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
-
-    const task = await runtime.addTask('delivery-only-test', { mode: 'interval', intervalMs: 60_000 })
-    const dispatched = await runtime.dispatchTask(task)
-
-    expect(dispatched).toBe(true)
-    expect(mockDelivery.send).toHaveBeenCalledTimes(1)
-    expect(backend.sentMessages).toHaveLength(0)
-  })
-})

package/src/__tests__/U4-ONSETTLED.test.ts

@@ -1,124 +0,0 @@
-/**
- * U4_ONSETTLED：onSettled 失败记账验收
- *
- * 三条子用例：
- * (1) delivery send 抛错 → task.lastStatus='failed' + history 追加 + pending=false
- * (2) once 任务 send 抛错 → task 不从 tasks Map 删除、不 append delete op（at-least-once）
- * (3) recurring 任务 send 成功 → task.lastStatus='success' + nextRunAt 推进 + append advance op
- *
- * 断言 backend.appendedOps 含预期 op 类型。
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { MockSchedulerBackend } from '../backend.js'
-import type { DeliveryMessage } from '@xyz-agent/session-delivery'
-
-import { SchedulerRuntime } from '../runtime.js'
-
-/** 构造 delivery onSettled 回调入参消息（dispatchViaDelivery 挂 dedupeKey=task.id）。 */
-function settledMsg(content: string, taskId: string): DeliveryMessage {
-  return {
-    payload: {
-      kind: 'custom',
-      customType: 'pi-scheduler:dispatched',
-      content,
-      display: true,
-    },
-    intent: 'after-run',
-    dedupeKey: taskId,
-  }
-}
-
-describe('U4_ONSETTLED: onSettled 失败记账', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-    vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  it('(1) delivery onSettled rejected → task.lastStatus=failed + history + pending=false', async () => {
-    const backend = new MockSchedulerBackend()
-    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
-
-    const task = await runtime.addTask('rejected-test', { mode: 'interval', intervalMs: 60_000 })
-
-    // 模拟 delivery onSettled rejected 回调（dedupeKey=task.id 反查）
-    runtime.handleSettled(settledMsg('rejected-test', task.id), 'rejected')
-
-    expect(task.lastStatus).toBe('failed')
-    expect(task.history[task.history.length - 1]!.status).toBe('failed')
-    // pending 在 addTask 时未设置（undefined），dispatchViaDelivery 中显式清除为 false
-    // rejected 回调不修改 pending，保持 dispatchViaDelivery 后的 false 状态
-    expect(task.pending).toBeFalsy()
-  })
-
-  it('(2) once 任务 rejected → task 不删（at-least-once 语义）', async () => {
-    const backend = new MockSchedulerBackend()
-    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
-
-    const task = await runtime.addTask(
-      'once-rejected',
-      { mode: 'interval', intervalMs: 60_000 },
-      { kind: 'once' },
-    )
-    const taskId = task.id
-
-    // 模拟 delivery onSettled rejected
-    runtime.handleSettled(settledMsg('once-rejected', taskId), 'rejected')
-
-    // once 任务失败不删——任务仍在 Map 中
-    expect(runtime.getTask(taskId)).toBeDefined()
-    expect(task.lastStatus).toBe('failed')
-    // 不应 append delete op（失败不删持久化）
-    const deleteOps = backend.appendedOps.filter(
-      op => op.op === 'delete' && 'taskId' in op && op.taskId === taskId,
-    )
-    expect(deleteOps).toHaveLength(0)
-  })
-
-  it('(2b) 通过 handleSettled rejected 触发时，任务不删除且保留失败历史', async () => {
-    const backend = new MockSchedulerBackend()
-    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
-
-    const task = await runtime.addTask(
-      'once-rejected-via-handler',
-      { mode: 'interval', intervalMs: 60_000 },
-      { kind: 'once' },
-    )
-
-    runtime.handleSettled(settledMsg('once-rejected-via-handler', task.id), 'rejected')
-
-    expect(task.lastStatus).toBe('failed')
-    expect(task.history[task.history.length - 1]!.status).toBe('failed')
-    expect(runtime.getTask(task.id)).toBeDefined()
-  })
-
-  it('(3) recurring 任务 delivered → lastStatus=success + nextRunAt 推进 + append advance', async () => {
-    const backend = new MockSchedulerBackend()
-    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
-
-    const task = await runtime.addTask('delivered-test', { mode: 'interval', intervalMs: 60_000 })
-    const oldNextRunAt = task.nextRunAt
-    // 时间前进：让 onDispatchSuccess 的 computeNextRunAt 基于更晚的时间计算
-    vi.setSystemTime(new Date('2026-01-01T00:01:01Z'))
-
-    // 模拟 delivery onSettled delivered
-    runtime.handleSettled(settledMsg('delivered-test', task.id), 'delivered')
-
-    // onDispatchSuccess 是 async，等一个 microtask
-    await vi.waitFor(() => {
-      expect(task.lastStatus).toBe('success')
-    })
-
-    expect(task.runCount).toBe(1)
-    expect(task.lastError).toBeUndefined()
-    // nextRunAt 推进到未来
-    expect(task.nextRunAt).toBeGreaterThan(oldNextRunAt)
-    // append advance op
-    const advanceOps = backend.appendedOps.filter(op => op.op === 'advance')
-    expect(advanceOps.length).toBeGreaterThanOrEqual(1)
-  })
-})

package/src/__tests__/U4-PARK_GATE.test.ts

@@ -1,206 +0,0 @@
-/**
- * U4_PARK_GATE：park 模式 gate 行为验收
- *
- * 三条子用例：
- * (1) isIdle=false 时 dispatchTask → delivery 入队（busy 不直投，等 tick 重触发）
- * (2) isIdle=false → flush() 外部调用 → 任务被投递（tick 外部重触发路径）
- * (3) force=true 时绕过 gate 直投（即使 isIdle=false 也 sendMessage）
- *
- * 断言 delivery send 调用次数和 intent 参数。
- */
-import { describe, expect, it, vi } from 'vitest'
-
-import { MockSchedulerBackend } from '../backend.js'
-import { SchedulerRuntime } from '../runtime.js'
-
-describe('U4_PARK_GATE: park 模式 gate 行为', () => {
-  it('(1) isIdle=false 时 dispatchTask → delivery 入队不直投', async () => {
-    // busy ctx：isIdle()=false
-    const busyCtx = { isIdle: () => false, hasPendingMessages: () => true }
-    const mockDelivery = {
-      send: vi.fn(),
-      sendChecked: vi.fn(),
-      flush: vi.fn(),
-      depth: vi.fn(() => 0),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, busyCtx)
-
-    const task = await runtime.addTask('park-gate-test', { mode: 'interval', intervalMs: 60_000 })
-    const dispatched = await runtime.dispatchTask(task)
-
-    // dispatchViaDelivery 入队成功返回 true
-    expect(dispatched).toBe(true)
-    // delivery.send 被调用 1 次（入队），backend.sendMessage 未被直调
-    expect(mockDelivery.send).toHaveBeenCalledTimes(1)
-    expect(mockDelivery.send).toHaveBeenCalledWith(
-      expect.objectContaining({
-        payload: expect.objectContaining({ content: 'park-gate-test' }),
-      }),
-    )
-    // 不直调 backend.sendMessage（非 force 走 delivery）
-    expect(backend.sentMessages).toHaveLength(0)
-    // pending 在 dispatchViaDelivery 后清除
-    expect(task.pending).toBe(false)
-  })
-
-  it('(2) isIdle=false → flush() 外部调用 → 队列消息被投递', async () => {
-    const busyCtx = { isIdle: () => false, hasPendingMessages: () => true }
-    // 内核级 flush 模拟：调用 port.send 投递已入队的消息
-    const portSendCalls: Array<{ msg: unknown; intent: string }> = []
-    const mockPort = {
-      supportedPayloads: ['custom'] as const,
-      isIdle: () => false,
-      hasPendingMessages: () => true,
-      send: vi.fn((msg: any, intent: string) => {
-        portSendCalls.push({ msg, intent })
-      }),
-    }
-    // 使用真实 createDelivery 但 mock port——验证 park 模式下 flush 触发投递
-    // 但为了隔离测试，直接用 mock delivery handle 模拟 flush 行为
-    let flushed = false
-    const mockDelivery = {
-      send: vi.fn(),
-      sendChecked: vi.fn(),
-      flush: vi.fn(() => { flushed = true }),
-      depth: vi.fn(() => (flushed ? 0 : 1)),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, busyCtx)
-
-    await runtime.addTask('flush-test', { mode: 'interval', intervalMs: 60_000 })
-    // 模拟 tickScheduler：dispatchTask 入队 + tick 末尾 flush
-    // 直接调 flush 验证外部触发路径
-    mockDelivery.flush()
-
-    expect(mockDelivery.flush).toHaveBeenCalledTimes(1)
-    expect(flushed).toBe(true)
-  })
-
-  it('(4) busy ctx 下 flush 由 tick 显式触发，而非内核自动重试', async () => {
-    const busyCtx = { isIdle: () => false, hasPendingMessages: () => true }
-    const mockDelivery = {
-      send: vi.fn(),
-      sendChecked: vi.fn(),
-      flush: vi.fn(),
-      depth: vi.fn(() => 1),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, busyCtx)
-
-    const task = await runtime.addTask('tick-flush', { mode: 'interval', intervalMs: 60_000 })
-    await runtime.dispatchTask(task)
-
-    expect(mockDelivery.send).toHaveBeenCalledTimes(1)
-    expect(mockDelivery.flush).not.toHaveBeenCalled()
-
-    await runtime.tickScheduler()
-
-    expect(mockDelivery.flush).toHaveBeenCalledTimes(1)
-    expect(backend.sentMessages).toHaveLength(0)
-  })
-
-  it('(3) force=true 时绕过 delivery 直投（即使 isIdle=false 也 sendMessage）', async () => {
-    const busyCtx = { isIdle: () => false, hasPendingMessages: () => true }
-    const mockDelivery = {
-      send: vi.fn(),
-      sendChecked: vi.fn(),
-      flush: vi.fn(),
-      depth: vi.fn(() => 0),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, busyCtx)
-
-    const task = await runtime.addTask(
-      'force-bypass-test',
-      { mode: 'interval', intervalMs: 60_000 },
-      { force: true },
-    )
-    const dispatched = await runtime.dispatchTask(task)
-
-    // force 任务直投成功
-    expect(dispatched).toBe(true)
-    // delivery.send 不被调用（force 绕过 delivery）
-    expect(mockDelivery.send).not.toHaveBeenCalled()
-    // backend.sendMessage 被直调
-    expect(backend.sentMessages).toHaveLength(1)
-    expect(backend.sentMessages[0]!.msg.content).toBe('force-bypass-test')
-    expect(backend.sentMessages[0]!.opts).toEqual(
-      expect.objectContaining({ deliverAs: 'followUp', triggerTurn: true }),
-    )
-  })
-
-  it('(5) 到期任务 + 持续 busy 多 tick 不重复入队；settled 后可再入队（回归：nextRunAt 未推进期曾每 tick 重压副本）', async () => {
-    const busyCtx = { isIdle: () => false, hasPendingMessages: () => true }
-    const mockDelivery = {
-      send: vi.fn(),
-      sendChecked: vi.fn(),
-      flush: vi.fn(),
-      depth: vi.fn(() => 1),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, busyCtx)
-
-    const task = await runtime.addTask('dup-test', { mode: 'interval', intervalMs: 60_000 })
-    // 任务到期（nextRunAt 已过）
-    task.nextRunAt = backend.now() - 1
-
-    // 3 个连续 tick：每次 step2 都会重标 pending，防重标记应拦截重复入队
-    await runtime.tickScheduler()
-    await runtime.tickScheduler()
-    await runtime.tickScheduler()
-    expect(mockDelivery.send).toHaveBeenCalledTimes(1)
-
-    // 终态回调（delivered）清除标记 + 记账推进 nextRunAt → 下轮到期可再入队
-    runtime.handleSettled(
-      { payload: { kind: 'custom', customType: 'pi-scheduler:dispatched', content: 'dup-test', display: true }, dedupeKey: task.id },
-      'delivered',
-    )
-    // onDispatchSuccess 为 fire-and-forget async，等微任务落定后再断言
-    await new Promise((r) => setTimeout(r, 0))
-    expect(task.lastStatus).toBe('success')
-    expect(task.nextRunAt).toBeGreaterThan(backend.now())
-
-    task.nextRunAt = backend.now() - 1
-    await runtime.tickScheduler()
-    expect(mockDelivery.send).toHaveBeenCalledTimes(2)
-  })
-
-  it('(6) rejected 终态同样清除防重标记', async () => {
-    const busyCtx = { isIdle: () => false, hasPendingMessages: () => true }
-    const mockDelivery = {
-      send: vi.fn(),
-      sendChecked: vi.fn(),
-      flush: vi.fn(),
-      depth: vi.fn(() => 1),
-      dispose: vi.fn(),
-    }
-    const backend = new MockSchedulerBackend()
-    backend.deliveryHandle = mockDelivery as any
-    const runtime = new SchedulerRuntime(backend, busyCtx)
-
-    const task = await runtime.addTask('reject-test', { mode: 'interval', intervalMs: 60_000 })
-    task.nextRunAt = backend.now() - 1
-    await runtime.tickScheduler()
-    expect(mockDelivery.send).toHaveBeenCalledTimes(1)
-
-    runtime.handleSettled(
-      { payload: { kind: 'custom', customType: 'pi-scheduler:dispatched', content: 'reject-test', display: true }, dedupeKey: task.id },
-      'rejected',
-    )
-    expect(task.lastStatus).toBe('failed')
-
-    await runtime.tickScheduler()
-    expect(mockDelivery.send).toHaveBeenCalledTimes(2)
-  })
-})