@zhushanwen/pi-scheduler 0.1.0 → 0.2.0

package/src/runtime.ts

@@ -1,30 +1,39 @@
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent'
 
+import type { SchedulerBackend } from './backend.js'
 import { autoName, generateTaskId } from './format.js'
-import { computeNextCronRunAt, parseDuration } from './parsing.js'
-import { createStore } from './store.js'
-import type { AddOptions, ScheduledTask, SchedulerStore, ScheduleSpec } from './types.js'
+import { computeNextRunAt, parseDuration } from './parsing.js'
+import type {
+  AddOptions,
+  ScheduledTask,
+  SchedulerEntryOp,
+  ScheduleSpec,
+  TaskSnapshot,
+} from './types.js'
 
 const MAX_TASKS = 50
 const RATE_LIMIT_PER_MINUTE = 6
 const TICK_INTERVAL_MS = 30_000
 const DEFAULT_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000 // 7 days
+const HISTORY_LIMIT = 20 // 与 replayFoldEntries 的裁剪上限一致（advance 折叠 / dispatch 累积共用）
 
 export class SchedulerRuntime {
   private tasks: Map<string, ScheduledTask> = new Map()
-  private store: ReturnType<typeof createStore>
-  private pi: Pick<ExtensionAPI, 'sendMessage'>
+  private backend: SchedulerBackend
   private ctx: Pick<ExtensionContext, 'isIdle' | 'hasPendingMessages'>
   private tickTimer: ReturnType<typeof setInterval> | null = null
   private dispatchTimestamps: number[] = []
+  private onAfterTickCallback: (() => void) | null = null
 
+  /**
+   * 依赖反转构造：backend 承担 appendEntry/pi.sendMessage/时间源，runtime 只持有内存态。
+   * 不触碰任何 FS / session JSONL（测试可用 MockSchedulerBackend 零副作用注入）。
+   */
   constructor(
-    cwd: string,
-    pi: Pick<ExtensionAPI, 'sendMessage'>,
+    backend: SchedulerBackend,
     ctx: Pick<ExtensionContext, 'isIdle' | 'hasPendingMessages'>,
   ) {
-    this.store = createStore(cwd)
-    this.pi = pi
+    this.backend = backend
     this.ctx = ctx
   }
 
@@ -36,7 +45,7 @@ export class SchedulerRuntime {
     }
 
     const id = generateTaskId()
-    const now = Date.now()
+    const now = this.backend.now()
     const kind = options.kind ?? 'recurring'
     const name = options.name ?? autoName(prompt)
 
@@ -48,16 +57,12 @@ export class SchedulerRuntime {
       expiresAt = now + expiryMs
     }
 
-    // 计算 nextRunAt：interval 模式 now + intervalMs；cron 模式首跑时间
-    let nextRunAt: number
-    if (schedule.mode === 'interval') {
-      nextRunAt = now + schedule.intervalMs
-    } else {
-      const next = await computeNextCronRunAt(schedule.cronExpression, now)
-      if (next === undefined) {
-        throw new Error(`Invalid cron expression: ${schedule.cronExpression}`)
-      }
-      nextRunAt = next
+    // 统一 nextRunAt 计算：interval → now + intervalMs；cron → 下次命中
+    const nextRunAt = await computeNextRunAt(schedule, now)
+    if (nextRunAt === undefined) {
+      // 创建时校验失败报错给用户（仅 cron 可能 undefined，interval 恒有值）
+      const expr = schedule.mode === 'cron' ? schedule.cronExpression : '<unknown>'
+      throw new Error(`Invalid cron expression: ${expr}`)
     }
 
     const task: ScheduledTask = {
@@ -76,7 +81,14 @@ export class SchedulerRuntime {
     }
 
     this.tasks.set(id, task)
-    this.persist()
+    // append-only：写 upsert op 到 owner session JSONL（ER-APPEND-FAIL catch，内存态已更新）
+    this.appendEntrySafe({
+      op: 'upsert',
+      taskId: id,
+      // getSessionFile() 在 --no-session 模式返回 undefined → '' 兜底（该模式 appendEntry 无 owner 不落盘）
+      ownerSessionFile: this.backend.getSessionFile() ?? '',
+      task: this.toSnapshot(task),
+    })
     return task
   }
 
@@ -92,31 +104,56 @@ export class SchedulerRuntime {
     const task = this.tasks.get(id)
     if (!task) return false
     task.enabled = enabled
+    // enable 重算到未来后的新 nextRunAt；携带到 toggle op 持久化，
+    // 防 resume 重放从 upsert 快照回退到旧过期 nextRunAt（P1 跨 session 持久化）
+    let recalcedNext: number | undefined
     // enable 时若 nextRunAt 已过期，重算，避免 enable 瞬间立即触发
-    if (enabled && task.nextRunAt < Date.now()) {
-      const schedule = task.schedule
-      if (schedule.mode === 'interval') {
-        task.nextRunAt = Date.now() + schedule.intervalMs
+    if (enabled && task.nextRunAt < this.backend.now()) {
+      const next = await 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 不再触发）
       } else {
-        task.nextRunAt = (await computeNextCronRunAt(schedule.cronExpression, Date.now())) ?? Date.now()
+        task.nextRunAt = next
+        recalcedNext = next
+        // MF-1：重算到未来后清除残留 pending。pending 是「到期待 dispatch」标记，
+        // 由 busy tick 的 step2 置位（W4 跨 tick 重试保留）。nextRunAt 已推到未来则该标记过期，
+        // 否则下个 tick step3 `pending && enabled` 会在重算的未来时间点之前提前 dispatch，
+        // 违背上方注释「避免 enable 瞬间立即触发」承诺。
+        task.pending = false
       }
     }
-    this.persist()
+    // 全部 mutation 完成后 append toggle：确保 append 的 enabled 是最终值
+    // （LOW4：cron-invalid 回退 enabled=false 的路径，append enabled=false 而非入参 true）
+    // P1：nextRunAt 仅 enable 重算到未来时携带——持久化重算值，防 resume 重放回退到 upsert 快照的旧过期值。
+    // 普通 toggle / cron 失效回退（recalcedNext=undefined）不带，重放时保持 upsert 快照值。
+    this.appendEntrySafe({
+      op: 'toggle',
+      taskId: id,
+      enabled: task.enabled,
+      ...(recalcedNext !== undefined && { nextRunAt: recalcedNext }),
+    })
     return true
   }
 
   deleteTask(id: string): boolean {
     const deleted = this.tasks.delete(id)
-    if (deleted) this.persist()
+    if (deleted) {
+      this.appendEntrySafe({ op: 'delete', taskId: id })
+    }
     return deleted
   }
 
   async runTaskNow(id: string): Promise<boolean> {
     const task = this.tasks.get(id)
     if (!task) return false
-    const dispatched = await this.dispatchTask(task)
-    this.persist()
-    return dispatched
+    // gap3：持久化由 dispatchTask 成功后 append advance(recurring)/delete(once) 隐式覆盖，
+    // 不在此重复 append（advance 已在 dispatchTask chokepoint）
+    return await this.dispatchTask(task)
   }
 
   // ── 调度 ──
@@ -133,26 +170,38 @@ export class SchedulerRuntime {
     }
   }
 
+  /**
+   * 注册 tick 后回调（W2）。index.ts 注册 refreshWidget 替代独立 widgetTimer——
+   * 每次 tickScheduler 末尾调用，对齐 TICK_INTERVAL_MS 刷新 widget。
+   */
+  onAfterTick(callback: () => void): void {
+    this.onAfterTickCallback = callback
+  }
+
   async tickScheduler(): Promise<void> {
-    const now = Date.now()
+    const now = this.backend.now()
 
-    // 1. 过期清理
+    // 1. 过期清理（must-fix 2 / CL9：append delete 抵消残留 upsert，防 resume 复活已过期任务）
+    // append-only 下 upsert entry 永久残留 JSONL（D10 不裁剪），若无 delete entry 抵消，
+    // resume 时 replayFoldEntries 会从 upsert 重放出已过期任务 → 每 resume 复活直到首个 tick。
     for (const [id, task] of this.tasks) {
       if (task.expiresAt && now >= task.expiresAt) {
         this.tasks.delete(id)
+        this.appendEntrySafe({ op: 'delete', taskId: id })
       }
     }
 
-    // 2. 标记到期
+    // 2. 标记到期（pending 是运行时标记，与 enabled 正交）
     for (const task of this.tasks.values()) {
       if (task.enabled && now >= task.nextRunAt) {
         task.pending = true
       }
     }
 
-    // 3. dispatch pending 任务（按 nextRunAt 排序）
+    // 3. dispatch pending 任务（按 nextRunAt 排序）。W4：显式 +t.enabled，
+    // 防御标记后到 dispatch 之间被 toggle disabled 的竞态（pending 与 enabled 正交）
     const pending = [...this.tasks.values()]
-      .filter(t => t.pending)
+      .filter(t => t.pending && t.enabled)
       .sort((a, b) => a.nextRunAt - b.nextRunAt)
 
     for (const task of pending) {
@@ -161,7 +210,8 @@ export class SchedulerRuntime {
       }
     }
 
-    this.persist()
+    // W2：tick 完成后刷新 widget（index.ts 注册 refreshWidget）
+    this.onAfterTickCallback?.()
   }
 
   // ── dispatch ──
@@ -170,6 +220,9 @@ export class SchedulerRuntime {
    * dispatch 单个任务。返回 true 表示真的发送了 message，false 表示 no-op
    * （task disabled / rate-limited / 非 force 且 busy）。
    * sendMessage 抛错时记录 failed 状态但不 rethrow，让 tick 继续处理其他任务。
+   *
+   * 持久化（append-only）：recurring 成功推进 nextRunAt → append advance（status='success' CL8）；
+   * once 成功 → append delete。失败 dispatch 不 append（CL7 重试语义，transient 失败 nextRunAt 未推进）。
    */
   async dispatchTask(task: ScheduledTask): Promise<boolean> {
     if (!task.enabled) return false
@@ -182,43 +235,61 @@ export class SchedulerRuntime {
     }
 
     // 检查速率限制
-    if (!this.hasDispatchCapacity(Date.now())) return false
+    if (!this.hasDispatchCapacity(this.backend.now())) return false
 
-    // 注入 message
+    // 注入 message（await：async 错误必须被捕获，fire-and-forget 会漏）
     try {
-      this.pi.sendMessage(
+      await this.backend.sendMessage(
         { content: task.prompt, customType: 'pi-scheduler:dispatched', display: true },
         { deliverAs: 'followUp', triggerTurn: true },
       )
     } catch {
       task.lastStatus = 'failed'
       task.pending = false
-      task.history.push({ at: Date.now(), status: 'failed' })
-      if (task.history.length > 20) task.history.shift()
+      task.history.push({ at: this.backend.now(), status: 'failed' })
+      if (task.history.length > HISTORY_LIMIT) task.history.shift()
       return false
     }
 
-    // 更新状态
+    // 更新状态（收敛到一个 now 值，避免多次 backend.now() 在真实时钟下漂移）
+    const now = this.backend.now()
     task.runCount++
-    task.lastRunAt = Date.now()
+    task.lastRunAt = now
     task.lastStatus = 'success'
     task.pending = false
-    task.history.push({ at: Date.now(), status: 'success' })
-    if (task.history.length > 20) task.history.shift()
+    task.lastError = undefined // 成功 dispatch 后清除历史错误
+    task.history.push({ at: now, status: 'success' })
+    if (task.history.length > HISTORY_LIMIT) task.history.shift()
 
-    // 计算下次执行
+    // 计算下次执行 + 持久化（append-only）
     if (task.kind === 'once') {
       this.tasks.delete(task.id)
+      // once 成功 → append delete（CL7：抵消 upsert，防 resume 复活已执行的 once 任务）
+      this.appendEntrySafe({ op: 'delete', taskId: task.id })
     } else {
-      const schedule = task.schedule
-      if (schedule.mode === 'interval') {
-        task.nextRunAt = Date.now() + schedule.intervalMs
+      const next = await computeNextRunAt(task.schedule, now)
+      if (next === undefined) {
+        // ERR-2 fallback：cron 表达式失效 → 停用任务，避免 `?? now()` 死循环。
+        // 不 append advance（nextRunAt 未推进，CL7 重试语义）；cron 失效停用的 enabled=false
+        // 持久化缺口属 at-least-once 已知窗口（首个 tick 会再停用），非 must-fix
+        task.enabled = false
+        task.lastStatus = 'failed'
+        task.lastError = 'cron expression invalid'
+        // nextRunAt 保留原值（enabled=false 后 tick 不再触发）
       } else {
-        task.nextRunAt = (await computeNextCronRunAt(schedule.cronExpression, Date.now())) ?? Date.now()
+        task.nextRunAt = next
+        // recurring 成功推进 nextRunAt → append advance（D1 核心：持久化新 nextRunAt，防 resume 回退重放）
+        this.appendEntrySafe({
+          op: 'advance',
+          taskId: task.id,
+          nextRunAt: next,
+          at: now,
+          status: 'success', // CL8：对齐 TaskStatus，非 'ok'
+        })
       }
     }
 
-    this.dispatchTimestamps.push(Date.now())
+    this.dispatchTimestamps.push(now)
     return true
   }
 
@@ -228,21 +299,39 @@ export class SchedulerRuntime {
     return this.dispatchTimestamps.length < RATE_LIMIT_PER_MINUTE
   }
 
-  // ── 持久化 ──
+  // ── 装配与回调 ──
 
-  loadTasks(): void {
-    const store = this.store.load()
-    this.tasks = new Map(store.tasks.map(t => [t.id, t]))
+  /** 装配点注入初始任务数组（读盘/重放由 backend 完成，runtime 只持有内存态）。 */
+  loadTasks(tasks: ScheduledTask[]): void {
+    this.tasks = new Map(tasks.map(t => [t.id, t]))
   }
 
-  persist(): void {
-    const store: SchedulerStore = { version: 1, tasks: Array.from(this.tasks.values()) }
-    this.store.persist(store)
+  // ── append-only 持久化辅助 ──
+
+  /**
+   * 委托 backend.appendEntry。失败 → console.warn + 不 rethrow（ER-APPEND-FAIL）。
+   * 内存态已先行更新（at-least-once 已知恶化窗口：append 失败则该 op 丢失，resume 重放回退）。
+   * 不再设 task.lastError='persist failed'（append 失败是 transient，不应污染业务态）。
+   */
+  private appendEntrySafe(op: SchedulerEntryOp): void {
+    try {
+      this.backend.appendEntry(op)
+    } catch (err) {
+      // best-effort 降级（ER-APPEND-FAIL）：append-only 模型下 append 失败仅丢失该 op 的持久化，
+      // 内存态已先行更新、不 rethrow，业务流程继续。at-least-once 已知恶化窗口（resume 重放回退）。
+      console.warn(
+        `[scheduler] appendEntry failed: ${err instanceof Error ? err.message : String(err)}`,
+      )
+    }
   }
 
-  persistSync(): void {
-    const store: SchedulerStore = { version: 1, tasks: Array.from(this.tasks.values()) }
-    this.store.persistSync(store)
+  /**
+   * 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

@@ -0,0 +1,156 @@
+import { formatRelativeTime, formatSchedule } from './format.js'
+import { computeNextRuns, parseSchedule } from './parsing.js'
+import type { SchedulerRuntime } from './runtime.js'
+import type { AddOptions, ScheduledTask } from './types.js'
+
+// recurring 预览行数（once 只回显 1 次）
+const PREVIEW_RUN_COUNT = 5
+
+// ── 结构化结果 ──
+
+export type ServiceErrorCode =
+  | 'TASK_NOT_FOUND'
+  | 'INVALID_SCHEDULE'
+  | 'TASK_LIMIT_REACHED'
+  | 'DISPATCH_SKIPPED'
+  | 'INVALID_PARAMS'
+  | 'INTERNAL'
+
+export interface ServiceResult<T = unknown> {
+  success: boolean
+  message: string
+  errorCode?: ServiceErrorCode
+  data?: T
+}
+
+// ── SchedulerService ──
+
+/**
+ * tool 与 command 的唯一业务入口（IF-4 去双轨）：
+ * 5 个动作单一实现，返回结构化 ServiceResult。
+ * - 成功: { success: true, message, data }
+ * - 失败: { success: false, errorCode, message }
+ *
+ * message 为用户可读纯文本（tool 用作 content 文本、command 直接输出），
+ * data 供 tool details（create: {task, nextRuns}；list: {tasks}）。
+ */
+export class SchedulerService {
+  constructor(public readonly runtime: SchedulerRuntime, private readonly now: () => number) {}
+
+  /**
+   * 创建任务。
+   * 注意：create 接收原始 schedule 字符串、内部 parseSchedule（而非已解析的
+   * ScheduleSpec）——这是对 IF-4 草案 create(parseResult) 的有意细化：
+   * 解析失败需要结构化 INVALID_SCHEDULE 返回，把解析责任留在 service 内，
+   * tool/command 两层都不需要重复 parseSchedule。
+   */
+  async create(
+    prompt: string,
+    scheduleInput: string,
+    options: AddOptions = {},
+  ): Promise<ServiceResult<{ task: ScheduledTask; nextRuns: number[] }>> {
+    const parsed = await 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)
+    } 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 }
+    }
+
+    const count = task.kind === 'once' ? 1 : PREVIEW_RUN_COUNT
+    const nextRuns = await computeNextRuns(task.schedule, this.now(), count)
+    // once 单行内联回显（只执行 1 次，编号列表会误导）；recurring 保持 5 行编号列表
+    const runPreview =
+      task.kind === 'once'
+        ? `Next run: ${formatRelativeTime(nextRuns[0]!)}`
+        : [
+            'Next 5 runs:',
+            ...nextRuns.map((t, i) => `  ${i + 1}. ${formatRelativeTime(t)}`),
+          ].join('\n')
+    // 一行紧凑：name(id) + schedule(含 kind 信息) + expires + force。
+    // 删冗余 Kind 行（formatSchedule 已含 once/every）；Expires/Force 合并（默认 no-expires/no-force 显式）。
+    const expiresLabel = task.expiresAt
+      ? `expires ${formatRelativeTime(task.expiresAt)}`
+      : 'no-expires'
+    const forceLabel = task.force ? 'force' : 'no-force'
+    const message = [
+      `Task "${task.name}" (${task.id}) created. ${formatSchedule(task.schedule, task.kind)}, ${expiresLabel}, ${forceLabel}`,
+      runPreview,
+    ].join('\n')
+
+    return { success: true, message, data: { task, nextRuns } }
+  }
+
+  list(): ServiceResult<{ tasks: ScheduledTask[] }> {
+    const tasks = this.runtime.listTasks()
+    if (tasks.length === 0) {
+      return { success: true, message: 'No scheduled tasks.', data: { tasks: [] } }
+    }
+    const message = tasks.map(t =>
+      `${t.enabled ? '●' : '○'} ${t.id} ${t.name} · ${formatSchedule(t.schedule, t.kind)} · ${formatRelativeTime(t.nextRunAt)}`
+    ).join('\n')
+    return { success: true, message, data: { tasks } }
+  }
+
+  async toggle(id: string | undefined, enabled: boolean | undefined): Promise<ServiceResult> {
+    if (!id) {
+      return { success: false, errorCode: 'INVALID_PARAMS', message: 'id is required for toggle.' }
+    }
+    if (enabled === undefined) {
+      return { success: false, errorCode: 'INVALID_PARAMS', 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: 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.' }
+    }
+    const success = this.runtime.deleteTask(id)
+    if (!success) {
+      return { success: false, errorCode: 'TASK_NOT_FOUND', message: `Task ${id} not found.` }
+    }
+    return { success: true, message: `Task ${id} deleted.` }
+  }
+
+  /**
+   * 立即执行任务。语义细分：
+   * 任务不存在 → TASK_NOT_FOUND；任务存在但 dispatch no-op
+   * （disabled / busy / rate-limited）→ DISPATCH_SKIPPED。
+   * 修复了旧实现把 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.' }
+    }
+    if (!this.runtime.getTask(id)) {
+      return { success: false, errorCode: 'TASK_NOT_FOUND', 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 (busy, disabled, or rate-limited).`,
+      }
+    }
+    return { success: true, message: `Task ${id} executed.` }
+  }
+}

package/src/tool.ts

@@ -1,8 +1,6 @@
 import { Static, Type } from 'typebox'
 
-import { formatRelativeTime, formatSchedule } from './format.js'
-import { computeNextRuns, parseSchedule } from './parsing.js'
-import type { SchedulerRuntime } from './runtime.js'
+import type { SchedulerService, ServiceResult } from './service.js'
 
 // TODO: add renderResult/renderCall to registerTool calls (standards.md §4.3)
 
@@ -23,37 +21,20 @@ export const scheduleGuidelines = [
   'This tool creates a scheduled task.',
   'Schedule accepts duration (5m, 2h, 1d) for interval-based or cron expression for time-based.',
   'Default kind is recurring. Set kind="once" for one-time reminders.',
-  'After creation, the response includes task id and next 5 run times.',
+  'After creation, the response includes task id and next run time(s).',
   'Default expiry is 7 days. Use expires="never" for long-term tasks.',
 ]
 
-export function createScheduleHandler(runtime: SchedulerRuntime) {
+/**
+ * schedule tool handler（SchedulerService 瘦壳，无独立业务逻辑）。
+ * 业务失败 → 结构化 isError result（不 throw）；service 未初始化等初始化异常
+ * 不在此 catch——穿透到 index.ts execute 的 catch 兜底（R3）。
+ */
+export function createScheduleHandler(service: SchedulerService) {
   return async (params: ScheduleParamsT) => {
     const { prompt, schedule: scheduleInput, kind, name, expires, force } = params
-
-    const parsed = await parseSchedule(scheduleInput)
-    if (!parsed) {
-      throw new Error(`Invalid schedule: "${scheduleInput}". Use duration (5m/2h/1d) or cron expression (*/10 * * * *).`)
-    }
-
-    const task = await runtime.addTask(prompt, parsed.spec, { kind, name, expires, force })
-
-    const nextRuns = await computeNextRuns(task.schedule, Date.now(), 5)
-    const summary = [
-      `Task "${task.name}" (${task.id}) created.`,
-      `Schedule: ${formatSchedule(task.schedule)}`,
-      `Kind: ${task.kind}`,
-      `Expires: ${task.expiresAt ? formatRelativeTime(task.expiresAt) : 'never'}`,
-      `Force: ${task.force ? 'yes' : 'no'}`,
-      '',
-      'Next 5 runs:',
-      ...nextRuns.map((t, i) => `  ${i + 1}. ${formatRelativeTime(t)}`),
-    ].join('\n')
-
-    return {
-      content: [{ type: 'text' as const, text: summary }],
-      details: { task, nextRuns },
-    }
+    const result = await service.create(prompt, scheduleInput, { kind, name, expires, force })
+    return toToolResult(result)
   }
 }
 
@@ -74,58 +55,53 @@ export const controlGuidelines = [
   'action="run" fires the task immediately.',
 ]
 
-export function createScheduleControlHandler(runtime: SchedulerRuntime) {
+export function createScheduleControlHandler(service: SchedulerService) {
   return async (params: ScheduleControlParamsT) => {
     const { action, id, enabled } = params
 
+    let result: ServiceResult
     switch (action) {
-      case 'list': {
-        const tasks = runtime.listTasks()
-        if (tasks.length === 0) {
-          return { content: [{ type: 'text' as const, text: 'No scheduled tasks.' }], details: { tasks: [] } }
-        }
-        const lines = tasks.map(t =>
-          `${t.enabled ? '●' : '○'} ${t.id} ${t.name} · ${formatSchedule(t.schedule)} · ${formatRelativeTime(t.nextRunAt)}`
-        )
-        return {
-          content: [{ type: 'text' as const, text: lines.join('\n') }],
-          details: { tasks },
-        }
-      }
-
-      case 'toggle': {
-        if (!id) throw new Error('id is required for toggle.')
-        if (enabled === undefined) throw new Error('enabled is required for toggle.')
-        const success = await runtime.toggleTask(id, enabled)
-        if (!success) throw new Error(`Task ${id} not found.`)
-        return {
-          content: [{ type: 'text' as const, text: `Task ${id} ${enabled ? 'enabled' : 'disabled'}.` }],
-          details: { success },
-        }
-      }
-
-      case 'delete': {
-        if (!id) throw new Error('id is required for delete.')
-        const success = runtime.deleteTask(id)
-        if (!success) throw new Error(`Task ${id} not found.`)
-        return {
-          content: [{ type: 'text' as const, text: `Task ${id} deleted.` }],
-          details: { success },
-        }
-      }
-
-      case 'run': {
-        if (!id) throw new Error('id is required for run.')
-        const success = await runtime.runTaskNow(id)
-        if (!success) throw new Error(`Task ${id} not found.`)
-        return {
-          content: [{ type: 'text' as const, text: `Task ${id} executed.` }],
-          details: { success },
+      case 'list':
+        result = service.list()
+        break
+      case 'toggle':
+        result = await service.toggle(id, enabled)
+        break
+      case 'delete':
+        result = service.delete(id)
+        break
+      case 'run':
+        result = await service.run(id)
+        break
+      default:
+        result = {
+          success: false,
+          errorCode: 'INVALID_PARAMS',
+          message: `Unknown action: ${action}`,
         }
-      }
+    }
+    return toToolResult(result)
+  }
+}
 
-      default:
-        throw new Error(`Unknown action: ${action}`)
+/**
+ * ServiceResult → tool execute 返回。
+ * 成功 → {content: [message], details: data}；失败 → isError + details.errorCode。
+ */
+function toToolResult(result: ServiceResult): {
+  content: { type: 'text'; text: string }[]
+  details: unknown
+  isError?: boolean
+} {
+  if (!result.success) {
+    return {
+      content: [{ type: 'text' as const, text: result.message }],
+      details: { errorCode: result.errorCode },
+      isError: true,
     }
   }
+  return {
+    content: [{ type: 'text' as const, text: result.message }],
+    details: result.data ?? {},
+  }
 }