@zhushanwen/pi-scheduler 0.5.2 → 0.7.0

package/src/__tests__/runtime.test.ts

@@ -1,5 +1,4 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { DeliveryMessage } from '@xyz-agent/session-delivery'
 
 // Mock 共享 logger，让 logger.warn 可被 spy（源码已从 console.warn 改为 logger.warn）
 const { loggerMock } = vi.hoisted(() => ({
@@ -11,27 +10,11 @@ vi.mock('@zhushanwen/pi-extension-logger', () => ({
   setPiHandle: vi.fn(),
 }))
 
-import { MockSchedulerBackend } from '../backend.js'
+import { MockSchedulerBackend } from './mock-backend.js'
 import { SchedulerRuntime } from '../runtime.js'
 
 // MockSchedulerBackend 零 FS 副作用：runtime 不再触碰 store，无需 mock store.js。
 
-const mockCtx = { isIdle: () => true, hasPendingMessages: () => false }
-
-/** 构造 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('SchedulerRuntime', () => {
   let backend: MockSchedulerBackend
   let runtime: SchedulerRuntime
@@ -39,7 +22,7 @@ describe('SchedulerRuntime', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     backend = new MockSchedulerBackend()
-    runtime = new SchedulerRuntime(backend, mockCtx)
+    runtime = new SchedulerRuntime(backend)
   })
 
   describe('addTask', () => {
@@ -125,7 +108,10 @@ describe('SchedulerRuntime', () => {
   })
 
   describe('dispatchTask', () => {
-    it('dispatches task when idle', async () => {
+    // steer 直投模型（scheduler-steer-direct-dispatch）：全任务统一 backend.sendMessage 直投，
+    // 受理即记账；runtime 层无 idle/busy 判定（pi 侧 steer 分支处理）、无 delivery 内核。
+
+    it('dispatches task via direct send', async () => {
       const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
       await runtime.dispatchTask(task)
       expect(backend.sentMessages).toHaveLength(1)
@@ -139,79 +125,6 @@ describe('SchedulerRuntime', () => {
       expect(backend.sentMessages).toHaveLength(0)
     })
 
-    it('non-force 任务在 busy 时走 delivery 入队（不直调 sendMessage）', async () => {
-      const busyCtx = { isIdle: () => false, hasPendingMessages: () => false }
-      const busyBackend = new MockSchedulerBackend()
-      const busyRuntime = new SchedulerRuntime(busyBackend, busyCtx)
-      const task = await busyRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 })
-      // 无 delivery handle 时走 dispatchDirect（直投），busy 不影响（直投不检查 idle）
-      await busyRuntime.dispatchTask(task)
-      expect(busyBackend.sentMessages).toHaveLength(1)
-    })
-
-    it('dispatches when force is true even if busy', async () => {
-      const busyCtx = { isIdle: () => false, hasPendingMessages: () => false }
-      const busyBackend = new MockSchedulerBackend()
-      const busyRuntime = new SchedulerRuntime(busyBackend, busyCtx)
-      const task = await busyRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 }, { force: true })
-      await busyRuntime.dispatchTask(task)
-      expect(busyBackend.sentMessages).toHaveLength(1)
-    })
-
-    // OR 组合补全：源码 `!isIdle() || hasPendingMessages()` 任一为真即跳过。
-    // idle=true 但有 pending message → dispatch 应被跳过。
-    // U4 变更：gate 已交 delivery 内核，无 delivery handle 时走 dispatchDirect（直投不检查 idle）
-    it('无 delivery handle 时直投不受 idle/pending 影响', async () => {
-      const pendingCtx = { isIdle: () => true, hasPendingMessages: () => true }
-      const pendingBackend = new MockSchedulerBackend()
-      const pendingRuntime = new SchedulerRuntime(pendingBackend, pendingCtx)
-      const task = await pendingRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 })
-      await pendingRuntime.dispatchTask(task)
-      expect(pendingBackend.sentMessages).toHaveLength(1)
-    })
-
-    // U4 区分力补强：有 delivery handle 时非 force 任务走 delivery 入队而非直投
-    it('有 delivery handle 时非 force 任务走 delivery 入队', async () => {
-      const pendingCtx = { isIdle: () => true, hasPendingMessages: () => true }
-      const pendingBackend = new MockSchedulerBackend()
-      pendingBackend.deliveryHandle = {
-        send: vi.fn(),
-        sendChecked: vi.fn(),
-        flush: vi.fn(),
-        depth: vi.fn(() => 0),
-        dispose: vi.fn(),
-      } as any
-      const pendingRuntime = new SchedulerRuntime(pendingBackend, pendingCtx)
-      const task = await pendingRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 })
-      const dispatched = await pendingRuntime.dispatchTask(task)
-
-      expect(dispatched).toBe(true)
-      expect(pendingBackend.deliveryHandle.send).toHaveBeenCalledTimes(1)
-      expect(pendingBackend.sentMessages).toHaveLength(0)
-      expect(task.pending).toBe(false)
-    })
-
-    // U4 区分力补强：busy 时 delivery 入队成功，不触发直投
-    it('busy 时 delivery 入队成功，不触发直投', async () => {
-      const busyCtx = { isIdle: () => false, hasPendingMessages: () => true }
-      const busyBackend = new MockSchedulerBackend()
-      busyBackend.deliveryHandle = {
-        send: vi.fn(),
-        sendChecked: vi.fn(),
-        flush: vi.fn(),
-        depth: vi.fn(() => 0),
-        dispose: vi.fn(),
-      } as any
-      const busyRuntime = new SchedulerRuntime(busyBackend, busyCtx)
-      const task = await busyRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 })
-      const dispatched = await busyRuntime.dispatchTask(task)
-
-      expect(dispatched).toBe(true)
-      expect(busyBackend.deliveryHandle.send).toHaveBeenCalledTimes(1)
-      expect(busyBackend.sentMessages).toHaveLength(0)
-      expect(task.pending).toBe(false)
-    })
-
     it('sendMessage 失败 → 记 failed 状态但不 rethrow', async () => {
       const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
       // backend.sendMessage 抛错模拟注入失败
@@ -234,7 +147,7 @@ describe('SchedulerRuntime', () => {
   // ── R3-S1：dispatchTask in-flight 守卫 ──
   // tick 为 fire-and-forget：tick1 的 await sendMessage 挂起超过 TICK_INTERVAL_MS（如 pi
   // 卡死）时，tick2 的 step2 再标 pending → step3 对同一 task 并发第二个 dispatch → 同一
-  // prompt 双注入（force 任务绕过 isIdle gate 直接受影响）。守卫：同任务在途（Set<taskId>）
+  // prompt 双注入。守卫：同任务在途（Set<taskId>）
   // 时 skip 本轮并 warn；不同任务不受影响。
   describe('dispatchTask in-flight 守卫（R3-S1）', () => {
     beforeEach(() => {
@@ -252,7 +165,7 @@ describe('SchedulerRuntime', () => {
       const sendPromise = new Promise<void>(resolve => { resolveSend = resolve })
       backend.sendMessage = vi.fn(() => sendPromise)
 
-      const task = await runtime.addTask('in-flight', { mode: 'interval', intervalMs: 60000 }, { force: true })
+      const task = await runtime.addTask('in-flight', { mode: 'interval', intervalMs: 60000 })
       task.nextRunAt = Date.now() - 1000
 
       // tick1：dispatch 进入 sendMessage 挂起（同步段已置 in-flight 标记）
@@ -280,8 +193,8 @@ describe('SchedulerRuntime', () => {
       const sendPromise = new Promise<void>(resolve => { resolveSend = resolve })
       backend.sendMessage = vi.fn(() => sendPromise)
 
-      const task1 = await runtime.addTask('first', { mode: 'interval', intervalMs: 60000 }, { force: true })
-      const task2 = await runtime.addTask('second', { mode: 'interval', intervalMs: 60000 }, { force: true })
+      const task1 = await runtime.addTask('first', { mode: 'interval', intervalMs: 60000 })
+      const task2 = await runtime.addTask('second', { mode: 'interval', intervalMs: 60000 })
       task1.nextRunAt = Date.now() - 1000
       task2.nextRunAt = Date.now() - 1000
 
@@ -315,10 +228,10 @@ describe('SchedulerRuntime', () => {
     })
 
     it('rate-limits dispatch to 6 per minute', async () => {
-      // force=true 保证不被 idle/busy 干扰，直接命中 rate-limit
+      // 直投模型下 runtime 无 idle/busy 判定，直接命中 rate-limit
       const tasks: Awaited<ReturnType<typeof runtime.addTask>>[] = []
       for (let i = 0; i < 7; i++) {
-        tasks.push(await runtime.addTask(`task ${i}`, { mode: 'interval', intervalMs: 60000 }, { force: true }))
+        tasks.push(await runtime.addTask(`task ${i}`, { mode: 'interval', intervalMs: 60000 }))
       }
 
       // 7 次 dispatch 全在同一分钟内（fake time 不前进）
@@ -331,7 +244,7 @@ describe('SchedulerRuntime', () => {
     })
 
     it('allows dispatch again after 1 minute window slides', async () => {
-      const task = await runtime.addTask('t', { mode: 'interval', intervalMs: 60000 }, { force: true })
+      const task = await runtime.addTask('t', { mode: 'interval', intervalMs: 60000 })
       // 先消耗完 6 次配额
       for (let i = 0; i < 6; i++) {
         // 同一 task 反复 dispatch（interval 模式每次重算 nextRunAt，不影响 rate-limit 计数）
@@ -458,8 +371,8 @@ describe('SchedulerRuntime', () => {
       await runtime.toggleTask(disabled.id, false)
       disabled.nextRunAt = Date.now() - 1000
 
-      // enabled + 到期（force=true 绕过 idle/busy 检查，隔离 enabled 维度）
-      const enabledTask = await runtime.addTask('enabled', { mode: 'interval', intervalMs: 60000 }, { force: true })
+      // enabled + 到期（隔离 enabled 维度）
+      const enabledTask = await runtime.addTask('enabled', { mode: 'interval', intervalMs: 60000 })
       enabledTask.nextRunAt = Date.now() - 1000
 
       await runtime.tickScheduler()
@@ -475,19 +388,16 @@ describe('SchedulerRuntime', () => {
     })
 
     // ── MF-1：toggle enable 重算 nextRunAt 到未来时清除残留 pending ──
-    // U4 变更：gate 已交 delivery 内核，非 force 任务在 busy 时通过 delivery 入队（无 handle 时直投）。
-    // pending 在 dispatchViaDelivery/dispatchDirect 成功后清除（不再依赖 gate 跳过保留 pending）。
+    // pending 在 dispatchTaskInner 成功/失败后清除（成功清、失败也清——重试由 nextRunAt 未推进
+    // 下的下个 tick step2 重标驱动）。
     it('MF-1: enable 重算 nextRunAt 到未来时清除残留 pending，不提前 dispatch', async () => {
-      // 可控 idle 状态：先 busy 模拟 dispatchTask 跳过保留 pending（W4），后切 idle 排除 busy 干扰
-      let idle = false
-      const controllableCtx = { isIdle: () => idle, hasPendingMessages: () => false }
       const controllableBackend = new MockSchedulerBackend()
-      const rt = new SchedulerRuntime(controllableBackend, controllableCtx)
+      const rt = new SchedulerRuntime(controllableBackend)
 
       vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
       const task = await rt.addTask('mf1', { mode: 'interval', intervalMs: 60000 })
 
-      // T0+61s：任务到期 + 无 delivery handle → dispatchDirect（直投，不检查 idle）
+      // T0+61s：任务到期 → steer 直投
       // 直投成功后 pending=false
       vi.setSystemTime(new Date('2026-01-01T00:01:01Z'))
       await rt.tickScheduler()
@@ -539,7 +449,7 @@ describe('SchedulerRuntime', () => {
         data: op,
       }))
       // fakeSessionFile 默认 '/test/session.json'，与第一个 backend 一致 → owner 过滤放行
-      const replayRuntime = new SchedulerRuntime(replayBackend, mockCtx)
+      const replayRuntime = new SchedulerRuntime(replayBackend)
       replayRuntime.loadTasks(replayBackend.loadTasks())
 
       const replayed = replayRuntime.getTask(task.id)
@@ -599,146 +509,6 @@ describe('SchedulerRuntime', () => {
     })
   })
 
-  // ── U4：delivery 内核集成 ──
-  // scheduler 的非 force 任务走 delivery 内核（park 模式）。
-  // force 任务和无 delivery handle 时走 dispatchDirect（直投）。
-  describe('U4: delivery 内核集成', () => {
-    it('有 delivery handle 时非 force 任务走 delivery 入队（不直调 sendMessage）', async () => {
-      // 模拟 delivery handle（必须在 runtime 构造前设置，构造时从 backend 获取）
-      const sentViaDelivery: Array<{ content: string; intent: string }> = []
-      const mockDelivery = {
-        send: vi.fn((msg: { payload: { content: string }; intent?: string }) => {
-          sentViaDelivery.push({
-            content: msg.payload.content,
-            intent: msg.intent ?? 'after-run',
-          })
-        }),
-        sendChecked: vi.fn(),
-        flush: vi.fn(),
-        depth: vi.fn(() => 0),
-        dispose: vi.fn(),
-      }
-      backend.deliveryHandle = mockDelivery as any
-      // 重新创建 runtime（构造时获取 delivery handle）
-      const deliveryRuntime = new SchedulerRuntime(backend, mockCtx)
-
-      const task = await deliveryRuntime.addTask('delivery-test', { mode: 'interval', intervalMs: 60000 })
-      await deliveryRuntime.dispatchTask(task)
-
-      // 非 force 任务走 delivery 入队
-      expect(mockDelivery.send).toHaveBeenCalledTimes(1)
-      expect(sentViaDelivery[0]!.content).toBe('delivery-test')
-      expect(sentViaDelivery[0]!.intent).toBe('after-run')
-      // 不直调 sendMessage
-      expect(backend.sentMessages).toHaveLength(0)
-      // pending 已清除（入队后移交内核管理）
-      expect(task.pending).toBe(false)
-    })
-
-    it('force 任务绕过 delivery 直投', async () => {
-      const mockDelivery = {
-        send: vi.fn(),
-        sendChecked: vi.fn(),
-        flush: vi.fn(),
-        depth: vi.fn(() => 0),
-        dispose: vi.fn(),
-      }
-      backend.deliveryHandle = mockDelivery as any
-      const deliveryRuntime = new SchedulerRuntime(backend, mockCtx)
-
-      const task = await deliveryRuntime.addTask('force-test', { mode: 'interval', intervalMs: 60000 }, { force: true })
-      await deliveryRuntime.dispatchTask(task)
-
-      // force 任务直投（不走 delivery）
-      expect(mockDelivery.send).not.toHaveBeenCalled()
-      expect(backend.sentMessages).toHaveLength(1)
-      expect(backend.sentMessages[0]!.msg.content).toBe('force-test')
-    })
-
-    it('tick 末尾调 delivery.flush()', async () => {
-      const mockDelivery = {
-        send: vi.fn(),
-        sendChecked: vi.fn(),
-        flush: vi.fn(),
-        depth: vi.fn(() => 0),
-        dispose: vi.fn(),
-      }
-      backend.deliveryHandle = mockDelivery as any
-      const deliveryRuntime = new SchedulerRuntime(backend, mockCtx)
-
-      await deliveryRuntime.tickScheduler()
-
-      // tick 完成后调 flush
-      expect(mockDelivery.flush).toHaveBeenCalledTimes(1)
-    })
-
-    it('handleSettled delivered（dedupeKey=task.id 反查）→ 成功记账', async () => {
-      const task = await runtime.addTask('settle-test', { mode: 'interval', intervalMs: 60000 })
-
-      // 模拟 delivery onSettled 回调（dispatchViaDelivery 挂 dedupeKey=task.id）
-      runtime.handleSettled(settledMsg('settle-test', task.id), 'delivered')
-
-      // onDispatchSuccess 是异步的，等待完成
-      await vi.waitFor(() => {
-        expect(task.runCount).toBe(1)
-        expect(task.lastStatus).toBe('success')
-      })
-      expect(task.lastError).toBeUndefined()
-    })
-
-    it('handleSettled rejected → 失败记账（once 不删持久化）', async () => {
-      const task = await runtime.addTask('settle-fail', { mode: 'interval', intervalMs: 60000 }, { kind: 'once' })
-
-      // 模拟 delivery onSettled 回调
-      runtime.handleSettled(settledMsg('settle-fail', task.id), 'rejected')
-
-      // 失败记账
-      expect(task.lastStatus).toBe('failed')
-      expect(task.history[task.history.length - 1]!.status).toBe('failed')
-      // once 任务失败不删持久化（任务仍在）
-      expect(runtime.getTask(task.id)).toBeDefined()
-    })
-
-    it('#11 同 prompt 两任务：各自 onSettled 按 dedupeKey 精确记账（不互相错配）', async () => {
-      const taskA = await runtime.addTask('same-prompt', { mode: 'interval', intervalMs: 60000 })
-      const taskB = await runtime.addTask('same-prompt', { mode: 'interval', intervalMs: 60000 })
-      expect(taskA.id).not.toBe(taskB.id)
-
-      // A 的投递终态：只记 A 的账（旧 content 反查 find 取首个命中，B 先入 Map 时错记 B）
-      runtime.handleSettled(settledMsg('same-prompt', taskA.id), 'delivered')
-
-      await vi.waitFor(() => {
-        expect(taskA.runCount).toBe(1)
-      })
-      expect(taskA.lastStatus).toBe('success')
-      expect(taskB.runCount).toBe(0)
-      expect(taskB.lastStatus).toBeUndefined()
-
-      // B 的投递终态：记 B 的账
-      runtime.handleSettled(settledMsg('same-prompt', taskB.id), 'delivered')
-
-      await vi.waitFor(() => {
-        expect(taskB.runCount).toBe(1)
-      })
-      expect(taskB.lastStatus).toBe('success')
-    })
-
-    it('#11 任务先删后 delivered → 不炸不误记其他任务', async () => {
-      const taskA = await runtime.addTask('deleted-task', { mode: 'interval', intervalMs: 60000 })
-      const taskB = await runtime.addTask('other-task', { mode: 'interval', intervalMs: 60000 })
-
-      // once 成功 / 手动删除后 delivered 迟到：dedupeKey 反查未命中 → no-op
-      runtime.deleteTask(taskA.id)
-      expect(() => {
-        runtime.handleSettled(settledMsg('deleted-task', taskA.id), 'delivered')
-      }).not.toThrow()
-
-      // 不误记其他任务的账
-      expect(taskB.runCount).toBe(0)
-      expect(taskB.lastStatus).toBeUndefined()
-    })
-  })
-
   // ── F2：tick 错误分诊（crash-fix）──
   // startScheduler 的 interval 回调对 fire-and-forget 的 tickScheduler() 加 catch：
   // stale 类错误（session 替换后泄漏 timer 访问 stale ctx）→ warn "tick stopped" + stopScheduler
@@ -827,7 +597,7 @@ describe('SchedulerRuntime', () => {
       vi.useFakeTimers()
       vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
       staleFlag = false
-      genRuntime = new SchedulerRuntime(backend, mockCtx, () => staleFlag)
+      genRuntime = new SchedulerRuntime(backend, () => staleFlag)
     })
 
     afterEach(() => {

package/src/__tests__/service.test.ts

@@ -1,11 +1,9 @@
 import { beforeEach, describe, expect, it } from 'vitest'
 
-import { MockSchedulerBackend } from '../backend.js'
+import { MockSchedulerBackend } from './mock-backend.js'
 import { SchedulerRuntime } from '../runtime.js'
 import { SchedulerService } from '../service.js'
 
-const mockCtx = { isIdle: () => true, hasPendingMessages: () => false }
-
 describe('SchedulerService', () => {
   let service: SchedulerService
   let backend: MockSchedulerBackend
@@ -15,14 +13,13 @@ describe('SchedulerService', () => {
     // 固定时间避免 clock-boundary flake：formatRelativeTime 内部读 Date.now()，
     // 两次读之间的延迟可能导致 "in 1h" 变成 "in 59m"。
     backend.nowValue = Date.now()
-    service = new SchedulerService(new SchedulerRuntime(backend, mockCtx), () => backend.now())
+    service = new SchedulerService(new SchedulerRuntime(backend), () => backend.now())
   })
 
   describe('create', () => {
     it('creates task with duration and returns full summary', async () => {
       const result = await service.create('check build', '5m')
       expect(result.success).toBe(true)
-      expect(result.errorCode).toBeUndefined()
       expect(result.message).toContain('Task "check build"')
       expect(result.message).toContain('every 5m')
       expect(result.message).toContain('Next 5 runs:')
@@ -51,7 +48,7 @@ describe('SchedulerService', () => {
       const fixedNow = Date.now()
       const injectBackend = new MockSchedulerBackend()
       injectBackend.nowValue = fixedNow
-      const nowService = new SchedulerService(new SchedulerRuntime(injectBackend, mockCtx), () => injectBackend.now())
+      const nowService = new SchedulerService(new SchedulerRuntime(injectBackend), () => injectBackend.now())
       const result = await nowService.create('one shot', '1h', { kind: 'once' })
       expect(result.data!.nextRuns[0]).toBe(fixedNow + 3_600_000)
       expect(result.message).toContain('in 1h')
@@ -63,22 +60,20 @@ describe('SchedulerService', () => {
       expect(result.data!.task.schedule).toEqual({ mode: 'cron', cronExpression: '0 0 9 * * 1-5' })
     })
 
-    it('returns INVALID_SCHEDULE for invalid schedule', async () => {
+    it('returns invalid-schedule message for invalid schedule', async () => {
       const result = await service.create('test', 'invalid')
       expect(result).toEqual({
         success: false,
-        errorCode: 'INVALID_SCHEDULE',
         message: 'Invalid schedule: "invalid". Use duration (5m/2h/1d) or cron expression (*/10 * * * *).',
       })
     })
 
-    it('returns TASK_LIMIT_REACHED when 50 tasks exist', async () => {
+    it('returns task-limit message when 50 tasks exist', async () => {
       for (let i = 0; i < 50; i++) {
         await service.create(`task ${i}`, '5m')
       }
       const result = await service.create('one more', '5m')
       expect(result.success).toBe(false)
-      expect(result.errorCode).toBe('TASK_LIMIT_REACHED')
       expect(result.message).toContain('Task limit reached (50)')
     })
   })
@@ -118,29 +113,26 @@ describe('SchedulerService', () => {
       expect(service.runtime.getTask(id)?.enabled).toBe(false)
     })
 
-    it('TC4: returns TASK_NOT_FOUND for unknown id', async () => {
+    it('TC4: returns not-found message for unknown id', async () => {
       const result = await service.toggle('deadbeef', true)
       expect(result).toEqual({
         success: false,
-        errorCode: 'TASK_NOT_FOUND',
         message: 'Task deadbeef not found.',
       })
     })
 
-    it('returns INVALID_PARAMS when id missing', async () => {
+    it('returns invalid-params message when id missing', async () => {
       const result = await service.toggle(undefined, true)
       expect(result).toEqual({
         success: false,
-        errorCode: 'INVALID_PARAMS',
         message: 'id is required for toggle.',
       })
     })
 
-    it('returns INVALID_PARAMS when enabled missing', async () => {
+    it('returns invalid-params message when enabled missing', async () => {
       const result = await service.toggle('abc12345', undefined)
       expect(result).toEqual({
         success: false,
-        errorCode: 'INVALID_PARAMS',
         message: 'enabled is required for toggle.',
       })
     })
@@ -155,11 +147,10 @@ describe('SchedulerService', () => {
       expect(service.runtime.getTask(id)).toBeUndefined()
     })
 
-    it('TC4: returns TASK_NOT_FOUND for unknown id', () => {
+    it('TC4: returns not-found message for unknown id', () => {
       const result = service.delete('deadbeef')
       expect(result).toEqual({
         success: false,
-        errorCode: 'TASK_NOT_FOUND',
         message: 'Task deadbeef not found.',
       })
     })
@@ -174,41 +165,36 @@ describe('SchedulerService', () => {
       expect(service.runtime.getTask(id)?.runCount).toBe(1)
     })
 
-    it('TC4: returns TASK_NOT_FOUND for unknown id', async () => {
+    it('TC4: returns not-found message for unknown id', async () => {
       const result = await service.run('deadbeef')
       expect(result).toEqual({
         success: false,
-        errorCode: 'TASK_NOT_FOUND',
         message: 'Task deadbeef not found.',
       })
     })
 
-    it('returns DISPATCH_SKIPPED for disabled task (not not-found)', async () => {
+    it('returns dispatch-skipped message for disabled task (not not-found)', async () => {
       const created = await service.create('test', '5m')
       const id = created.data!.task.id
       await service.toggle(id, false)
       const result = await service.run(id)
       expect(result).toEqual({
         success: false,
-        errorCode: 'DISPATCH_SKIPPED',
-        message: `Task ${id} not dispatched (disabled, rate-limited, or already queued for delivery).`,
+        message: `Task ${id} not dispatched (disabled, rate-limited, or dispatch in flight).`,
       })
     })
 
-    // U4 变更：gate 已交 delivery 内核，无 delivery handle 时走 dispatchDirect（直投不检查 idle）。
-    // busy 不再导致 DISPATCH_SKIPPED（直投成功）。
-    it('无 delivery handle 时 busy 不影响 dispatch（直投）', async () => {
-      const busyCtx = { isIdle: () => false, hasPendingMessages: () => false }
-      const busyBackend = new MockSchedulerBackend()
-      const busyService = new SchedulerService(new SchedulerRuntime(busyBackend, busyCtx), () => busyBackend.now())
+    it('run 直投成功', async () => {
+      const backend2 = new MockSchedulerBackend()
+      const service2 = new SchedulerService(new SchedulerRuntime(backend2), () => backend2.now())
 
-      const created = await busyService.create('test', '5m')
+      const created = await service2.create('test', '5m')
       const id = created.data!.task.id
-      const result = await busyService.run(id)
+      const result = await service2.run(id)
 
-      // 直投成功（无 delivery handle → dispatchDirect，不检查 idle）
+      // steer 直投成功（runtime 层无 idle/busy 判定）
       expect(result.success).toBe(true)
-      expect(busyBackend.sentMessages).toHaveLength(1)
+      expect(backend2.sentMessages).toHaveLength(1)
     })
   })
 })

package/src/__tests__/tool.test.ts

@@ -1,34 +1,30 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { MockSchedulerBackend } from '../backend.js'
+import { MockSchedulerBackend } from './mock-backend.js'
 import { SchedulerRuntime } from '../runtime.js'
 import { SchedulerService } from '../service.js'
-import { createScheduleControlHandler, createScheduleHandler } from '../tool.js'
-
-const mockCtx = { isIdle: () => true, hasPendingMessages: () => false }
+import { handleSchedule, handleScheduleControl } from '../tool.js'
 
 describe('schedule tool', () => {
   let service: SchedulerService
-  let handler: ReturnType<typeof createScheduleHandler>
 
   beforeEach(() => {
     vi.clearAllMocks()
     const backend = new MockSchedulerBackend()
-    service = new SchedulerService(new SchedulerRuntime(backend, mockCtx), () => backend.now())
-    handler = createScheduleHandler(service)
+    service = new SchedulerService(new SchedulerRuntime(backend), () => backend.now())
   })
 
   it('creates task with duration', async () => {
-    const result = await handler({ prompt: 'check build', schedule: '5m' })
+    const result = await handleSchedule(service, { prompt: 'check build', schedule: '5m' })
     expect(result.content[0]!.text).toContain('Task "check build"')
     const details = result.details as { task: { schedule: { mode: string; intervalMs: number } } }
     expect(details.task.schedule).toEqual({ mode: 'interval', intervalMs: 300000 })
   })
 
   // W4：业务失败 throw（pi 只对 execute throw 置 isError:true，返回值里的 isError
-  // 被 agent-loop 丢弃——错误轮曾被标成功）。原 errorCode details 随 throw 不再产出。
+  // 被 agent-loop 丢弃——错误轮曾被标成功）。
   it('invalid schedule throws with message (W4: pi 采信 throw)', async () => {
-    await expect(handler({ prompt: 'test', schedule: 'invalid' })).rejects.toThrow(
+    await expect(handleSchedule(service, { prompt: 'test', schedule: 'invalid' })).rejects.toThrow(
       'Invalid schedule',
     )
   })
@@ -36,54 +32,52 @@ describe('schedule tool', () => {
 
 describe('schedule_control tool', () => {
   let service: SchedulerService
-  let handler: ReturnType<typeof createScheduleControlHandler>
 
   beforeEach(() => {
     vi.clearAllMocks()
     const backend = new MockSchedulerBackend()
-    service = new SchedulerService(new SchedulerRuntime(backend, mockCtx), () => backend.now())
-    handler = createScheduleControlHandler(service)
+    service = new SchedulerService(new SchedulerRuntime(backend), () => backend.now())
   })
 
   it('lists tasks', async () => {
     await service.create('test', '5m')
-    const result = await handler({ action: 'list' })
+    const result = await handleScheduleControl(service, { action: 'list' })
     expect(result.content[0]!.text).toContain('test')
   })
 
   it('returns empty message when no tasks', async () => {
-    const result = await handler({ action: 'list' })
+    const result = await handleScheduleControl(service, { action: 'list' })
     expect(result.content[0]!.text).toBe('No scheduled tasks.')
   })
 
   it('toggles task', async () => {
     const created = await service.create('test', '5m')
-    const result = await handler({ action: 'toggle', id: created.data!.task.id, enabled: false })
+    const result = await handleScheduleControl(service, { action: 'toggle', id: created.data!.task.id, enabled: false })
     expect(result.content[0]!.text).toContain('disabled')
   })
 
   it('missing id on toggle throws (W4)', async () => {
-    await expect(handler({ action: 'toggle', enabled: true })).rejects.toThrow(
+    await expect(handleScheduleControl(service, { action: 'toggle', enabled: true })).rejects.toThrow(
       'id is required',
     )
   })
 
-  // TC5 tool 侧：toggle 不存在 id → throw（service message 原文即 TASK_NOT_FOUND 文案）
-  it('TC5: toggle unknown id throws with TASK_NOT_FOUND message (W4)', async () => {
-    await expect(handler({ action: 'toggle', id: 'deadbeef', enabled: false })).rejects.toThrow(
+  // TC5 tool 侧：toggle 不存在 id → throw（service message 原文即 not found 文案）
+  it('TC5: toggle unknown id throws with not-found message (W4)', async () => {
+    await expect(handleScheduleControl(service, { action: 'toggle', id: 'deadbeef', enabled: false })).rejects.toThrow(
       'Task deadbeef not found.',
     )
   })
 
   it('deletes task', async () => {
     const created = await service.create('test', '5m')
-    const result = await handler({ action: 'delete', id: created.data!.task.id })
+    const result = await handleScheduleControl(service, { action: 'delete', id: created.data!.task.id })
     expect(result.content[0]!.text).toContain('deleted')
   })
 
   it('runs task now', async () => {
     const created = await service.create('test', '5m')
-    const result = await handler({ action: 'run', id: created.data!.task.id })
+    const result = await handleScheduleControl(service, { action: 'run', id: created.data!.task.id })
     expect(result.content[0]!.text).toContain('executed')
   })
 })