@zhushanwen/pi-scheduler 0.3.4 → 0.4.1

package/src/__tests__/replay.test.ts

@@ -1,5 +1,15 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
+// Mock 共享 logger，让 logger.warn 可被 spy（源码已从 console.warn 改为 logger.warn）
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}))
+vi.mock('@zhushanwen/pi-extension-logger', () => ({
+  getLogger: () => loggerMock,
+  createLogger: () => loggerMock,
+  setPiHandle: vi.fn(),
+}))
+
 import { replayFoldEntries, type SchedulerEntryLike } from '../replay.js'
 import type { SchedulerEntryOp, TaskSnapshot } from '../types.js'
 
@@ -141,8 +151,8 @@ describe('replayFoldEntries', () => {
   })
 
   // ── TC-W-GETENTRIES-FALLBACK：getEntries 异常兜底（gap4）──
-  it('TC-W-GETENTRIES-FALLBACK: 迭代器抛错时 console.warn + 返回空 Map，不崩溃', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  it('TC-W-GETENTRIES-FALLBACK: 迭代器抛错时 logger.warn + 返回空 Map，不崩溃', () => {
+    loggerMock.warn.mockClear()
     // 构造迭代时抛错的 iterable（模拟 session JSONL 损坏）
     const throwingIterable: Iterable<SchedulerEntryLike> = {
       [Symbol.iterator]() {
@@ -158,11 +168,10 @@ describe('replayFoldEntries', () => {
 
     const result = replayFoldEntries(throwingIterable, '/s.json')
     expect(result.size).toBe(0)
-    expect(warnSpy).toHaveBeenCalled()
-    const msg = warnSpy.mock.calls[0]![0] as string
+    expect(loggerMock.warn).toHaveBeenCalled()
+    const msg = loggerMock.warn.mock.calls[0]![0] as string
     expect(msg).toContain('replayFoldEntries failed')
-    expect(msg).toContain('JSONL corrupted')
-    warnSpy.mockRestore()
+    expect(loggerMock.warn.mock.calls[0]![1]).toEqual(expect.objectContaining({ error: expect.stringContaining('JSONL corrupted') }))
   })
 
   // ── gap2 补强：advance 后 lastStatus/lastRunAt/runCount/history 全恢复 ──
@@ -258,7 +267,7 @@ describe('replayFoldEntries', () => {
   // ── MF-2：守卫按变体校验必填字段——损坏 entry 只跳过该条，不清空全部任务 ──
   it('MF-2: op 合法但缺必填字段的损坏 entry 被跳过，其余任务保留', () => {
     const session = '/s.json'
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerMock.warn.mockClear()
     const entries: SchedulerEntryLike[] = [
       { type: 'custom', customType: 'pi-scheduler:task', data: { op: 'upsert' } }, // 缺 taskId+task
       { type: 'custom', customType: 'pi-scheduler:task', data: { op: 'upsert', taskId: 'A' } }, // 缺 task
@@ -272,12 +281,11 @@ describe('replayFoldEntries', () => {
     const result = replayFoldEntries(entries, session)
     expect(result.size).toBe(1)
     expect(result.get('A')).toBeDefined()
-    warnSpy.mockRestore()
   })
 
   it('MF-2: upsert task 嵌套数据损坏（history 非数组）→ 逐条跳过该 entry，其余任务保留', () => {
     const session = '/s.json'
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerMock.warn.mockClear()
     const entries: SchedulerEntryLike[] = [
       {
         type: 'custom',
@@ -297,10 +305,9 @@ describe('replayFoldEntries', () => {
     expect(result.get('GOOD')).toBeDefined()
     expect(result.has('BAD')).toBe(false)
     // 逐条跳过 warn（非外层整体 catch 的 replayFoldEntries failed warn）
-    expect(warnSpy).toHaveBeenCalled()
-    const msg = warnSpy.mock.calls[0]![0] as string
+    expect(loggerMock.warn).toHaveBeenCalled()
+    const msg = loggerMock.warn.mock.calls[0]![0] as string
     expect(msg).toContain('skipping corrupted scheduler entry')
-    warnSpy.mockRestore()
   })
 
   afterEach(() => {

package/src/__tests__/runtime.test.ts

@@ -1,4 +1,15 @@
 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(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}))
+vi.mock('@zhushanwen/pi-extension-logger', () => ({
+  getLogger: () => loggerMock,
+  createLogger: () => loggerMock,
+  setPiHandle: vi.fn(),
+}))
 
 import { MockSchedulerBackend } from '../backend.js'
 import { SchedulerRuntime } from '../runtime.js'
@@ -7,6 +18,20 @@ import { SchedulerRuntime } from '../runtime.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
@@ -114,13 +139,14 @@ describe('SchedulerRuntime', () => {
       expect(backend.sentMessages).toHaveLength(0)
     })
 
-    it('skips when not idle and force is false', async () => {
+    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(0)
+      expect(busyBackend.sentMessages).toHaveLength(1)
     })
 
     it('dispatches when force is true even if busy', async () => {
@@ -134,13 +160,56 @@ describe('SchedulerRuntime', () => {
 
     // OR 组合补全：源码 `!isIdle() || hasPendingMessages()` 任一为真即跳过。
     // idle=true 但有 pending message → dispatch 应被跳过。
-    it('skips when idle but has pending messages', async () => {
+    // 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 () => {
@@ -178,7 +247,7 @@ describe('SchedulerRuntime', () => {
     })
 
     it('sendMessage 挂起期间下一 tick 同任务被跳过：不双注入、warn in-flight、完成后 runCount=1', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       let resolveSend: (() => void) | undefined
       const sendPromise = new Promise<void>(resolve => { resolveSend = resolve })
       backend.sendMessage = vi.fn(() => sendPromise)
@@ -195,7 +264,7 @@ describe('SchedulerRuntime', () => {
       // in-flight 守卫 → skip + warn（修复前：同一 prompt 双注入）
       await runtime.tickScheduler()
       expect(backend.sendMessage).toHaveBeenCalledTimes(1)
-      const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+      const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('already in flight')
 
       // 放行挂起的 sendMessage：tick1 正常收尾（状态推进恰好一次）
@@ -204,7 +273,6 @@ describe('SchedulerRuntime', () => {
       expect(backend.sendMessage).toHaveBeenCalledTimes(1)
       expect(task.runCount).toBe(1)
       expect(task.pending).toBe(false)
-      warnSpy.mockRestore()
     })
 
     it('挂起 dispatch 只挡同任务：其他任务在下一 tick 正常 dispatch 不受影响', async () => {
@@ -353,7 +421,7 @@ describe('SchedulerRuntime', () => {
 
     // ── TC-W-APPEND-FAIL：appendEntry 失败捕获（ER-APPEND-FAIL）──
     it('TC-W-APPEND-FAIL: appendEntry 失败不抛、保留内存态、不污染 lastError', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       backend.appendError = new Error('pi internal')
 
       // addTask 内 appendEntry 抛错 → 被捕获（console.warn），不 rethrow；内存态已更新（task 仍在）
@@ -362,7 +430,7 @@ describe('SchedulerRuntime', () => {
       expect(task.enabled).toBe(true)
       // appendEntrySafe 不污染业务态（append 失败是 transient，不设 lastError）
       expect(task.lastError).toBeUndefined()
-      expect(warnSpy).toHaveBeenCalled()
+      expect(loggerMock.warn).toHaveBeenCalled()
 
       // tickScheduler 同样不抛：dispatch 成功后 append advance 抛错被捕获，nextRunAt 已推进（内存态正确）
       task.nextRunAt = Date.now() - 1000
@@ -373,7 +441,6 @@ describe('SchedulerRuntime', () => {
       // nextRunAt 已推进到未来（内存态正确，append 失败只丢持久化）
       expect(updated.nextRunAt).toBe(Date.now() + 60000)
       expect(updated.lastError).toBeUndefined() // 不被 append 失败污染
-      warnSpy.mockRestore()
     })
 
     // ── TC-W-ON-AFTER-TICK：onAfterTick 回调（W2）──
@@ -408,8 +475,8 @@ describe('SchedulerRuntime', () => {
     })
 
     // ── MF-1：toggle enable 重算 nextRunAt 到未来时清除残留 pending ──
-    // 场景：busy tick 标记 pending=true（W4 跨 tick 重试）→ disable → enable 重算到未来。
-    // 修复前 pending 残留 → 下个 tick step3 `pending && enabled` 在重算的未来时间点之前提前 dispatch。
+    // U4 变更：gate 已交 delivery 内核，非 force 任务在 busy 时通过 delivery 入队（无 handle 时直投）。
+    // pending 在 dispatchViaDelivery/dispatchDirect 成功后清除（不再依赖 gate 跳过保留 pending）。
     it('MF-1: enable 重算 nextRunAt 到未来时清除残留 pending，不提前 dispatch', async () => {
       // 可控 idle 状态：先 busy 模拟 dispatchTask 跳过保留 pending（W4），后切 idle 排除 busy 干扰
       let idle = false
@@ -420,29 +487,26 @@ describe('SchedulerRuntime', () => {
       vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
       const task = await rt.addTask('mf1', { mode: 'interval', intervalMs: 60000 })
 
-      // T0+61s：任务到期 + busy → step2 标 pending=true，step3 dispatchTask busy 跳过（pending 保留）
+      // T0+61s：任务到期 + 无 delivery handle → dispatchDirect（直投，不检查 idle）
+      // 直投成功后 pending=false
       vi.setSystemTime(new Date('2026-01-01T00:01:01Z'))
       await rt.tickScheduler()
-      expect(task.pending).toBe(true) // busy tick 残留 pending（W4 跨 tick 重试）
-      expect(controllableBackend.sentMessages).toHaveLength(0)
+      expect(task.pending).toBe(false) // 直投成功后 pending 已清除
+      expect(controllableBackend.sentMessages).toHaveLength(1) // 直投成功
 
-      // disable → enable：enable 重算 nextRunAt 到未来（T0+61s + 60s = T0+121s）
-      await rt.toggleTask(task.id, false)
-      await rt.toggleTask(task.id, true)
-      expect(task.pending).toBe(false) // 修复后：重算到未来清除残留 pending
+      // 重算 nextRunAt 到未来（recurring 任务 dispatch 后 nextRunAt 已推进）
       const recalcedNext = task.nextRunAt
-      expect(recalcedNext).toBeGreaterThan(Date.now()) // 确认重算到了未来
+      expect(recalcedNext).toBeGreaterThan(Date.now()) // 已推进到未来
 
-      // T0+90s：在重算的未来 nextRunAt 之前 tick，切 idle 排除 busy 干扰 → 不应 dispatch
+      // T0+90s：在重算的未来 nextRunAt 之前 tick → 不应 dispatch
       vi.setSystemTime(new Date('2026-01-01T00:01:30Z'))
-      idle = true
       await rt.tickScheduler()
-      expect(controllableBackend.sentMessages).toHaveLength(0)
+      expect(controllableBackend.sentMessages).toHaveLength(1) // 仍是 1 次
 
       // 到达重算的未来 nextRunAt 后 tick：才 dispatch
       vi.setSystemTime(new Date(recalcedNext + 1000))
       await rt.tickScheduler()
-      expect(controllableBackend.sentMessages).toHaveLength(1)
+      expect(controllableBackend.sentMessages).toHaveLength(2)
     })
 
     // ── P1：toggle enable 重算的 nextRunAt 跨 session 重放后保持未来值 ──
@@ -535,6 +599,146 @@ 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
@@ -554,7 +758,7 @@ describe('SchedulerRuntime', () => {
     })
 
     it('U1: stale 错误 → warn "tick stopped" + timer 自停，后续 tick 不再发生', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       const nowSpy = vi.spyOn(backend, 'now')
       runtime.onAfterTick(() => {
         throw new Error('This extension ctx is stale after session replacement or reload.')
@@ -563,7 +767,7 @@ describe('SchedulerRuntime', () => {
       runtime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick1：stale 抛 → catch 分诊 → 自停
 
-      const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+      const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('tick stopped')
       expect(warnText).not.toContain('tick error')
 
@@ -572,12 +776,11 @@ describe('SchedulerRuntime', () => {
 
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 2) // 60s：timer 已停，无新 tick
       expect(nowSpy.mock.calls.length).toBe(countAfterSelfStop) // now 计数不再增长
-      warnSpy.mockRestore()
       nowSpy.mockRestore()
     })
 
     it('U2: 非 stale 错误 → warn "tick error" 且调度继续（advance 两次 now 计数 +2）', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       const nowSpy = vi.spyOn(backend, 'now')
       runtime.onAfterTick(() => {
         throw new Error('boom')
@@ -586,7 +789,7 @@ describe('SchedulerRuntime', () => {
       runtime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick1：warn 但不停
 
-      const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+      const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('tick error')
       expect(warnText).not.toContain('tick stopped')
 
@@ -595,7 +798,6 @@ describe('SchedulerRuntime', () => {
 
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 2) // 2 个后续 tick 照常
       expect(nowSpy.mock.calls.length).toBe(countAfterFirstTick + 2)
-      warnSpy.mockRestore()
       nowSpy.mockRestore()
     })
 
@@ -634,7 +836,7 @@ describe('SchedulerRuntime', () => {
     })
 
     it('G1-a: in-flight tick 期间代际翻转 + 非文案错误 → warn "tick stopped" + 自停（不依赖 pi 错误文案）', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       const nowSpy = vi.spyOn(backend, 'now')
       // tick 内先翻世代（模拟 session 替换交错发生在 dispatch await 窗口），再抛与
       // pi 文案完全无关的错误——旧实现按文案分诊会误判为普通错误继续调度（若 pi 改文案）
@@ -646,7 +848,7 @@ describe('SchedulerRuntime', () => {
       genRuntime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick1：catch 分诊走 G1 代际 → 自停
 
-      const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+      const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('tick stopped')
       expect(warnText).not.toContain('tick error')
 
@@ -655,12 +857,11 @@ describe('SchedulerRuntime', () => {
 
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 2) // timer 已停，无新 tick
       expect(nowSpy.mock.calls.length).toBe(countAfterSelfStop)
-      warnSpy.mockRestore()
       nowSpy.mockRestore()
     })
 
     it('G1-b: 代际翻转后泄漏 timer 在下个 tick 前置检查自停——不进入 tick（backend.now 零调用）', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       const nowSpy = vi.spyOn(backend, 'now')
       genRuntime.startScheduler()
       // session 替换：代际翻转（F1 未能触达的泄漏 timer 场景；无任何错误发生）
@@ -668,7 +869,7 @@ describe('SchedulerRuntime', () => {
 
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick1：前置检查命中 → 自停
 
-      const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+      const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('tick stopped')
       expect(warnText).not.toContain('tick error')
       // 前置检查在 tickScheduler 之前拦截：tick 本体未执行（now 零调用，无 dispatch/append）
@@ -676,12 +877,11 @@ describe('SchedulerRuntime', () => {
 
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 2) // timer 已停，仍零调用
       expect(nowSpy).not.toHaveBeenCalled()
-      warnSpy.mockRestore()
       nowSpy.mockRestore()
     })
 
     it('G1-c: isCtxStale 注入但返回 false + 非 stale 错误 → warn "tick error" 且调度继续', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       const nowSpy = vi.spyOn(backend, 'now')
       // staleFlag 恒 false（beforeEach 初始化）：代际未翻转，注入存在不改变分诊结果
       genRuntime.onAfterTick(() => {
@@ -691,7 +891,7 @@ describe('SchedulerRuntime', () => {
       genRuntime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick1：非 stale → warn 继续调度
 
-      const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+      const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('tick error')
       expect(warnText).not.toContain('tick stopped')
 
@@ -700,12 +900,11 @@ describe('SchedulerRuntime', () => {
 
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 2) // 2 个后续 tick 照常
       expect(nowSpy.mock.calls.length).toBe(countAfterFirstTick + 2)
-      warnSpy.mockRestore()
       nowSpy.mockRestore()
     })
 
     it('G1-d: isCtxStale 返回 false 但错误文案含 stale 片段 → 文案兜底仍自停（覆盖 reload 盲区）', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      loggerMock.warn.mockClear()
       const nowSpy = vi.spyOn(backend, 'now')
       // reload 场景模拟：factory 重跑后旧闭包代际计数不再递增（staleFlag 恒 false），
       // 只有错误文案能识别 stale——兜底支必须独立于代际检测生效
@@ -716,7 +915,7 @@ describe('SchedulerRuntime', () => {
       genRuntime.startScheduler()
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS) // tick1：文案兜底 → 自停
 
-      const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+      const warnText = loggerMock.warn.mock.calls.map(c => String(c[0])).join('\n')
       expect(warnText).toContain('tick stopped')
       expect(warnText).not.toContain('tick error')
 
@@ -725,7 +924,6 @@ describe('SchedulerRuntime', () => {
 
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 2)
       expect(nowSpy.mock.calls.length).toBe(countAfterSelfStop)
-      warnSpy.mockRestore()
       nowSpy.mockRestore()
     })
   })

package/src/__tests__/service.test.ts

@@ -195,10 +195,9 @@ describe('SchedulerService', () => {
       })
     })
 
-    // TC8：busy 场景（任务 enabled 但 ctx.isIdle() 返回 false）→ dispatch no-op →
-    // DISPATCH_SKIPPED。m2 只覆盖了 disabled 场景，busy 是 dispatchTask 的
-    // `!task.force && (!ctx.isIdle() || ctx.hasPendingMessages())` 独立分支。
-    it('returns DISPATCH_SKIPPED when ctx is busy (isIdle=false)', async () => {
+    // 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())
@@ -207,11 +206,9 @@ describe('SchedulerService', () => {
       const id = created.data!.task.id
       const result = await busyService.run(id)
 
-      expect(result.success).toBe(false)
-      expect(result.errorCode).toBe('DISPATCH_SKIPPED')
-      expect(result.message).toContain('busy')
-      // 未发送任何 message（dispatch no-op）
-      expect(busyBackend.sentMessages).toHaveLength(0)
+      // 直投成功（无 delivery handle → dispatchDirect，不检查 idle）
+      expect(result.success).toBe(true)
+      expect(busyBackend.sentMessages).toHaveLength(1)
     })
   })
 })