@zhushanwen/pi-scheduler 0.5.2 → 0.7.0

package/src/replay.ts

@@ -1,6 +1,8 @@
+import { toErrorMessage } from '@zhushanwen/pi-ext-guards'
 import { getLogger } from '@zhushanwen/pi-extension-logger'
 
-import type { ScheduledTask, SchedulerEntryOp, TaskSnapshot } from './types.js'
+import { appendExecutionRecord, snapshotToTask, TASK_ENTRY_TYPE } from './types.js'
+import type { ScheduledTask, SchedulerEntryOp } from './types.js'
 
 const logger = getLogger('scheduler')
 
@@ -15,16 +17,14 @@ export interface SchedulerEntryLike {
   data?: unknown
 }
 
-const HISTORY_LIMIT = 20
-
 /**
  * 从 CustomEntry 序列折叠恢复 per-task 末态（event sourcing）。
  *
  * session_start 重放入口：PiSchedulerBackend.loadTasks() 委托本函数，把当前 session 的
- * pi-scheduler:task custom entries 折叠成运行时任务 Map。
+ * TASK_ENTRY_TYPE custom entries 折叠成运行时任务 Map。
  *
  * 两步：
- * ① 全量折叠（foldEntries）——遍历 customType==='pi-scheduler:task' 的 entries，按 op 类型折叠：
+ * ① 全量折叠（foldEntries）——遍历 customType===TASK_ENTRY_TYPE 的 entries，按 op 类型折叠：
  *    - upsert → 用快照重建任务（ownerSessionFile 来自 op 顶层）
  *    - advance → nextRunAt=新值 / lastRunAt=at / runCount++ / history.push(裁20) / lastStatus=status（gap2）
  *    - toggle → enabled=新值
@@ -50,7 +50,7 @@ export function replayFoldEntries(
     return tasks
   } catch (err) {
     // gap4：session JSONL 损坏 / 迭代器抛错时降级为无任务，不让 session_start 崩溃。
-    logger.warn('replayFoldEntries failed', { error: err instanceof Error ? err.message : String(err) })
+    logger.warn('replayFoldEntries failed', { error: toErrorMessage(err) })
     return new Map()
   }
 }
@@ -58,7 +58,7 @@ export function replayFoldEntries(
 /** 步骤① 全量折叠：跳过非本扩展 entry 与守卫不过的损坏 entry；单条折叠抛错只跳过该条（MF-2）。 */
 function foldEntries(entries: Iterable<SchedulerEntryLike>, tasks: Map<string, ScheduledTask>): void {
   for (const entry of entries) {
-    if (entry.type !== 'custom' || entry.customType !== 'pi-scheduler:task') continue
+    if (entry.type !== 'custom' || entry.customType !== TASK_ENTRY_TYPE) continue
     if (!isSchedulerEntryOp(entry.data)) continue
     const op = entry.data // SchedulerEntryOp（守卫 isSchedulerEntryOp 收窄）
 
@@ -68,7 +68,7 @@ function foldEntries(entries: Iterable<SchedulerEntryLike>, tasks: Map<string, S
       // MF-2：守卫已按变体校验必填字段，但嵌套数据损坏（如 upsert task.history 非数组 →
       // snapshotToTask 的 .map 抛）仍可能抛——逐条 try/catch 只跳过该条，
       // 不让外层整体 catch 把全部任务清成空 Map（一条损坏 entry 不得清空全部任务）
-      logger.warn('skipping corrupted scheduler entry', { error: err instanceof Error ? err.message : String(err) })
+      logger.warn('skipping corrupted scheduler entry', { error: toErrorMessage(err) })
       continue
     }
   }
@@ -110,8 +110,7 @@ function applyAdvance(
   task.nextRunAt = op.nextRunAt
   task.lastRunAt = op.at
   task.runCount += 1
-  task.history.push({ at: op.at, status: op.status })
-  if (task.history.length > HISTORY_LIMIT) task.history.shift()
+  appendExecutionRecord(task, op.at, op.status)
   task.lastStatus = op.status // gap2：advance 必须恢复 lastStatus（不只 nextRunAt/lastRunAt/runCount/history）
 }
 
@@ -193,27 +192,3 @@ function isSchedulerEntryOp(data: unknown): data is SchedulerEntryOp {
   }
   return false
 }
-
-/**
- * 从 TaskSnapshot 重建 ScheduledTask（剥离 pending——运行时标记不持久化）。
- * history 深拷贝：避免快照与运行时 task 共享同一数组引用（upsert 后 task 继续被 mutate）。
- */
-function snapshotToTask(snapshot: TaskSnapshot): ScheduledTask {
-  return {
-    id: snapshot.id,
-    name: snapshot.name,
-    prompt: snapshot.prompt,
-    kind: snapshot.kind,
-    schedule: snapshot.schedule,
-    enabled: snapshot.enabled,
-    force: snapshot.force,
-    createdAt: snapshot.createdAt,
-    nextRunAt: snapshot.nextRunAt,
-    expiresAt: snapshot.expiresAt,
-    runCount: snapshot.runCount,
-    lastRunAt: snapshot.lastRunAt,
-    lastStatus: snapshot.lastStatus,
-    lastError: snapshot.lastError,
-    history: snapshot.history.map(h => ({ ...h })),
-  }
-}

package/src/runtime.ts

@@ -1,31 +1,25 @@
-import type { ExtensionContext } from '@earendil-works/pi-coding-agent'
 import { guardStaleCtx, toErrorMessage } from '@zhushanwen/pi-ext-guards'
 import { getLogger } from '@zhushanwen/pi-extension-logger'
 
-import type { DeliveryHandle, DeliveryMessage } from '@xyz-agent/session-delivery'
-
 import type { SchedulerBackend } from './backend.js'
 import { autoName, generateTaskId } from './format.js'
 import { computeNextRunAt, MS_PER_DAY, MS_PER_MINUTE, parseDuration } from './parsing.js'
+import { appendExecutionRecord, toTaskSnapshot } from './types.js'
 import type {
   AddOptions,
   ScheduledTask,
   SchedulerEntryOp,
   ScheduleSpec,
-  TaskSnapshot,
 } from './types.js'
 
 const logger = getLogger('scheduler')
 
 const MAX_TASKS = 50
-// 入队防重标记 TTL 分钟数（合批非首条任务无终态回调，过期后放行重投；10 min >> 合批窗口）
-const QUEUE_DEDUPE_TTL_MINUTES = 10
-const QUEUE_DEDUPE_TTL_MS = QUEUE_DEDUPE_TTL_MINUTES * MS_PER_MINUTE
 const RATE_LIMIT_PER_MINUTE = 6
 const TICK_INTERVAL_MS = 30_000
 const DEFAULT_EXPIRY_DAYS = 7
 const DEFAULT_EXPIRY_MS = DEFAULT_EXPIRY_DAYS * MS_PER_DAY // 7 days
-const HISTORY_LIMIT = 20 // 与 replayFoldEntries 的裁剪上限一致（advance 折叠 / dispatch 累积共用）
+// HISTORY_LIMIT 单点在 types.ts（ext-simplify-08 L5）——与 replay.ts 的 advance 折叠共用
 // STALE_CTX_MARKER（文案兜底分诊词）已迁移到 ext-guards 共享守卫（guardStaleCtx 内部
 // 引用，本文件不再直接持有）。语义：G1 模块级代际检测（isCtxStale）为主判；文案子串
 // 覆盖代际盲区——显式 reload / cwd 变化触发 clearExtensionCache 后 jiti 重新 import 产生
@@ -43,15 +37,6 @@ export class SchedulerRuntime {
   private readonly isCtxStale: (() => boolean) | undefined
   // R3-S1：同任务 dispatch 在途标记（Set<taskId>），见 dispatchTask 注释
   private readonly dispatchesInFlight = new Set<string>()
-  // 入队防重标记（Map<taskId, enqueuedAt>）：非 force 任务 send 进 delivery 内核后、
-  // 终态回调（handleSettled）前，nextRunAt 未推进——tick step2 会按 `now >= nextRunAt`
-  // 重新置 pending，若无此标记，agent busy 的每个 tick 都会再压一份同 prompt 副本进队列
-  // （合批后重复注入）。入队置位、delivered/rejected 清除；任务删除（delete/过期）同步清除。
-  // TTL 兜底：合批投递时 onSettled 只带首条 dedupeKey，非首条任务收不到终态回调——
-  // 标记过期后允许重投，保持 at-least-once（与旧「nextRunAt 未推进下 tick 重投」等价）。
-  private readonly queuedInDeliveryAt = new Map<string, number>()
-  // delivery handle（装配点注入；非 force 任务走内核队列）
-  private delivery: DeliveryHandle | undefined
 
   /**
    * 依赖反转构造：backend 承担 appendEntry/pi.sendMessage/时间源，runtime 只持有内存态。
@@ -61,17 +46,9 @@ export class SchedulerRuntime {
    * 替换。index.ts 装配点注入（模块级代数比对，R3-M1），使 stale 分诊不依赖 pi 错误文案；
    * 缺省（不注入）恒视为非 stale——纯 runtime 单测与旧装配路径行为不变。
    */
-  constructor(
-    backend: SchedulerBackend,
-    ctx?: Pick<ExtensionContext, 'isIdle' | 'hasPendingMessages'>,
-    isCtxStale?: () => boolean,
-  ) {
+  constructor(backend: SchedulerBackend, isCtxStale?: () => boolean) {
     this.backend = backend
-    // ctx 不再存实例变量（gate 已交内核）；isCtxStale 保留用于代际检测
-    void ctx
     this.isCtxStale = isCtxStale
-    // 从 backend 获取 delivery handle（装配点注入）
-    this.delivery = backend.getDeliveryHandle?.()
   }
 
   // ── 任务 CRUD ──
@@ -94,8 +71,8 @@ export class SchedulerRuntime {
       expiresAt = now + expiryMs
     }
 
-    // 统一 nextRunAt 计算：interval → now + intervalMs；cron → 下次命中
-    const nextRunAt = await computeNextRunAt(schedule, now)
+    // 统一 nextRunAt 计算：interval → now + intervalMs；cron → 下次命中（D2 后同步）
+    const nextRunAt = computeNextRunAt(schedule, now)
     if (nextRunAt === undefined) {
       // 创建时校验失败报错给用户（仅 cron 可能 undefined，interval 恒有值）
       const expr = schedule.mode === 'cron' ? schedule.cronExpression : '<unknown>'
@@ -109,7 +86,6 @@ export class SchedulerRuntime {
       kind,
       schedule,
       enabled: true,
-      force: options.force ?? false,
       createdAt: now,
       nextRunAt,
       expiresAt,
@@ -124,7 +100,7 @@ export class SchedulerRuntime {
       taskId: id,
       // getSessionFile() 在 --no-session 模式返回 undefined → '' 兜底（该模式 appendEntry 无 owner 不落盘）
       ownerSessionFile: this.backend.getSessionFile() ?? '',
-      task: this.toSnapshot(task),
+      task: toTaskSnapshot(task),
     })
     return task
   }
@@ -146,14 +122,9 @@ export class SchedulerRuntime {
     let recalcedNext: number | undefined
     // enable 时若 nextRunAt 已过期，重算，避免 enable 瞬间立即触发
     if (enabled && task.nextRunAt < this.backend.now()) {
-      const next = await computeNextRunAt(task.schedule, this.backend.now())
+      const next = computeNextRunAt(task.schedule, this.backend.now())
       if (next === undefined) {
-        // ERR-2 fallback：cron 表达式失效 → 停用任务并记录失败原因。
-        // 禁止 `?? now()` 类 fallback（会使 nextRunAt=now，下个 tick 立即重算 → 死循环）
-        task.enabled = false
-        task.lastStatus = 'failed'
-        task.lastError = 'cron expression invalid'
-        // nextRunAt 保留原值（enabled=false 后 tick 不再触发）
+        this.disableForInvalidCron(task)
       } else {
         task.nextRunAt = next
         recalcedNext = next
@@ -179,7 +150,6 @@ export class SchedulerRuntime {
 
   deleteTask(id: string): boolean {
     const deleted = this.tasks.delete(id)
-    if (deleted) this.queuedInDeliveryAt.delete(id)
     if (deleted) {
       this.appendEntrySafe({ op: 'delete', taskId: id })
     }
@@ -259,7 +229,6 @@ export class SchedulerRuntime {
     for (const [id, task] of this.tasks) {
       if (task.expiresAt && now >= task.expiresAt) {
         this.tasks.delete(id)
-        this.queuedInDeliveryAt.delete(id)
         this.appendEntrySafe({ op: 'delete', taskId: id })
       }
     }
@@ -285,24 +254,20 @@ export class SchedulerRuntime {
 
     // W2：tick 完成后刷新 widget（index.ts 注册 refreshWidget）
     this.onAfterTickCallback?.()
-
-    // delivery flush：park 模式下内核不主动重试，由 scheduler tick 外部触发 flush
-    // 让积压在队列中的消息在每个 tick 尝试投递
-    this.delivery?.flush()
   }
 
   // ── dispatch ──
 
   /**
-   * dispatch 单个任务。返回 true 表示真的发送了 message，false 表示 no-op
-   * （task disabled / 已有同任务在途 / rate-limited / 非 force 且 busy）。
+   * dispatch 单个任务。返回 true 表示消息已发出（pi.sendMessage 受理），false 表示
+   * no-op（task disabled / 已有同任务在途 / rate-limited）。
    *
    * R3-S1 in-flight 守卫：tick 为 fire-and-forget，若 tick1 的 `await backend.sendMessage`
    * 挂起超过 TICK_INTERVAL_MS（如 pi 卡死），tick2 的 step2 会再标 pending、step3 对同一
-   * task 并发第二个 dispatch → 同一 prompt 双注入（force 任务绕过 isIdle gate 直接受影响）。
-   * 参照 subagent-workflow resumesInFlight 模式：入口同步置位、finally 清除（覆盖 gate /
-   * rate-limit / sendMessage 抛错 / 成功推进全部退出路径）；命中时 skip 本轮并 warn
-   * （不 throw——tick 继续处理其他任务，本任务 pending 保留到下轮重试）。
+   * task 并发第二个 dispatch → 同一 prompt 双注入。参照 subagent-workflow resumesInFlight
+   * 模式：入口同步置位、finally 清除（覆盖 gate / rate-limit / sendMessage 抛错 / 成功推进
+   * 全部退出路径）；命中时 skip 本轮并 warn（不 throw——tick 继续处理其他任务，本任务
+   * pending 保留到下轮重试）。
    */
   async dispatchTask(task: ScheduledTask): Promise<boolean> {
     if (!task.enabled) return false
@@ -321,7 +286,13 @@ export class SchedulerRuntime {
   /**
    * dispatch 本体（dispatchTask 守卫置位后执行；runTaskNow 与 tick step3 共用入口，
    * 手动 run-now 与挂起中的 tick dispatch 并发时同样被守卫拦截）。
-   * sendMessage 抛错时记录 failed 状态但不 rethrow，让 tick 继续处理其他任务。
+   * steer 直投（scheduler-steer-direct-dispatch 设计）：{deliverAs:'steer', triggerTurn:true}
+   * 在 pi 侧的两分支——busy 时 steer 插入当前 turn（立即被模型看到）、idle 时开新 turn。
+   * 受理即记账：pi extension API sendMessage 是 fire-and-forget（返回 void，错误走
+   * pi 内部 emitError 通道），await 立即通过，无「入队未终态」窗口——nextRunAt 调用即推进，
+   * tick 不重标 pending，无需防重标记。
+   * sendMessage 抛错（同步异常，session 关闭等）时记录 failed 状态但不 rethrow，
+   * 让 tick 继续处理其他任务。
    *
    * 持久化（append-only）：recurring 成功推进 nextRunAt → append advance（status='success' CL8）；
    * once 成功 → append delete。失败 dispatch 不 append（CL7 重试语义，transient 失败 nextRunAt 未推进）。
@@ -330,95 +301,39 @@ export class SchedulerRuntime {
     // 检查速率限制
     if (!this.hasDispatchCapacity(this.backend.now())) return false
 
-    if (task.force || !this.delivery) {
-      // force 任务或无 delivery handle 时直投（绕过内核队列）
-      return this.dispatchDirect(task)
-    }
-
-    // 已在内核队列中（入队后未终态且未过 TTL）——step2 会按未推进的 nextRunAt 重新置
-    // pending，此处拦截防重复入队（见 queuedInDeliveryAt 字段注释）
-    const queuedAt = this.queuedInDeliveryAt.get(task.id)
-    if (queuedAt !== undefined && this.backend.now() - queuedAt < QUEUE_DEDUPE_TTL_MS) return false
-
-    // 非 force 任务走 delivery 内核（park 模式：busy 入队等下次 tick flush）
-    return this.dispatchViaDelivery(task)
-  }
-
-  /**
-   * force 任务直投：绕过 delivery 内核队列，直接调 backend.sendMessage。
-   * 无 delivery handle 时也走此路径（向后兼容）。
-   */
-  private async dispatchDirect(task: ScheduledTask): Promise<boolean> {
     try {
       await this.backend.sendMessage(
         { content: task.prompt, customType: 'pi-scheduler:dispatched', display: true },
-        { deliverAs: 'followUp', triggerTurn: true },
+        { deliverAs: 'steer', triggerTurn: true },
       )
     } catch {
       task.lastStatus = 'failed'
       task.pending = false
-      task.history.push({ at: this.backend.now(), status: 'failed' })
-      if (task.history.length > HISTORY_LIMIT) task.history.shift()
+      appendExecutionRecord(task, this.backend.now(), 'failed')
       return false
     }
     return this.onDispatchSuccess(task)
   }
 
   /**
-   * 非 force 任务走 delivery 内核：入队后由内核 flush 时投递。
-   * gate（isIdle/hasPendingMessages）由内核管理，busy 时入队不重试（park 模式）。
-   * onSettled 回调处理成功/失败记账。
-   * 返回 true 表示已入队（非实际发送）。
-   */
-  private dispatchViaDelivery(task: ScheduledTask): boolean {
-    const delivery = this.delivery!
-
-    delivery.send({
-      payload: {
-        kind: 'custom',
-        customType: 'pi-scheduler:dispatched',
-        content: task.prompt,
-        display: true,
-      },
-      intent: 'after-run',
-      // #11：task.id 作为 onSettled 反查键（本 handle 未开 dedupe，dedupeKey 不驱动
-      // 去重，仅随消息透传给 onSettled 回调）。content 反查在同 prompt 多任务下错配。
-      dedupeKey: task.id,
-    })
-
-    // send() 不 throw（park 模式下入队即返回）。
-    // 入队即挂防重标记 + 计入速率限制（nextRunAt 要等 delivered 后才推进，期间 step2
-    // 会持续重标 pending——防重标记拦截重复入队，速率记账覆盖入队侧消耗）。
-    // 成功/失败记账由 onSettled 回调异步处理。
-    this.queuedInDeliveryAt.set(task.id, this.backend.now())
-    this.dispatchTimestamps.push(this.backend.now())
-    task.pending = false
-    return true
-  }
-
-  /**
-   * dispatch 成功后的状态更新与持久化（dispatchDirect 成功后、onSettled delivered 后共用）。
-   * countRate=false 时不再计速率（delivery 路径入队时已计入，delivered 再计会双算）。
+   * dispatch 成功后的状态更新与持久化（dispatchTaskInner 受理成功后调用）。
    */
-  private async onDispatchSuccess(task: ScheduledTask, countRate = true): Promise<boolean> {
+  private async onDispatchSuccess(task: ScheduledTask): Promise<boolean> {
     const now = this.backend.now()
     task.runCount++
     task.lastRunAt = now
     task.lastStatus = 'success'
     task.pending = false
     task.lastError = undefined
-    task.history.push({ at: now, status: 'success' })
-    if (task.history.length > HISTORY_LIMIT) task.history.shift()
+    appendExecutionRecord(task, now, 'success')
 
     if (task.kind === 'once') {
       this.tasks.delete(task.id)
       this.appendEntrySafe({ op: 'delete', taskId: task.id })
     } else {
-      const next = await computeNextRunAt(task.schedule, now)
+      const next = computeNextRunAt(task.schedule, now)
       if (next === undefined) {
-        task.enabled = false
-        task.lastStatus = 'failed'
-        task.lastError = 'cron expression invalid'
+        this.disableForInvalidCron(task)
       } else {
         task.nextRunAt = next
         this.appendEntrySafe({
@@ -431,47 +346,28 @@ export class SchedulerRuntime {
       }
     }
 
-    if (countRate) this.dispatchTimestamps.push(now)
+    this.dispatchTimestamps.push(now)
     return true
   }
 
-  /**
-   * onSettled 回调入口（index.ts 装配点绑定）：delivery 内核投递终态时调用。
-   * delivered → 成功记账（onDispatchSuccess）；rejected → 失败记账。
-   * once 任务失败不删持久化（at-least-once 语义）。
-   * #11：按 msg.dedupeKey（dispatch 时挂的 task.id，见 dispatchViaDelivery）精确反查
-   * tasks Map——旧 content 反查在「同 prompt 多任务」下错配（find 取首个命中），
-   * 任务已删除时静默丢弃不误记。反查未命中（once 成功已删 / 批量合投非首条 /
-   * 非 scheduler 消息）直接返回。
-   * 已知限制：内核 busy 期间多条消息合投为一批时（doSend splice 全队列），onSettled
-   * 只收到保留首条 dedupeKey 的 composed 消息——非首条任务不记账，靠下个 tick 的
-   * nextRunAt 未推进重投（at-least-once 兜底），与旧 content 反查行为等价不劣化。
-   */
-  handleSettled(msg: DeliveryMessage, outcome: 'delivered' | 'rejected'): void {
-    const taskId = msg.dedupeKey
-    // 防重标记先清（任务可能已被删除，反查未命中也要清）
-    if (taskId !== undefined) this.queuedInDeliveryAt.delete(taskId)
-    const task = taskId !== undefined ? this.tasks.get(taskId) : undefined
-    if (!task) return // 任务已被删除（once 成功后删）或非 scheduler 发出的消息
-
-    if (outcome === 'delivered') {
-      // fire-and-forget：onDispatchSuccess 内部 catch 不 rethrow（countRate=false：入队时已计速率）
-      void this.onDispatchSuccess(task, false).catch(() => {})
-    } else {
-      // 失败记账
-      task.lastStatus = 'failed'
-      task.history.push({ at: this.backend.now(), status: 'failed' })
-      if (task.history.length > HISTORY_LIMIT) task.history.shift()
-      // once 任务失败不删持久化（at-least-once 语义）
-    }
-  }
-
   private hasDispatchCapacity(now: number): boolean {
     const oneMinuteAgo = now - MS_PER_MINUTE
     this.dispatchTimestamps = this.dispatchTimestamps.filter(t => t > oneMinuteAgo)
     return this.dispatchTimestamps.length < RATE_LIMIT_PER_MINUTE
   }
 
+  /**
+   * ERR-2 fallback（ext-simplify-17 B3 抽取）：cron 表达式失效 → 停用任务并记录失败原因
+   * （toggle enable 重算与 dispatch 成功推进两处共用）。禁止 `?? now()` 类 fallback
+   * （会使 nextRunAt=now，下个 tick 立即重算 → 死循环）；nextRunAt 保留原值——
+   * enabled=false 后 tick 不再触发。
+   */
+  private disableForInvalidCron(task: ScheduledTask): void {
+    task.enabled = false
+    task.lastStatus = 'failed'
+    task.lastError = 'cron expression invalid'
+  }
+
   // ── 装配与回调 ──
 
   /** 装配点注入初始任务数组（读盘/重放由 backend 完成，runtime 只持有内存态）。 */
@@ -492,16 +388,7 @@ export class SchedulerRuntime {
     } catch (err) {
       // best-effort 降级（ER-APPEND-FAIL）：append-only 模型下 append 失败仅丢失该 op 的持久化，
       // 内存态已先行更新、不 rethrow，业务流程继续。at-least-once 已知恶化窗口（resume 重放回退）。
-      logger.warn('appendEntry failed', { error: err instanceof Error ? err.message : String(err) })
+      logger.warn('appendEntry failed', { error: toErrorMessage(err) })
     }
   }
-
-  /**
-   * ScheduledTask → TaskSnapshot：剥离 ownerSessionFile（在 op 顶层）与 pending（运行时标记），
-   * history 深拷贝（避免快照与运行时 task 共享数组引用）。
-   */
-  private toSnapshot(task: ScheduledTask): TaskSnapshot {
-    const { ownerSessionFile: _o, pending: _p, history, ...rest } = task
-    return { ...rest, history: history.slice() }
-  }
 }

package/src/service.ts

@@ -1,3 +1,5 @@
+import { toErrorMessage } from '@zhushanwen/pi-ext-guards'
+
 import { formatRelativeTime, formatSchedule } from './format.js'
 import { computeNextRuns, parseSchedule } from './parsing.js'
 import type { SchedulerRuntime } from './runtime.js'
@@ -8,18 +10,12 @@ const PREVIEW_RUN_COUNT = 5
 
 // ── 结构化结果 ──
 
-export type ServiceErrorCode =
-  | 'TASK_NOT_FOUND'
-  | 'INVALID_SCHEDULE'
-  | 'TASK_LIMIT_REACHED'
-  | 'DISPATCH_SKIPPED'
-  | 'INVALID_PARAMS'
-  | 'INTERNAL'
+// L1（ext-simplify-08）：errorCode 枚举与字段已删——W4 后失败通道收敛为 throw，
+// tool/command 两层均零消费方；失败语义由 message 文案承载。
 
 export interface ServiceResult<T = unknown> {
   success: boolean
   message: string
-  errorCode?: ServiceErrorCode
   data?: T
 }
 
@@ -29,7 +25,7 @@ export interface ServiceResult<T = unknown> {
  * tool 与 command 的唯一业务入口（IF-4 去双轨）：
  * 5 个动作单一实现，返回结构化 ServiceResult。
  * - 成功: { success: true, message, data }
- * - 失败: { success: false, errorCode, message }
+ * - 失败: { success: false, message }
  *
  * message 为用户可读纯文本（tool 用作 content 文本、command 直接输出），
  * data 供 tool details（create: {task, nextRuns}；list: {tasks}）。
@@ -41,39 +37,37 @@ export class SchedulerService {
    * 创建任务。
    * 注意：create 接收原始 schedule 字符串、内部 parseSchedule（而非已解析的
    * ScheduleSpec）——这是对 IF-4 草案 create(parseResult) 的有意细化：
-   * 解析失败需要结构化 INVALID_SCHEDULE 返回，把解析责任留在 service 内，
-   * tool/command 两层都不需要重复 parseSchedule。
+   * 解析失败需要结构化失败返回（success=false + 用户可读 message），把解析责任留在
+   * service 内，tool/command 两层都不需要重复 parseSchedule。
    */
   async create(
     prompt: string,
     scheduleInput: string,
     options: AddOptions = {},
   ): Promise<ServiceResult<{ task: ScheduledTask; nextRuns: number[] }>> {
-    const parsed = await parseSchedule(scheduleInput)
+    // parseSchedule 同步化（D2）后返回值即 ScheduleSpec（L7：不再包装 { spec }）；
+    // undefined 唯一语义 = 表达式无效——croner 是 dependencies 恒在盘，不存在解析器缺失
+    const parsed = parseSchedule(scheduleInput)
     if (!parsed) {
       return {
         success: false,
-        errorCode: 'INVALID_SCHEDULE',
         message: `Invalid schedule: "${scheduleInput}". Use duration (5m/2h/1d) or cron expression (*/10 * * * *).`,
       }
     }
 
     let task: ScheduledTask
     try {
-      task = await this.runtime.addTask(prompt, parsed.spec, options)
+      task = await this.runtime.addTask(prompt, parsed, options)
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err)
-      if (message.startsWith('Task limit reached')) {
-        return { success: false, errorCode: 'TASK_LIMIT_REACHED', message }
-      }
-      // 意外错误兜底（正常路径不会到达：parseSchedule 已校验 cron 有效性）
-      return { success: false, errorCode: 'INTERNAL', message }
+      // 失败归一 message 通道（L1）：任务上限 / 意外错误（正常路径不会到达——
+      // parseSchedule 已校验 cron 有效性）同样回传原始 message
+      return { success: false, message: toErrorMessage(err) }
     }
 
     const count = task.kind === 'once' ? 1 : PREVIEW_RUN_COUNT
     // 消息内相对时间与 nextRuns 必须同基准：分开读时钟会在整点边界漂移（in 1h → in 59m）
     const now = this.now()
-    const nextRuns = await computeNextRuns(task.schedule, now, count)
+    const nextRuns = computeNextRuns(task.schedule, now, count)
     // once 单行内联回显（只执行 1 次，编号列表会误导）；recurring 保持 5 行编号列表
     const runPreview =
       task.kind === 'once'
@@ -82,14 +76,13 @@ export class SchedulerService {
             'Next 5 runs:',
             ...nextRuns.map((t, i) => `  ${i + 1}. ${formatRelativeTime(t, now)}`),
           ].join('\n')
-    // 一行紧凑：name(id) + schedule(含 kind 信息) + expires + force。
-    // 删冗余 Kind 行（formatSchedule 已含 once/every）；Expires/Force 合并（默认 no-expires/no-force 显式）。
+    // 一行紧凑：name(id) + schedule(含 kind 信息) + expires。
+    // 删冗余 Kind 行（formatSchedule 已含 once/every）；Expires 合并（默认 no-expires 显式）。
     const expiresLabel = task.expiresAt
       ? `expires ${formatRelativeTime(task.expiresAt, now)}`
       : 'no-expires'
-    const forceLabel = task.force ? 'force' : 'no-force'
     const message = [
-      `Task "${task.name}" (${task.id}) created. ${formatSchedule(task.schedule, task.kind)}, ${expiresLabel}, ${forceLabel}`,
+      `Task "${task.name}" (${task.id}) created. ${formatSchedule(task.schedule, task.kind)}, ${expiresLabel}`,
       runPreview,
     ].join('\n')
 
@@ -111,49 +104,47 @@ export class SchedulerService {
 
   async toggle(id: string | undefined, enabled: boolean | undefined): Promise<ServiceResult> {
     if (!id) {
-      return { success: false, errorCode: 'INVALID_PARAMS', message: 'id is required for toggle.' }
+      return { success: false, message: 'id is required for toggle.' }
     }
     if (enabled === undefined) {
-      return { success: false, errorCode: 'INVALID_PARAMS', message: 'enabled is required for toggle.' }
+      return { success: false, message: 'enabled is required for toggle.' }
     }
     const success = await this.runtime.toggleTask(id, enabled)
     if (!success) {
-      return { success: false, errorCode: 'TASK_NOT_FOUND', message: `Task ${id} not found.` }
+      return { success: false, message: `Task ${id} not found.` }
     }
     return { success: true, message: `Task ${id} ${enabled ? 'enabled' : 'disabled'}.` }
   }
 
   delete(id: string | undefined): ServiceResult {
     if (!id) {
-      return { success: false, errorCode: 'INVALID_PARAMS', message: 'id is required for delete.' }
+      return { success: false, message: 'id is required for delete.' }
     }
     const success = this.runtime.deleteTask(id)
     if (!success) {
-      return { success: false, errorCode: 'TASK_NOT_FOUND', message: `Task ${id} not found.` }
+      return { success: false, message: `Task ${id} not found.` }
     }
     return { success: true, message: `Task ${id} deleted.` }
   }
 
   /**
    * 立即执行任务。语义细分：
-   * 任务不存在 → TASK_NOT_FOUND；任务存在但 dispatch no-op
-   * （disabled / rate-limited / 同任务入队已在 TTL 窗口内）→ DISPATCH_SKIPPED。
-   * busy 不再是 no-op：非 force 任务入队 delivery 内核即成功（park 等后续投递）。
+   * 任务不存在 → not found 文案；任务存在但 dispatch no-op
+   * （disabled / rate-limited / 同任务在途）→ not dispatched 文案。
    * 修复了旧实现把 no-op 误报为 not found 的混同。
    */
   async run(id: string | undefined): Promise<ServiceResult> {
     if (!id) {
-      return { success: false, errorCode: 'INVALID_PARAMS', message: 'id is required for run.' }
+      return { success: false, message: 'id is required for run.' }
     }
     if (!this.runtime.getTask(id)) {
-      return { success: false, errorCode: 'TASK_NOT_FOUND', message: `Task ${id} not found.` }
+      return { success: false, message: `Task ${id} not found.` }
     }
     const dispatched = await this.runtime.runTaskNow(id)
     if (!dispatched) {
       return {
         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).`,
       }
     }
     return { success: true, message: `Task ${id} executed.` }