@zhushanwen/pi-scheduler 0.1.0 → 0.2.0

package/src/__tests__/service.test.ts

@@ -0,0 +1,214 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { MockSchedulerBackend } from '../backend.js'
+import { SchedulerRuntime } from '../runtime.js'
+import { SchedulerService } from '../service.js'
+
+const mockCtx = { isIdle: () => true, hasPendingMessages: () => false }
+
+describe('SchedulerService', () => {
+  let service: SchedulerService
+  let backend: MockSchedulerBackend
+
+  beforeEach(() => {
+    backend = new MockSchedulerBackend()
+    service = new SchedulerService(new SchedulerRuntime(backend, mockCtx), () => backend.now())
+  })
+
+  describe('create', () => {
+    it('creates task with duration and returns full summary', async () => {
+      const result = await service.create('check build', '5m')
+      expect(result.success).toBe(true)
+      expect(result.errorCode).toBeUndefined()
+      expect(result.message).toContain('Task "check build"')
+      expect(result.message).toContain('every 5m')
+      expect(result.message).toContain('Next 5 runs:')
+      expect(result.data!.task.schedule).toEqual({ mode: 'interval', intervalMs: 300000 })
+      expect(result.data!.nextRuns).toHaveLength(5)
+      // TC-RECURRING-NO-REGRESS：recurring 回显仍为 5 行编号 run 行（编号列表不变）
+      const runLines = result.message.split('\n').filter(l => /^\s+\d+\./.test(l))
+      expect(runLines).toHaveLength(5)
+    })
+
+    // TC-ONCE-ECHO：once 任务回显仅 1 条 run 行（单行内联，无编号列表）
+    it('TC-ONCE-ECHO: once task echoes single run line without numbered list', async () => {
+      const result = await service.create('git pull', '1h', { kind: 'once' })
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('once in 1h')
+      expect(result.message).not.toContain('Next 5 runs:')
+      expect(result.message).toContain('Next run: in 1h')
+      // 无编号 run 行（once 单行内联）
+      expect(result.message).not.toMatch(/^\s+\d+\./m)
+      // nextRuns 数据同步裁剪
+      expect(result.data!.nextRuns).toHaveLength(1)
+    })
+
+    // TC-NOW-INJECT：create 用注入的 now 源（backend.now()）而非 Date.now()
+    it('TC-NOW-INJECT: create uses injected now source', async () => {
+      const fixedNow = Date.now()
+      const injectBackend = new MockSchedulerBackend()
+      injectBackend.nowValue = fixedNow
+      const nowService = new SchedulerService(new SchedulerRuntime(injectBackend, mockCtx), () => injectBackend.now())
+      const result = await nowService.create('one shot', '1h', { kind: 'once' })
+      expect(result.data!.nextRuns[0]).toBe(fixedNow + 3_600_000)
+      expect(result.message).toContain('in 1h')
+    })
+
+    it('creates cron task', async () => {
+      const result = await service.create('standup', '0 9 * * 1-5')
+      expect(result.success).toBe(true)
+      expect(result.data!.task.schedule).toEqual({ mode: 'cron', cronExpression: '0 0 9 * * 1-5' })
+    })
+
+    it('returns INVALID_SCHEDULE for invalid schedule', async () => {
+      const result = await service.create('test', 'invalid')
+      expect(result).toEqual({
+        success: false,
+        errorCode: 'INVALID_SCHEDULE',
+        message: 'Invalid schedule: "invalid". Use duration (5m/2h/1d) or cron expression (*/10 * * * *).',
+      })
+    })
+
+    it('returns TASK_LIMIT_REACHED when 50 tasks exist', async () => {
+      for (let i = 0; i < 50; i++) {
+        await service.create(`task ${i}`, '5m')
+      }
+      const result = await service.create('one more', '5m')
+      expect(result.success).toBe(false)
+      expect(result.errorCode).toBe('TASK_LIMIT_REACHED')
+      expect(result.message).toContain('Task limit reached (50)')
+    })
+  })
+
+  describe('list', () => {
+    it('returns empty message when no tasks', () => {
+      expect(service.list()).toEqual({
+        success: true,
+        message: 'No scheduled tasks.',
+        data: { tasks: [] },
+      })
+    })
+
+    it('returns formatted lines when tasks exist', async () => {
+      await service.create('check build', '5m')
+      const result = service.list()
+      expect(result.success).toBe(true)
+      expect(result.message).toContain('check build')
+      expect(result.message).toContain('every 5m')
+      expect(result.data!.tasks).toHaveLength(1)
+    })
+
+    it('marks disabled tasks with ○', async () => {
+      const created = await service.create('paused', '5m')
+      await service.toggle(created.data!.task.id, false)
+      const result = service.list()
+      expect(result.message).toContain('○')
+    })
+  })
+
+  describe('toggle', () => {
+    it('toggles task', async () => {
+      const created = await service.create('test', '5m')
+      const id = created.data!.task.id
+      const result = await service.toggle(id, false)
+      expect(result).toEqual({ success: true, message: `Task ${id} disabled.` })
+      expect(service.runtime.getTask(id)?.enabled).toBe(false)
+    })
+
+    it('TC4: returns TASK_NOT_FOUND for unknown id', async () => {
+      const result = await service.toggle('deadbeef', true)
+      expect(result).toEqual({
+        success: false,
+        errorCode: 'TASK_NOT_FOUND',
+        message: 'Task deadbeef not found.',
+      })
+    })
+
+    it('returns INVALID_PARAMS when id missing', async () => {
+      const result = await service.toggle(undefined, true)
+      expect(result).toEqual({
+        success: false,
+        errorCode: 'INVALID_PARAMS',
+        message: 'id is required for toggle.',
+      })
+    })
+
+    it('returns INVALID_PARAMS when enabled missing', async () => {
+      const result = await service.toggle('abc12345', undefined)
+      expect(result).toEqual({
+        success: false,
+        errorCode: 'INVALID_PARAMS',
+        message: 'enabled is required for toggle.',
+      })
+    })
+  })
+
+  describe('delete', () => {
+    it('deletes task', async () => {
+      const created = await service.create('test', '5m')
+      const id = created.data!.task.id
+      const result = service.delete(id)
+      expect(result).toEqual({ success: true, message: `Task ${id} deleted.` })
+      expect(service.runtime.getTask(id)).toBeUndefined()
+    })
+
+    it('TC4: returns TASK_NOT_FOUND for unknown id', () => {
+      const result = service.delete('deadbeef')
+      expect(result).toEqual({
+        success: false,
+        errorCode: 'TASK_NOT_FOUND',
+        message: 'Task deadbeef not found.',
+      })
+    })
+  })
+
+  describe('run', () => {
+    it('runs task now', async () => {
+      const created = await service.create('test', '5m')
+      const id = created.data!.task.id
+      const result = await service.run(id)
+      expect(result).toEqual({ success: true, message: `Task ${id} executed.` })
+      expect(service.runtime.getTask(id)?.runCount).toBe(1)
+    })
+
+    it('TC4: returns TASK_NOT_FOUND for unknown id', async () => {
+      const result = await service.run('deadbeef')
+      expect(result).toEqual({
+        success: false,
+        errorCode: 'TASK_NOT_FOUND',
+        message: 'Task deadbeef not found.',
+      })
+    })
+
+    it('returns DISPATCH_SKIPPED for disabled task (not not-found)', async () => {
+      const created = await service.create('test', '5m')
+      const id = created.data!.task.id
+      await service.toggle(id, false)
+      const result = await service.run(id)
+      expect(result).toEqual({
+        success: false,
+        errorCode: 'DISPATCH_SKIPPED',
+        message: `Task ${id} not dispatched (busy, disabled, or rate-limited).`,
+      })
+    })
+
+    // TC8：busy 场景（任务 enabled 但 ctx.isIdle() 返回 false）→ dispatch no-op →
+    // DISPATCH_SKIPPED。m2 只覆盖了 disabled 场景，busy 是 dispatchTask 的
+    // `!task.force && (!ctx.isIdle() || ctx.hasPendingMessages())` 独立分支。
+    it('returns DISPATCH_SKIPPED when ctx is busy (isIdle=false)', async () => {
+      const busyCtx = { isIdle: () => false, hasPendingMessages: () => false }
+      const busyBackend = new MockSchedulerBackend()
+      const busyService = new SchedulerService(new SchedulerRuntime(busyBackend, busyCtx), () => busyBackend.now())
+
+      const created = await busyService.create('test', '5m')
+      const id = created.data!.task.id
+      const result = await busyService.run(id)
+
+      expect(result.success).toBe(false)
+      expect(result.errorCode).toBe('DISPATCH_SKIPPED')
+      expect(result.message).toContain('busy')
+      // 未发送任何 message（dispatch no-op）
+      expect(busyBackend.sentMessages).toHaveLength(0)
+    })
+  })
+})

package/src/__tests__/tool.test.ts

@@ -1,45 +1,52 @@
-import { beforeEach,describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { MockSchedulerBackend } from '../backend.js'
 import { SchedulerRuntime } from '../runtime.js'
-import { createScheduleControlHandler,createScheduleHandler } from '../tool.js'
+import { SchedulerService } from '../service.js'
+import { createScheduleControlHandler, createScheduleHandler } from '../tool.js'
 
-const mockPi = { sendMessage: vi.fn() }
 const mockCtx = { isIdle: () => true, hasPendingMessages: () => false }
 
 describe('schedule tool', () => {
-  let runtime: SchedulerRuntime
+  let service: SchedulerService
   let handler: ReturnType<typeof createScheduleHandler>
 
   beforeEach(() => {
     vi.clearAllMocks()
-    runtime = new SchedulerRuntime('/test', mockPi as never, mockCtx as never)
-    handler = createScheduleHandler(runtime)
+    const backend = new MockSchedulerBackend()
+    service = new SchedulerService(new SchedulerRuntime(backend, mockCtx), () => backend.now())
+    handler = createScheduleHandler(service)
   })
 
   it('creates task with duration', async () => {
     const result = await handler({ prompt: 'check build', schedule: '5m' })
     expect(result.content[0]!.text).toContain('Task "check build"')
-    expect(result.details.task.schedule).toEqual({ mode: 'interval', intervalMs: 300000 })
+    const details = result.details as { task: { schedule: { mode: string; intervalMs: number } } }
+    expect(details.task.schedule).toEqual({ mode: 'interval', intervalMs: 300000 })
   })
 
-  it('throws for invalid schedule', async () => {
-    await expect(handler({ prompt: 'test', schedule: 'invalid' }))
-      .rejects.toThrow('Invalid schedule')
+  it('invalid schedule returns isError with message (not throw)', async () => {
+    const result = await handler({ prompt: 'test', schedule: 'invalid' })
+    expect(result.isError).toBe(true)
+    expect(result.content[0]!.text).toContain('Invalid schedule')
+    const details = result.details as { errorCode: string }
+    expect(details.errorCode).toBe('INVALID_SCHEDULE')
   })
 })
 
 describe('schedule_control tool', () => {
-  let runtime: SchedulerRuntime
+  let service: SchedulerService
   let handler: ReturnType<typeof createScheduleControlHandler>
 
   beforeEach(() => {
     vi.clearAllMocks()
-    runtime = new SchedulerRuntime('/test', mockPi as never, mockCtx as never)
-    handler = createScheduleControlHandler(runtime)
+    const backend = new MockSchedulerBackend()
+    service = new SchedulerService(new SchedulerRuntime(backend, mockCtx), () => backend.now())
+    handler = createScheduleControlHandler(service)
   })
 
   it('lists tasks', async () => {
-    await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+    await service.create('test', '5m')
     const result = await handler({ action: 'list' })
     expect(result.content[0]!.text).toContain('test')
   })
@@ -50,25 +57,35 @@ describe('schedule_control tool', () => {
   })
 
   it('toggles task', async () => {
-    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
-    const result = await handler({ action: 'toggle', id: task.id, enabled: false })
+    const created = await service.create('test', '5m')
+    const result = await handler({ action: 'toggle', id: created.data!.task.id, enabled: false })
     expect(result.content[0]!.text).toContain('disabled')
   })
 
-  it('throws for missing id on toggle', async () => {
-    await expect(handler({ action: 'toggle', enabled: true }))
-      .rejects.toThrow('id is required')
+  it('missing id on toggle returns isError', async () => {
+    const result = await handler({ action: 'toggle', enabled: true })
+    expect(result.isError).toBe(true)
+    expect(result.content[0]!.text).toContain('id is required')
+  })
+
+  // TC5 tool 侧：toggle 不存在 id → 结构化 isError + TASK_NOT_FOUND
+  it('TC5: toggle unknown id returns isError with TASK_NOT_FOUND', async () => {
+    const result = await handler({ action: 'toggle', id: 'deadbeef', enabled: false })
+    expect(result.isError).toBe(true)
+    const details = result.details as { errorCode: string }
+    expect(details.errorCode).toBe('TASK_NOT_FOUND')
+    expect(result.content[0]!.text).toBe('Task deadbeef not found.')
   })
 
   it('deletes task', async () => {
-    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
-    const result = await handler({ action: 'delete', id: task.id })
+    const created = await service.create('test', '5m')
+    const result = await handler({ action: 'delete', id: created.data!.task.id })
     expect(result.content[0]!.text).toContain('deleted')
   })
 
   it('runs task now', async () => {
-    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
-    const result = await handler({ action: 'run', id: task.id })
+    const created = await service.create('test', '5m')
+    const result = await handler({ action: 'run', id: created.data!.task.id })
     expect(result.content[0]!.text).toContain('executed')
   })
 })

package/src/backend.ts

@@ -0,0 +1,151 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+import { replayFoldEntries, type SchedulerEntryLike } from './replay.js'
+import type { ScheduledTask, SchedulerEntryOp } from './types.js'
+
+// ── SchedulerBackend 接口 ──
+
+/**
+ * 运行时协作后端抽象（依赖反转）。SchedulerRuntime 只依赖此接口：
+ * 不触碰 session JSONL、不持有 pi。
+ *
+ * - sendMessage: 到期 dispatch 的消息注入（生产实现委托 pi.sendMessage）
+ * - appendEntry: 按 op 写 pi-scheduler:task custom entry（event sourcing）。
+ *   生产实现委托 pi.appendEntry（同步落盘）。失败必须被调用方 try-catch（ER-APPEND-FAIL：
+ *   runtime 捕获后 console.warn + 不 rethrow，内存态已更新，at-least-once 已知恶化窗口）
+ * - getSessionFile: 当前 session JSONL 路径（addTask 构建 upsert op 的 ownerSessionFile 用；
+ *   --no-session 模式返回 undefined，调用方 ?? '' 兜底）
+ * - now: 时间源（测试可注入固定值）
+ *
+ * 读路径不在接口：loadTasks 由 PiSchedulerBackend 类方法承担（非接口成员），内部委托
+ * replayFoldEntries（折叠当前 session 的 custom entries 恢复任务），index.ts 装配点调用后
+ * 经 runtime.loadTasks(tasks) 注入。append-only 模型无需全量 persist——runtime 按 op 调
+ * appendEntry，replay 重放恢复，故 persist/persistSync 已移除。
+ *
+ * sendMessage 的 msg 签名与 pi 的 CustomMessage 对齐（customType/display 必填）：
+ * 调用方必须显式提供，PiSchedulerBackend 直接透传无需兜底默认值。
+ */
+export interface SchedulerBackend {
+  sendMessage(
+    msg: { content: string; customType: string; display: boolean },
+    opts?: { deliverAs?: 'followUp'; triggerTurn?: boolean },
+  ): Promise<void>
+  appendEntry(op: SchedulerEntryOp): void
+  getSessionFile(): string | undefined
+  now(): number
+}
+
+/**
+ * ctx.sessionManager 的最小可识别形状（duck-typed）。真实 ExtensionContext.sessionManager
+ * 返回 pi 的 SessionManager（getEntries(): SessionEntry[]、getSessionFile(): string|undefined），
+ * 结构兼容本接口。PiSchedulerBackend 只依赖这两个方法。
+ */
+export interface SchedulerBackendCtx {
+  sessionManager: {
+    getEntries(): SchedulerEntryLike[] | Iterable<SchedulerEntryLike>
+    getSessionFile(): string | undefined
+  }
+}
+
+// ── 生产实现 ──
+
+/**
+ * 生产后端：pi.appendEntry（写 custom entry 到 owner session JSONL）+ pi.sendMessage + Date.now()。
+ *
+ * 任务状态以 append-only event sourcing 持久化：runtime 各操作调 appendEntry 写 op，
+ * session_start 时 loadTasks 经 replayFoldEntries 折叠历史 entries 恢复。不再持有 store 文件、
+ * 不再全量 persist/persistSync。
+ */
+export class PiSchedulerBackend implements SchedulerBackend {
+  private ctx: SchedulerBackendCtx
+  private pi: Pick<ExtensionAPI, 'sendMessage' | 'appendEntry'>
+
+  constructor(ctx: SchedulerBackendCtx, pi: Pick<ExtensionAPI, 'sendMessage' | 'appendEntry'>) {
+    this.ctx = ctx
+    this.pi = pi
+  }
+
+  /**
+   * 读路径：折叠当前 session 的 pi-scheduler:task custom entries 恢复任务（非接口成员，
+   * 由装配点 session_start 调用）。replayFoldEntries 内部含 fork owner 过滤与异常兜底。
+   */
+  loadTasks(): ScheduledTask[] {
+    return [
+      ...replayFoldEntries(this.ctx.sessionManager.getEntries(), this.ctx.sessionManager.getSessionFile()).values(),
+    ]
+  }
+
+  async sendMessage(
+    msg: { content: string; customType: string; display: boolean },
+    opts?: { deliverAs?: 'followUp'; triggerTurn?: boolean },
+  ): Promise<void> {
+    await this.pi.sendMessage(msg, opts)
+  }
+
+  appendEntry(op: SchedulerEntryOp): void {
+    this.pi.appendEntry('pi-scheduler:task', op)
+  }
+
+  getSessionFile(): string | undefined {
+    return this.ctx.sessionManager.getSessionFile()
+  }
+
+  now(): number {
+    return Date.now()
+  }
+}
+
+// ── 测试实现 ──
+
+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
+
+  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()
+  }
+
+  /**
+   * 读路径（非接口成员，与 PiSchedulerBackend.loadTasks 对称）：经 replayFoldEntries 折叠
+   * fakeEntries + fakeSessionFile 恢复任务。测试用它验证 backend→replay 委托（TC-W-BACKEND-REPLAY）。
+   */
+  loadTasks(): ScheduledTask[] {
+    return [...replayFoldEntries(this.fakeEntries, this.fakeSessionFile).values()]
+  }
+}

package/src/commands.ts

@@ -1,8 +1,7 @@
 import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent'
 
-import { formatRelativeTime, formatSchedule } from './format.js'
-import { parseSchedule } from './parsing.js'
-import type { SchedulerRuntime } from './runtime.js'
+import { formatSchedule } from './format.js'
+import type { SchedulerService } from './service.js'
 
 /**
  * Shell-style quote-aware tokenizer.
@@ -41,17 +40,17 @@ function tokenizeQuoted(input: string): string[] {
  * 注册 /schedule command。
  * 消歧规则：第一个参数匹配子命令关键词则走对应分支，否则尝试 parseSchedule 创建任务。
  *
- * runtime 通过 getter 获取：registerScheduleCommand 在 factory 顶层调用，此时 session_start
- * 尚未触发、runtime 还是 null。getArgumentCompletions / handler 真正执行时才读 runtime 当前值。
+ * service 通过 getter 获取：registerScheduleCommand 在 factory 顶层调用，此时 session_start
+ * 尚未触发、service 还是 null。getArgumentCompletions / handler 真正执行时才读 service 当前值。
  */
 export function registerScheduleCommand(
   pi: ExtensionAPI,
-  getRuntime: () => SchedulerRuntime | null,
+  getService: () => SchedulerService | null,
 ) {
   pi.registerCommand('schedule', {
     description: 'Manage scheduled tasks. No args opens TUI. /schedule <schedule> <prompt> to create.',
     getArgumentCompletions(prefix: string) {
-      const runtime = getRuntime()
+      const service = getService()
       const trimmed = prefix.trimStart()
       const parts = trimmed.split(/\s+/).filter(Boolean)
       if (parts.length <= 1) {
@@ -66,17 +65,20 @@ export function registerScheduleCommand(
         ].filter(opt => opt.label.startsWith(trimmed.toLowerCase()))
       }
       // on/off/rm/run 后补全任务 id
-      if (['on', 'off', 'rm', 'run'].includes(parts[0]!) && runtime) {
-        return runtime.listTasks().map(t => ({
-          label: t.id,
-          value: t.id,
-          description: `${t.name} · ${formatSchedule(t.schedule)}`
-        }))
+      if (['on', 'off', 'rm', 'run'].includes(parts[0]!) && service) {
+        const result = service.list()
+        if (result.success && result.data) {
+          return result.data.tasks.map(t => ({
+            label: t.id,
+            value: t.id,
+            description: `${t.name} · ${formatSchedule(t.schedule, t.kind)}`
+          }))
+        }
       }
       return null
     },
     handler: async (args: string, ctx: ExtensionCommandContext) => {
-      const result = await executeScheduleCommand(getRuntime(), args)
+      const result = await executeScheduleCommand(getService(), args)
       ctx.ui.notify(result, 'info')
     },
   })
@@ -85,12 +87,14 @@ export function registerScheduleCommand(
 /**
  * Core logic for /schedule command. Extracted for testability (handler returns
  * void per SDK contract; tests call this function directly to assert output).
+ *
+ * 命令层只保留参数路由与 usage 文案（C6），业务调用全部走 SchedulerService。
  */
 export async function executeScheduleCommand(
-  runtime: SchedulerRuntime | null,
+  service: SchedulerService | null,
   args: string,
 ): Promise<string> {
-  if (!runtime) return 'Scheduler not initialized: session not started.'
+  if (!service) return 'Scheduler not initialized: session not started.'
 
   const trimmed = args.trim()
   if (!trimmed) {
@@ -103,32 +107,27 @@ export async function executeScheduleCommand(
 
   // 子命令路由
   if (first === 'list') {
-    const tasks = runtime.listTasks()
-    if (tasks.length === 0) return 'No scheduled tasks.'
-    return tasks.map(t =>
-      `${t.enabled ? '●' : '○'} ${t.id} ${t.name} · ${formatSchedule(t.schedule)} · ${formatRelativeTime(t.nextRunAt)}`
-    ).join('\n')
+    return service.list().message
   }
 
   if (first === 'on' || first === 'off') {
     const id = parts[1]
     if (!id) return `Usage: /schedule ${first} <id>`
-    const success = await runtime.toggleTask(id, first === 'on')
-    return success ? `Task ${id} ${first === 'on' ? 'enabled' : 'disabled'}.` : `Task ${id} not found.`
+    const result = await service.toggle(id, first === 'on')
+    return result.message
   }
 
   if (first === 'rm') {
     const id = parts[1]
     if (!id) return 'Usage: /schedule rm <id>'
-    const success = runtime.deleteTask(id)
-    return success ? `Task ${id} deleted.` : `Task ${id} not found.`
+    return service.delete(id).message
   }
 
   if (first === 'run') {
     const id = parts[1]
     if (!id) return 'Usage: /schedule run <id>'
-    const success = await runtime.runTaskNow(id)
-    return success ? `Task ${id} executed.` : `Task ${id} not found.`
+    const result = await service.run(id)
+    return result.message
   }
 
   // 创建任务分支
@@ -140,11 +139,6 @@ export async function executeScheduleCommand(
   const prompt = parts.slice(scheduleStart + 1).join(' ')
   if (!prompt) return 'Usage: /schedule <schedule> <prompt>'
 
-  const parsed = await parseSchedule(scheduleInput)
-  if (!parsed) {
-    return `Invalid schedule: "${scheduleInput}". Use duration (5m/2h/1d) or cron expression.`
-  }
-
-  const task = await runtime.addTask(prompt, parsed.spec, { kind })
-  return `Task "${task.name}" (${task.id}) created. Schedule: ${formatSchedule(task.schedule)}`
+  const result = await service.create(prompt, scheduleInput, { kind })
+  return result.message
 }

package/src/format.ts

@@ -1,10 +1,12 @@
 import { formatDuration } from './parsing.js'
-import type { ScheduleSpec } from './types.js'
+import type { ScheduleSpec, TaskKind } from './types.js'
 
-/** Format ScheduleSpec to readable string */
-export function formatSchedule(spec: ScheduleSpec): string {
+/** Format ScheduleSpec to readable string. kind 区分 once/recurring（once 显示 'once in X' 而非误导性的 'every X'）。 */
+export function formatSchedule(spec: ScheduleSpec, kind?: TaskKind): string {
   if (spec.mode === 'interval') {
-    return `every ${formatDuration(spec.intervalMs)}`
+    return kind === 'once'
+      ? `once in ${formatDuration(spec.intervalMs)}`
+      : `every ${formatDuration(spec.intervalMs)}`
   }
   return spec.cronExpression
 }