@zhushanwen/pi-scheduler 0.5.2 → 0.7.0

package/src/__tests__/types.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest'
+
+import { snapshotToTask, toTaskSnapshot } from '../types.js'
+import type { ScheduledTask, TaskSnapshot } from '../types.js'
+
+/**
+ * B2 转换器收敛（ext-simplify-17）等价守卫：toTaskSnapshot canonical 取解构式，
+ * 替换 importer 旧显式 14 字段式——期望值按旧显式式的输出形状逐字段锚定
+ * （toEqual 严格比较键集合，解构式多带/漏带键即红），防字段演进中静默漂移。
+ * 既有间接断言（importer/runtime 测试的 objectContaining）不覆盖键集合精确性与
+ * 可选字段传递，此处补直接等价证据。
+ */
+
+/** 全字段 ScheduledTask（含全部可选字段 + 两个运行时字段 + 非空 history）。 */
+function fullTask(): ScheduledTask {
+  return {
+    id: 'abcd1234',
+    name: 'test task',
+    prompt: 'do something',
+    kind: 'recurring',
+    schedule: { mode: 'interval', intervalMs: 60000 },
+    enabled: true,
+    createdAt: 1000,
+    nextRunAt: 2000,
+    expiresAt: 9999,
+    runCount: 3,
+    lastRunAt: 1500,
+    lastStatus: 'success',
+    lastError: 'prev error',
+    history: [
+      { at: 1400, status: 'failed' },
+      { at: 1500, status: 'success' },
+    ],
+    ownerSessionFile: '/x/sess.json',
+    pending: true,
+  }
+}
+
+/**
+ * fullTask 对应的期望快照——字面量逐字段写出（不用解构从 fullTask 推导，
+ * 避免期望值与被测实现共享同一剥离逻辑而失去独立性），形状 = 旧显式式输出。
+ */
+function expectedSnapshot(): TaskSnapshot {
+  return {
+    id: 'abcd1234',
+    name: 'test task',
+    prompt: 'do something',
+    kind: 'recurring',
+    schedule: { mode: 'interval', intervalMs: 60000 },
+    enabled: true,
+    createdAt: 1000,
+    nextRunAt: 2000,
+    expiresAt: 9999,
+    runCount: 3,
+    lastRunAt: 1500,
+    lastStatus: 'success',
+    lastError: 'prev error',
+    history: [
+      { at: 1400, status: 'failed' },
+      { at: 1500, status: 'success' },
+    ],
+  }
+}
+
+describe('toTaskSnapshot / snapshotToTask（B2 收敛等价）', () => {
+  it('toTaskSnapshot: 全字段 task → 恰好 14 字段快照（剥离 ownerSessionFile/pending，值逐一相等）', () => {
+    expect(toTaskSnapshot(fullTask())).toEqual(expectedSnapshot())
+  })
+
+  it('toTaskSnapshot: history 是数组拷贝——task 后续 push/shift 不污染已产出的快照', () => {
+    const task = fullTask()
+    const snapshot = toTaskSnapshot(task)
+    expect(snapshot.history).not.toBe(task.history)
+    task.history.push({ at: 9999, status: 'failed' })
+    task.history.shift()
+    expect(snapshot.history).toEqual([
+      { at: 1400, status: 'failed' },
+      { at: 1500, status: 'success' },
+    ])
+  })
+
+  it('snapshotToTask: 快照 → 恢复 task 不含运行时字段、字段逐一相等、history 逐项拷贝', () => {
+    const source = expectedSnapshot()
+    const task = snapshotToTask(source)
+    expect(task).toEqual(source)
+    expect('ownerSessionFile' in task).toBe(false)
+    expect('pending' in task).toBe(false)
+    // 逐项深拷贝：恢复的 task 后续 mutate 不污染快照（数组与元素均独立）
+    expect(task.history).not.toBe(source.history)
+    expect(task.history[0]).not.toBe(source.history[0])
+  })
+})

package/src/__tests__/widget.test.ts

@@ -10,7 +10,6 @@ const makeTask = (overrides: Partial<ScheduledTask> = {}): ScheduledTask => ({
   kind: 'recurring',
   schedule: { mode: 'interval', intervalMs: 60000 },
   enabled: true,
-  force: false,
   createdAt: Date.now(),
   nextRunAt: Date.now() + 60000,
   runCount: 0,

package/src/backend.ts

@@ -1,17 +1,34 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-import type { DeliveryHandle } from '@xyz-agent/session-delivery'
 
 import { replayFoldEntries, type SchedulerEntryLike } from './replay.js'
+import { TASK_ENTRY_TYPE } from './types.js'
 import type { ScheduledTask, SchedulerEntryOp } from './types.js'
 
 // ── SchedulerBackend 接口 ──
 
+/**
+ * sendMessage 的 msg 形状（ext-simplify-17 B5）：与 pi 的 CustomMessage 鸭子对齐
+ * （customType/display 必填）——pi 根入口不导出 CustomMessage，鸭子解耦只能文件内收敛，
+ * 接口与实现两处共用（测试 mock-backend 持结构兼容的内联签名，不引用本 alias）。
+ */
+interface SchedulerMessage {
+  content: string
+  customType: string
+  display: boolean
+}
+
+/** sendMessage 的 opts 形状：steer 直投选项（scheduler-steer-direct-dispatch 投递模型）。 */
+interface SchedulerSendOptions {
+  deliverAs?: 'steer'
+  triggerTurn?: boolean
+}
+
 /**
  * 运行时协作后端抽象（依赖反转）。SchedulerRuntime 只依赖此接口：
  * 不触碰 session JSONL、不持有 pi。
  *
  * - sendMessage: 到期 dispatch 的消息注入（生产实现委托 pi.sendMessage）
- * - appendEntry: 按 op 写 pi-scheduler:task custom entry（event sourcing）。
+ * - appendEntry: 按 op 写 TASK_ENTRY_TYPE custom entry（event sourcing）。
  *   生产实现委托 pi.appendEntry（同步落盘）。失败必须被调用方 try-catch（ER-APPEND-FAIL：
  *   runtime 捕获后 logger.warn + 不 rethrow，内存态已更新，at-least-once 已知恶化窗口）
  * - getSessionFile: 当前 session JSONL 路径（addTask 构建 upsert op 的 ownerSessionFile 用；
@@ -25,17 +42,16 @@ import type { ScheduledTask, SchedulerEntryOp } from './types.js'
  *
  * sendMessage 的 msg 签名与 pi 的 CustomMessage 对齐（customType/display 必填）：
  * 调用方必须显式提供，PiSchedulerBackend 直接透传无需兜底默认值。
+ *
+ * delivery handle 不在本接口（ext-simplify-08 L2）：backend 自身不消费，曾以
+ * setDeliveryHandle/getDeliveryHandle 中转给 runtime 属穿层传参——现由装配点经
+ * SchedulerRuntime 构造器直传。
  */
 export interface SchedulerBackend {
-  sendMessage(
-    msg: { content: string; customType: string; display: boolean },
-    opts?: { deliverAs?: 'followUp'; triggerTurn?: boolean },
-  ): Promise<void>
+  sendMessage(msg: SchedulerMessage, opts?: SchedulerSendOptions): Promise<void>
   appendEntry(op: SchedulerEntryOp): void
   getSessionFile(): string | undefined
   now(): number
-  /** 获取 delivery handle（装配点注入；未注入时 force 路径仍用 sendMessage 直投）。 */
-  getDeliveryHandle?(): DeliveryHandle | undefined
 }
 
 /**
@@ -62,7 +78,6 @@ export interface SchedulerBackendCtx {
 export class PiSchedulerBackend implements SchedulerBackend {
   private ctx: SchedulerBackendCtx
   private pi: Pick<ExtensionAPI, 'sendMessage' | 'appendEntry'>
-  private deliveryHandle: DeliveryHandle | undefined
 
   constructor(ctx: SchedulerBackendCtx, pi: Pick<ExtensionAPI, 'sendMessage' | 'appendEntry'>) {
     this.ctx = ctx
@@ -70,7 +85,7 @@ export class PiSchedulerBackend implements SchedulerBackend {
   }
 
   /**
-   * 读路径：折叠当前 session 的 pi-scheduler:task custom entries 恢复任务（非接口成员，
+   * 读路径：折叠当前 session 的 TASK_ENTRY_TYPE custom entries 恢复任务（非接口成员，
    * 由装配点 session_start 调用）。replayFoldEntries 内部含 fork owner 过滤与异常兜底。
    */
   loadTasks(): ScheduledTask[] {
@@ -79,15 +94,12 @@ export class PiSchedulerBackend implements SchedulerBackend {
     ]
   }
 
-  async sendMessage(
-    msg: { content: string; customType: string; display: boolean },
-    opts?: { deliverAs?: 'followUp'; triggerTurn?: boolean },
-  ): Promise<void> {
+  async sendMessage(msg: SchedulerMessage, opts?: SchedulerSendOptions): Promise<void> {
     await this.pi.sendMessage(msg, opts)
   }
 
   appendEntry(op: SchedulerEntryOp): void {
-    this.pi.appendEntry('pi-scheduler:task', op)
+    this.pi.appendEntry(TASK_ENTRY_TYPE, op)
   }
 
   getSessionFile(): string | undefined {
@@ -97,76 +109,4 @@ export class PiSchedulerBackend implements SchedulerBackend {
   now(): number {
     return Date.now()
   }
-
-  /**
-   * 注入 delivery handle（装配点创建后调用）。
-   * runtime 通过 getDeliveryHandle() 获取，非 force 任务走内核队列。
-   */
-  setDeliveryHandle(handle: DeliveryHandle): void {
-    this.deliveryHandle = handle
-  }
-
-  getDeliveryHandle(): DeliveryHandle | undefined {
-    return this.deliveryHandle
-  }
-}
-
-// ── 测试实现 ──
-
-export interface SentMessage {
-  msg: { content: string; customType: string; display: boolean }
-  opts?: { deliverAs?: 'followUp'; triggerTurn?: boolean }
-}
-
-/**
- * Mock 后端：零 session/FS 副作用，记录 sendMessage/appendEntry 调用，支持注入固定时间与 fake entries。
- * 与 SchedulerBackend/PiSchedulerBackend 同文件 export（测试从 './backend.js' import）。
- *
- * 能力：
- * - sentMessages: 每次 sendMessage 的 {msg, opts} 记录
- * - appendedOps: 每次 appendEntry 收到的 SchedulerEntryOp（测 runtime 各 op 断言）
- * - fakeEntries / fakeSessionFile: loadTasks 经 replayFoldEntries 的注入源（测 backend→replay 委托）
- * - nowValue: now() 返回固定值，缺省 Date.now()
- * - appendError: 注入后 appendEntry 抛该错（测 ER-APPEND-FAIL 捕获路径）
- */
-export class MockSchedulerBackend implements SchedulerBackend {
-  sentMessages: SentMessage[] = []
-  appendedOps: SchedulerEntryOp[] = []
-  fakeEntries: SchedulerEntryLike[] = []
-  fakeSessionFile: string | undefined = '/test/session.json'
-  nowValue: number | undefined
-  appendError: Error | null = null
-  deliveryHandle: DeliveryHandle | undefined
-
-  async sendMessage(
-    msg: { content: string; customType: string; display: boolean },
-    opts?: { deliverAs?: 'followUp'; triggerTurn?: boolean },
-  ): Promise<void> {
-    this.sentMessages.push({ msg, opts })
-  }
-
-  appendEntry(op: SchedulerEntryOp): void {
-    if (this.appendError) throw this.appendError
-    this.appendedOps.push(op)
-  }
-
-  getSessionFile(): string | undefined {
-    return this.fakeSessionFile
-  }
-
-  now(): number {
-    return this.nowValue ?? Date.now()
-  }
-
-  getDeliveryHandle(): DeliveryHandle | undefined {
-    return this.deliveryHandle
-  }
-
-  /**
-   * 读路径（非接口成员，与 PiSchedulerBackend.loadTasks 对称）：经 replayFoldEntries 折叠
-   * fakeEntries + fakeSessionFile 恢复任务。测试用它验证 backend→replay 委托（TC-W-BACKEND-REPLAY）。
-   */
-  loadTasks(): ScheduledTask[] {
-    return [...replayFoldEntries(this.fakeEntries, this.fakeSessionFile).values()]
-  }
 }

package/src/importer.ts

@@ -4,9 +4,11 @@ import * as path from 'node:path'
 
 import { getAgentDir } from '@earendil-works/pi-coding-agent'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { isEnoentError, toErrorMessage } from '@zhushanwen/pi-ext-guards'
 import { getLogger } from '@zhushanwen/pi-extension-logger'
 
-import type { ScheduledTask, SchedulerEntryOp, SchedulerStore, TaskSnapshot } from './types.js'
+import { TASK_ENTRY_TYPE, toTaskSnapshot } from './types.js'
+import type { ScheduledTask, SchedulerEntryOp, SchedulerStore } from './types.js'
 
 const logger = getLogger('scheduler')
 
@@ -40,7 +42,7 @@ export function getLegacyStorePath(cwd: string): string {
 
 /**
  * 旧 store 任务字段补全（参考 store.ts load() 默认值兜底）：旧数据可能缺字段，逐字段给默认值。
- * ownerSessionFile/pending 不补全——旧数据本无此二字段，由 toTaskSnapshot 显式剥离。
+ * ownerSessionFile/pending 不补全——旧数据本无此二字段，由 toTaskSnapshot 剥离。
  */
 function normalizeLegacyTask(t: Partial<ScheduledTask>): ScheduledTask {
   return {
@@ -53,7 +55,6 @@ function normalizeLegacyTask(t: Partial<ScheduledTask>): ScheduledTask {
     nextRunAt: t.nextRunAt ?? 0,
     runCount: t.runCount ?? 0,
     enabled: t.enabled ?? true,
-    force: t.force ?? false,
     history: t.history ?? [],
     expiresAt: t.expiresAt,
     lastRunAt: t.lastRunAt,
@@ -62,46 +63,6 @@ function normalizeLegacyTask(t: Partial<ScheduledTask>): ScheduledTask {
   }
 }
 
-/**
- * ScheduledTask → TaskSnapshot：显式构造 15 字段
- * （id/name/prompt/kind/schedule/enabled/force/createdAt/nextRunAt/expiresAt?/
- * runCount/lastRunAt?/lastStatus?/lastError?/history），剥离 ownerSessionFile（在 op 顶层）
- * 与 pending（运行时标记），history 用 slice() 深拷贝。
- *
- * 显式构造而非复用 runtime.toSnapshot 的解构写法（T-C3-explicit）：旧 store 数据本无
- * ownerSessionFile/pending 运行时字段，显式构造更安全。两处构造逻辑需保持形状一致
- * （对照 types.ts TaskSnapshot 15 字段）。
- */
-function toTaskSnapshot(task: ScheduledTask): TaskSnapshot {
-  return {
-    id: task.id,
-    name: task.name,
-    prompt: task.prompt,
-    kind: task.kind,
-    schedule: task.schedule,
-    enabled: task.enabled,
-    force: task.force,
-    createdAt: task.createdAt,
-    nextRunAt: task.nextRunAt,
-    expiresAt: task.expiresAt,
-    runCount: task.runCount,
-    lastRunAt: task.lastRunAt,
-    lastStatus: task.lastStatus,
-    lastError: task.lastError,
-    history: task.history.slice(),
-  }
-}
-
-/**
- * 判断 err 是否为 ENOENT（fs.renameSync 源文件不存在）。
- * Record 守卫模式与 replay.ts isSchedulerEntryOp 同款（避免 taste/no-unsafe-cast）。
- */
-function isENOENT(err: unknown): boolean {
-  if (!(err instanceof Error)) return false
-  if (!('code' in err)) return false
-  return (err as Record<'code', unknown>).code === 'ENOENT'
-}
-
 /**
  * 从 .imported 路径读取旧 store JSON、逐任务 pi.appendEntry upsert、按 flush 状态删除 .imported。
  * read/parse/append 任一异常由外层 importLegacyStore 的 try/catch 兜底（C1 整体降级）。
@@ -139,8 +100,7 @@ function importFromFile(
       ownerSessionFile: currentSessionFile,
       task: toTaskSnapshot(task),
     }
-    // customType 与 backend.ts PiSchedulerBackend.appendEntry 同源，改一处必改两处
-    pi.appendEntry('pi-scheduler:task', op)
+    pi.appendEntry(TASK_ENTRY_TYPE, op)
   }
 
   // 空 store（0 任务）无持久化依赖，直接删；resumed session（sessionFile 已存在）已即时落盘，删
@@ -171,7 +131,7 @@ function importFromFile(
         fs.unlinkSync(importedPath)
       } catch (err) {
         // MF-2：并发——另一进程（resumed B）已 unlink → ENOENT 静默；其他 fs 错误（EACCES）不吞
-        if (!isENOENT(err)) throw err
+        if (!isEnoentError(err)) throw err
       }
     }
     // 从未 flush：保留 .imported，下次 session_start 崩溃恢复重导入（不 unlink；不告警——
@@ -213,7 +173,7 @@ function handleImportedResidue(
  * 导入旧 scheduler store 到当前 session（append-only event sourcing 迁移，IF-IMPORT-LEGACY）。
  *
  * 策略：原子 rename scheduler.json → scheduler.json.imported 独占迁移；成功者读取 .imported
- * 逐任务 pi.appendEntry('pi-scheduler:task', upsert) 后删除 .imported；rename 抛 ENOENT
+ * 逐任务 pi.appendEntry(TASK_ENTRY_TYPE, upsert) 后删除 .imported；rename 抛 ENOENT
  * 说明并发场景下别人已 rename 走，走 handleImportedResidue 幂等恢复。
  *
  * 时序（CL3 方案A）：必须在 backend.loadTasks() 之前执行——append 的 upsert entry 进入 pi
@@ -247,7 +207,7 @@ export function importLegacyStore(
     try {
       fs.renameSync(storePath, importedPath)
     } catch (err) {
-      if (isENOENT(err)) {
+      if (isEnoentError(err)) {
         // 并发 S10 / 崩溃恢复：scheduler.json 已不在（被别人 rename 走或上次崩溃）→ 残留恢复
         return handleImportedResidue(importedPath, pi, currentSessionFile)
       }
@@ -259,7 +219,7 @@ export function importLegacyStore(
     return importFromFile(importedPath, pi, currentSessionFile)
   } catch (err) {
     // C1 整体降级：read/parse/appendEntry 任一异常不崩 session_start
-    logger.warn('import failed', { error: err instanceof Error ? err.message : String(err) })
+    logger.warn('import failed', { error: toErrorMessage(err) })
     return undefined
   }
 }

package/src/index.ts

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

package/src/parsing.ts

@@ -1,4 +1,9 @@
-import type { ParseScheduleResult, ScheduleSpec } from './types.js'
+// croner 是 dependencies + 静态 import（ext-simplify-08 D2/M18）：npm 语义保证全安装
+// 形态在盘（独立安装 / builtin inline 同构），不存在「解析器缺失」分支——undefined
+// 的唯一语义 = 表达式无效。
+import { Cron } from 'croner'
+
+import type { ScheduleSpec } from './types.js'
 
 // ── Duration 解析 ──
 
@@ -65,19 +70,6 @@ const CRON_FIELD_COUNT_WITH_SECONDS = 6
 /** computeNextCronRuns / computeNextRuns 默认返回的未来执行时间数。 */
 const DEFAULT_NEXT_RUNS_COUNT = 5
 
-let cronerModule: typeof import('croner') | null | undefined
-
-async function getCroner(): Promise<typeof import('croner') | null> {
-  if (cronerModule !== undefined) return cronerModule
-  try {
-    cronerModule = await import('croner')
-    return cronerModule
-  } catch {
-    cronerModule = null
-    return null
-  }
-}
-
 /**
  * 规范化 cron 表达式：5 字段自动补秒字段。
  * 返回 undefined 表示无效。
@@ -103,20 +95,17 @@ export function normalizeCronExpression(input: string): string | undefined {
 
 /**
  * 计算 cron 表达式的下次执行时间。
- * 返回 undefined 表示表达式无效或 croner 不可用。
+ * 返回 undefined 的唯一语义 = 表达式无效（croner 静态 import 恒在盘，见文件头注释）。
  */
-export async function computeNextCronRunAt(
+export function computeNextCronRunAt(
   expression: string,
   from?: number,
-): Promise<number | undefined> {
-  const croner = await getCroner()
-  if (!croner) return undefined
-
+): number | undefined {
   try {
     const normalized = normalizeCronExpression(expression)
     if (!normalized) return undefined
 
-    const job = new croner.Cron(normalized, { startAt: from ? new Date(from) : undefined })
+    const job = new Cron(normalized, { startAt: from ? new Date(from) : undefined })
     const next = job.nextRun()
     return next ? next.getTime() : undefined
   } catch {
@@ -126,21 +115,18 @@ export async function computeNextCronRunAt(
 
 /**
  * 计算 cron 表达式的多个未来执行时间。
- * count 默认 5。
+ * count 默认 5；表达式无效 → 空数组。
  */
-export async function computeNextCronRuns(
+export function computeNextCronRuns(
   expression: string,
   from?: number,
   count = DEFAULT_NEXT_RUNS_COUNT,
-): Promise<number[]> {
-  const croner = await getCroner()
-  if (!croner) return []
-
+): number[] {
   try {
     const normalized = normalizeCronExpression(expression)
     if (!normalized) return []
 
-    const job = new croner.Cron(normalized, { startAt: from ? new Date(from) : undefined })
+    const job = new Cron(normalized, { startAt: from ? new Date(from) : undefined })
     const runs: number[] = []
     let current = from ? new Date(from) : new Date()
 
@@ -160,14 +146,12 @@ export async function computeNextCronRuns(
 // ── 统一解析 ──
 
 /**
- * 统一解析 schedule 输入。
+ * 统一解析 schedule 输入为 ScheduleSpec（L7：不包装单字段结果对象）。
  * 不含空格 → duration 解析 → interval mode
  * 含空格 → cron 解析 → cron mode
- * 都失败 → undefined
+ * 都失败 → undefined（语义 = 表达式无效，service 层归一为 INVALID_SCHEDULE 单一错误通道）
  */
-export async function parseSchedule(
-  input: string,
-): Promise<ParseScheduleResult | undefined> {
+export function parseSchedule(input: string): ScheduleSpec | undefined {
   const trimmed = input.trim()
   if (!trimmed) return undefined
 
@@ -175,9 +159,7 @@ export async function parseSchedule(
   if (!trimmed.includes(' ')) {
     const ms = parseDuration(trimmed)
     if (ms !== undefined) {
-      return {
-        spec: { mode: 'interval', intervalMs: ms },
-      }
+      return { mode: 'interval', intervalMs: ms }
     }
     return undefined
   }
@@ -186,11 +168,9 @@ export async function parseSchedule(
   const normalized = normalizeCronExpression(trimmed)
   if (normalized) {
     // 验证 cron 表达式有效
-    const nextRun = await computeNextCronRunAt(trimmed)
+    const nextRun = computeNextCronRunAt(trimmed)
     if (nextRun !== undefined) {
-      return {
-        spec: { mode: 'cron', cronExpression: normalized },
-      }
+      return { mode: 'cron', cronExpression: normalized }
     }
   }
 
@@ -200,14 +180,14 @@ export async function parseSchedule(
 /**
  * 统一计算 schedule 的下次执行时间（IF-5：runtime 内唯一 nextRunAt 计算入口）。
  * interval → from + intervalMs（from 缺省 Date.now()）；
- * cron → 下次命中时间戳（> from）；cron 无效或 croner 不可用 → undefined。
+ * cron → 下次命中时间戳（> from）；cron 无效 → undefined。
  * undefined 语义按调用方决策：addTask → 创建即抛错；
  * toggleTask/dispatchTask 重算 → ERR-2 fallback（停用 + failed）。
  */
-export async function computeNextRunAt(
+export function computeNextRunAt(
   spec: ScheduleSpec,
   from?: number,
-): Promise<number | undefined> {
+): number | undefined {
   if (spec.mode === 'interval') {
     const start = from ?? Date.now()
     return start + spec.intervalMs
@@ -222,11 +202,11 @@ export async function computeNextRunAt(
  * 统一计算多个未来执行时间。
  * interval 模式直接乘法，cron 模式调用 croner。
  */
-export async function computeNextRuns(
+export function computeNextRuns(
   spec: ScheduleSpec,
   from?: number,
   count = DEFAULT_NEXT_RUNS_COUNT,
-): Promise<number[]> {
+): number[] {
   if (spec.mode === 'interval') {
     const start = from ?? Date.now()
     return Array.from({ length: count }, (_, i) => start + spec.intervalMs * (i + 1))