@zhushanwen/pi-scheduler 0.3.4 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-scheduler",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "type": "module",
   "main": "index.ts",
   "xyz-agent": {
@@ -44,6 +44,10 @@
       "optional": true
     }
   },
+  "dependencies": {
+    "@xyz-agent/session-delivery": "0.2.0",
+    "@zhushanwen/pi-extension-logger": "0.3.0"
+  },
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest"

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

@@ -0,0 +1,99 @@
+/**
+ * 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-DISPATCH_INFLIGHT.test.ts

@@ -0,0 +1,109 @@
+/**
+ * U4_DISPATCH_INFLIGHT：调用方 in-flight 守卫验收
+ *
+ * 两个子用例：
+ * (1) 同一 taskId 的 dispatchTask 并发调用 → 第二次立即返回 false + logger.warn
+ * (2) 第一次 dispatchTask 完成后（finally 清除）→ 第二次正常执行
+ *
+ * 断言 delivery send 调用总次数为 1（拦截场景）或 2（串行场景）。
+ */
+import { describe, expect, it, vi } from 'vitest'
+
+import { getLogger } from '@zhushanwen/pi-extension-logger'
+
+import { MockSchedulerBackend } from '../backend.js'
+import { SchedulerRuntime } from '../runtime.js'
+
+describe('U4_DISPATCH_INFLIGHT: 调用方 in-flight 守卫', () => {
+  it('(1) 同一 taskId 并发 dispatch → 第二次被拦截（send 只调 1 次 + warn）', async () => {
+    const warnSpy = vi.spyOn(getLogger('scheduler'), 'warn').mockImplementation(() => {})
+
+    // 可控延迟的 sendMessage：让第一次 dispatch 挂起
+    let resolveSend: (() => void) | undefined
+    const sendPromise = new Promise<void>(resolve => {
+      resolveSend = resolve
+    })
+    const backend = new MockSchedulerBackend()
+    backend.sendMessage = vi.fn(() => sendPromise)
+    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
+
+    const task = await runtime.addTask(
+      'inflight-test',
+      { mode: 'interval', intervalMs: 60_000 },
+      { force: true },
+    )
+
+    // 第一次 dispatch（挂起）
+    const first = runtime.dispatchTask(task)
+    // sendMessage 被调 1 次
+    expect(backend.sendMessage).toHaveBeenCalledTimes(1)
+
+    // 第二次 dispatch（同一 taskId，在途被拦截）
+    const second = await runtime.dispatchTask(task)
+    expect(second).toBe(false)
+
+    // warn 包含 in-flight 提示
+    const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+    expect(warnText).toContain('already in flight')
+
+    // sendMessage 仍只有 1 次（拦截有效）
+    expect(backend.sendMessage).toHaveBeenCalledTimes(1)
+
+    // 放行第一次 dispatch
+    resolveSend!()
+    await first
+
+    warnSpy.mockRestore()
+  })
+
+  it('(2) 第一次完成后 → 第二次 dispatchTask 正常执行（send 调 2 次）', async () => {
+    const backend = new MockSchedulerBackend()
+    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
+
+    const task = await runtime.addTask(
+      'serial-inflight',
+      { mode: 'interval', intervalMs: 60_000 },
+      { force: true },
+    )
+
+    // 第一次 dispatch（串行等待完成）
+    const first = await runtime.dispatchTask(task)
+    expect(first).toBe(true)
+    expect(backend.sentMessages).toHaveLength(1)
+
+    // 第二次 dispatch（in-flight 已清除，正常执行）
+    // 需要重置 nextRunAt 让任务再次到期
+    task.nextRunAt = 0
+    const second = await runtime.dispatchTask(task)
+    expect(second).toBe(true)
+
+    // send 被调 2 次（串行完成）
+    expect(backend.sentMessages).toHaveLength(2)
+  })
+
+  it('(3) 非 force + 有 delivery handle 时，in-flight 守卫同样拦截并发 dispatch', async () => {
+    const warnSpy = vi.spyOn(getLogger('scheduler'), 'warn').mockImplementation(() => {})
+    const backend = new MockSchedulerBackend()
+    backend.deliveryHandle = {
+      send: vi.fn(),
+      sendChecked: vi.fn(),
+      flush: vi.fn(),
+      depth: vi.fn(() => 0),
+      dispose: vi.fn(),
+    } as any
+    const runtime = new SchedulerRuntime(backend, { isIdle: () => true, hasPendingMessages: () => false })
+
+    const task = await runtime.addTask('delivery-inflight', { mode: 'interval', intervalMs: 60_000 })
+
+    const first = runtime.dispatchTask(task)
+    const second = await runtime.dispatchTask(task)
+
+    expect(await first).toBe(true)
+    expect(second).toBe(false)
+    expect(backend.deliveryHandle.send).toHaveBeenCalledTimes(1)
+
+    const warnText = warnSpy.mock.calls.map(c => String(c[0])).join('\n')
+    expect(warnText).toContain('already in flight')
+    warnSpy.mockRestore()
+  })
+})

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

@@ -0,0 +1,124 @@
+/**
+ * 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

@@ -0,0 +1,206 @@
+/**
+ * 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)
+  })
+})

package/src/__tests__/importer.test.ts

@@ -4,6 +4,16 @@ import * as path from 'node:path'
 
 import { afterEach, beforeEach, 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 { getLegacyStorePath, importLegacyStore } from '../importer.js'
 import type { ScheduledTask } from '../types.js'
 
@@ -52,9 +62,8 @@ describe('importLegacyStore', () => {
     vi.mocked(fs.existsSync).mockReturnValue(false)
     vi.mocked(fs.readFileSync).mockReturnValue('{}')
     vi.mocked(fs.unlinkSync).mockImplementation(() => {})
-    // 抑制 importer 的 console.log/warn 输出（断言用 spy）
-    vi.spyOn(console, 'log').mockImplementation(() => {})
-    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    // 清理 logger mock（logger 默认 no-op，无需抑制输出）
+    loggerMock.warn.mockClear()
   })
 
   afterEach(() => {
@@ -101,9 +110,10 @@ describe('importLegacyStore', () => {
     expect(fs.unlinkSync).toHaveBeenCalledTimes(1)
     expect(fs.unlinkSync).toHaveBeenCalledWith(importedPath)
 
-    // 5) 进度日志（console.warn，项目 convention 禁 console.log）
-    expect(console.warn).toHaveBeenCalledWith(
-      expect.stringContaining(`imported 2 legacy tasks from ${importedPath}`),
+    // 5) 进度日志
+    expect(loggerMock.warn).toHaveBeenCalledWith(
+      expect.stringContaining('imported legacy tasks'),
+      expect.objectContaining({ count: 2 }),
     )
   })
 
@@ -177,8 +187,9 @@ describe('importLegacyStore', () => {
     const appendEntry = vi.fn()
 
     expect(() => importLegacyStore(cwd, { appendEntry }, sessionFile)).not.toThrow()
-    expect(console.warn).toHaveBeenCalledWith(
-      expect.stringContaining('[scheduler] import failed'),
+    expect(loggerMock.warn).toHaveBeenCalledWith(
+      expect.stringContaining('import failed'),
+      expect.objectContaining({ error: expect.stringContaining('not valid JSON') }),
     )
     expect(appendEntry).toHaveBeenCalledTimes(0) // parse 失败，无 append
   })
@@ -215,7 +226,10 @@ describe('importLegacyStore', () => {
     // append 已发生，但 unlink 未执行——数据可能仅内存，销毁源文件 = 永久丢失
     expect(appendEntry).toHaveBeenCalledTimes(1)
     expect(fs.unlinkSync).not.toHaveBeenCalled()
-    expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('deferring'))
+    expect(loggerMock.warn).toHaveBeenCalledWith(
+      expect.stringContaining('deferring'),
+      expect.objectContaining({ count: 1 }),
+    )
 
     // 情形1：flush 已发生（sessionFile 出现，.imported 仍在）→ cleanup 删除 .imported
     vi.mocked(fs.existsSync).mockImplementation(p => p === sessionFile || p === importedPath)

package/src/__tests__/index-generation.test.ts

@@ -20,6 +20,16 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
 import { afterEach, beforeEach, 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(),
+}))
+
 // 与 index-session-start.test.ts 同款（MF-3）：mock 掉 importer，装配路径仍被调用、FS 副作用为零。
 vi.mock('../importer.js', () => ({ importLegacyStore: vi.fn(() => vi.fn()) }))
 
@@ -127,7 +137,7 @@ describe('G1: index.ts 代际接线（S9）', () => {
   it('factory 重跑：第二次 factory 执行 + session_start 后，第一代 runtime isCtxStale 为 true 且 tick 前置自停', async () => {
     vi.useFakeTimers()
     vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerMock.warn.mockClear()
     try {
       // 第一代：独立 factory 执行 + session_start 装配（runtime1 真实 startScheduler）
       const first = createMockPi()
@@ -156,15 +166,14 @@ describe('G1: index.ts 代际接线（S9）', () => {
       // tick 前置自停：第一代 runtime 的泄漏 timer 在下个 tick 被代际前置检查拦截
       // （G1-b 的生产路径验证：warn "tick stopped" + timer 自停，后续 tick 不再发生）
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS)
-      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')
 
-      const warnCountAfterSelfStop = warnSpy.mock.calls.length
+      const warnCountAfterSelfStop = loggerMock.warn.mock.calls.length
       await vi.advanceTimersByTimeAsync(TICK_INTERVAL_MS * 2) // timer 已停，无新 warn
-      expect(warnSpy.mock.calls.length).toBe(warnCountAfterSelfStop)
+      expect(loggerMock.warn.mock.calls.length).toBe(warnCountAfterSelfStop)
     } finally {
-      warnSpy.mockRestore()
       vi.useRealTimers()
     }
   })