@zhushanwen/pi-scheduler 0.0.2

package/index.ts

@@ -0,0 +1 @@
+export { default } from './src/index.js'

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@zhushanwen/pi-scheduler",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "index.ts",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "skills": []
+  },
+  "keywords": [
+    "pi-package"
+  ],
+  "devDependencies": {
+    "vitest": "^4.1.8"
+  },
+  "files": [
+    "index.ts",
+    "src/**/*.ts",
+    "vitest.config.ts"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@sinclair/typebox": "*",
+    "croner": "^9.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@sinclair/typebox": {
+      "optional": true
+    },
+    "croner": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/__tests__/commands.test.ts

@@ -0,0 +1,237 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { executeScheduleCommand, registerScheduleCommand } from '../commands.js'
+import { SchedulerRuntime } from '../runtime.js'
+
+// Mock store 避免 FS 副作用（runtime constructor 调 createStore）。
+vi.mock('../store.js', () => ({
+  createStore: () => ({
+    load: () => ({ version: 1, tasks: [] }),
+    persist: vi.fn(),
+    persistSync: vi.fn(),
+    storePath: '/mocked.json',
+  }),
+}))
+
+interface CommandOpts {
+  description: string
+  handler: (args: string) => Promise<string>
+  getArgumentCompletions: (prefix: string) => unknown
+}
+
+describe('/schedule command', () => {
+  let runtime: SchedulerRuntime
+  let commandOpts: CommandOpts
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // 注册命令时把 opts 截获下来，后续直接调 handler / getArgumentCompletions。
+    const mockPi = {
+      registerCommand: (_name: string, opts: CommandOpts) => {
+        commandOpts = opts
+      },
+    }
+    runtime = new SchedulerRuntime(
+      '/test',
+      { sendMessage: vi.fn() } as never,
+      { isIdle: () => true, hasPendingMessages: () => false } as never,
+    )
+    registerScheduleCommand(mockPi as never, () => runtime)
+  })
+
+  // ── 子命令路由：list ──
+
+  it('list returns empty message when no tasks', async () => {
+    expect(await executeScheduleCommand(runtime, 'list')).toBe('No scheduled tasks.')
+  })
+
+  it('list returns formatted task lines', async () => {
+    await runtime.addTask('check build', { mode: 'interval', intervalMs: 60000 })
+    const result = await executeScheduleCommand(runtime, 'list')
+    expect(result).toContain('check build')
+    expect(result).toContain('every 1m')
+  })
+
+  it('list marks disabled tasks with ○', async () => {
+    const task = await runtime.addTask('paused task', { mode: 'interval', intervalMs: 60000 })
+    await runtime.toggleTask(task.id, false)
+    const result = await executeScheduleCommand(runtime, 'list')
+    expect(result).toContain('○')
+    expect(result).toContain('paused task')
+  })
+
+  // ── 子命令路由：on / off ──
+
+  it('off toggles task enabled to false', async () => {
+    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+    const result = await executeScheduleCommand(runtime, `off ${task.id}`)
+    expect(result).toContain('disabled')
+    expect(runtime.getTask(task.id)?.enabled).toBe(false)
+  })
+
+  it('on toggles task enabled to true', async () => {
+    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+    await runtime.toggleTask(task.id, false)
+    const result = await executeScheduleCommand(runtime, `on ${task.id}`)
+    expect(result).toContain('enabled')
+    expect(runtime.getTask(task.id)?.enabled).toBe(true)
+  })
+
+  it('off with missing id returns usage', async () => {
+    expect(await executeScheduleCommand(runtime, 'off')).toBe('Usage: /schedule off <id>')
+  })
+
+  it('on with missing id returns usage', async () => {
+    expect(await executeScheduleCommand(runtime, 'on')).toBe('Usage: /schedule on <id>')
+  })
+
+  it('off with unknown id returns not found', async () => {
+    expect(await executeScheduleCommand(runtime, 'off deadbeef')).toBe('Task deadbeef not found.')
+  })
+
+  // ── 子命令路由：rm ──
+
+  it('rm deletes task', async () => {
+    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+    const result = await executeScheduleCommand(runtime, `rm ${task.id}`)
+    expect(result).toContain('deleted')
+    expect(runtime.getTask(task.id)).toBeUndefined()
+  })
+
+  it('rm with missing id returns usage', async () => {
+    expect(await executeScheduleCommand(runtime, 'rm')).toBe('Usage: /schedule rm <id>')
+  })
+
+  it('rm with unknown id returns not found', async () => {
+    expect(await executeScheduleCommand(runtime, 'rm deadbeef')).toBe('Task deadbeef not found.')
+  })
+
+  // ── 子命令路由：run ──
+
+  it('run executes task', async () => {
+    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+    const result = await executeScheduleCommand(runtime, `run ${task.id}`)
+    expect(result).toContain('executed')
+    // dispatchTask 更新 task 对象（同一引用），runCount 自增到 1。
+    expect(runtime.getTask(task.id)?.runCount).toBe(1)
+  })
+
+  it('run with missing id returns usage', async () => {
+    expect(await executeScheduleCommand(runtime, 'run')).toBe('Usage: /schedule run <id>')
+  })
+
+  it('run with unknown id returns not found', async () => {
+    expect(await executeScheduleCommand(runtime, 'run deadbeef')).toBe('Task deadbeef not found.')
+  })
+
+  // ── 创建任务分支 ──
+
+  it('creates interval task from /schedule 5m check build', async () => {
+    const result = await executeScheduleCommand(runtime, '5m check build')
+    expect(result).toContain('check build')
+    expect(result).toContain('every 5m')
+    expect(runtime.listTasks()).toHaveLength(1)
+  })
+
+  it('created interval task is recurring by default', async () => {
+    await executeScheduleCommand(runtime, '5m check build')
+    const task = runtime.listTasks()[0]!
+    expect(task.kind).toBe('recurring')
+  })
+
+  it('creates once task from /schedule once 10s remind', async () => {
+    const result = await executeScheduleCommand(runtime, 'once 10s remind me')
+    expect(result).toContain('remind me')
+    // once 任务 dispatch 后会被删除，但创建时尚未 dispatch
+    expect(runtime.listTasks()).toHaveLength(1)
+    const task = runtime.listTasks()[0]!
+    expect(task.kind).toBe('once')
+  })
+
+  // Quote-aware tokenizer 修复后，cron 'expr' 能正确提取整个表达式。
+  it('creates cron task from quoted expression', async () => {
+    const result = await executeScheduleCommand(runtime, "cron '*/10 * * * *' prompt")
+    expect(result).toContain('created')
+    expect(result).toContain('*/10 * * * *')
+    expect(runtime.listTasks()).toHaveLength(1)
+  })
+
+  it('creates cron task from double-quoted expression', async () => {
+    const result = await executeScheduleCommand(runtime, 'cron "0 9 * * 1-5" standup reminder')
+    expect(result).toContain('created')
+    expect(result).toContain('0 9 * * 1-5')
+    expect(runtime.listTasks()).toHaveLength(1)
+  })
+
+  // Unquoted multi-token cron still fails -- tokenizer cannot distinguish cron fields from prompt.
+  // Users should quote the cron expression or use the schedule tool (JSON params are unambiguous).
+  it('cron branch fails on unquoted multi-token expression (use quotes)', async () => {
+    const result = await executeScheduleCommand(runtime, 'cron */10 * * * * prompt')
+    expect(result).toMatch(/^Invalid schedule:/)
+    expect(result).toContain('*/10')
+  })
+
+  // ── 错误分支 ──
+
+  it('invalid schedule returns error message', async () => {
+    const result = await executeScheduleCommand(runtime, 'invalid-duration-str')
+    expect(result).toMatch(/invalid|usage/i)
+  })
+
+  it('schedule with no prompt returns usage', async () => {
+    const result = await executeScheduleCommand(runtime, '5m')
+    expect(result).toBe('Usage: /schedule <schedule> <prompt>')
+  })
+
+  it('no args returns TUI not-implemented message', async () => {
+    const result = await executeScheduleCommand(runtime, '')
+    expect(result).toContain('not yet implemented')
+  })
+
+  it('returns error when runtime is null', async () => {
+    expect(await executeScheduleCommand(null, 'list')).toBe('Scheduler not initialized: session not started.')
+  })
+
+  // ── getArgumentCompletions ──
+
+  it('completes subcommands for empty prefix', () => {
+    const completions = commandOpts.getArgumentCompletions('') as Array<{ label: string }>
+    const labels = completions.map(c => c.label)
+    expect(labels).toContain('list')
+    expect(labels).toContain('on')
+    expect(labels).toContain('off')
+    expect(labels).toContain('rm')
+    expect(labels).toContain('run')
+    expect(labels).toContain('once')
+    expect(labels).toContain('cron')
+  })
+
+  it('filters subcommands by prefix', () => {
+    const completions = commandOpts.getArgumentCompletions('r') as Array<{ label: string }>
+    const labels = completions.map(c => c.label)
+    expect(labels).toContain('rm')
+    expect(labels).toContain('run')
+    expect(labels).not.toContain('list')
+  })
+
+  it('completes task ids after on/off/rm/run', async () => {
+    const task = await runtime.addTask('mytask', { mode: 'interval', intervalMs: 60000 })
+    // 注意：路由要求 parts.length >= 2 才进 task-id 分支（'on ' 单 token 进子命令分支）。
+    // 当前实现对部分输入的 id 不做过滤，返回所有 task id。
+    const completions = commandOpts.getArgumentCompletions(`on ${task.id.slice(0, 2)}`) as Array<{ label: string; description: string }>
+    const labels = completions.map(c => c.label)
+    expect(labels).toContain(task.id)
+    expect(completions.find(c => c.label === task.id)?.description).toContain('mytask')
+  })
+
+  it('returns null for completion when runtime missing and prefix has 2 tokens', () => {
+    const mockPi = {
+      registerCommand: (_name: string, opts: CommandOpts) => {
+        commandOpts = opts
+      },
+    }
+    registerScheduleCommand(mockPi as never, () => null)
+    // 2 个 token 才能跳过子命令分支、命中末尾 return null
+    expect(commandOpts.getArgumentCompletions('on abcdef12')).toBeNull()
+  })
+})

package/src/__tests__/cron.test.ts

@@ -0,0 +1,107 @@
+// src/__tests__/cron.test.ts
+//
+// Cron 执行路径测试（M10a）。
+// parsing.test.ts 现有测试只覆盖 duration/interval 路径，未覆盖 cron 分支。
+// 此文件集中测 cron 相关导出：normalizeCronExpression / computeNextCronRunAt /
+// computeNextCronRuns / parseSchedule(cron) / computeNextRuns(cron)。
+//
+// croner 包是动态 import 的，测试时已安装（package.json peerDep croner ^9.0.0），
+// getCroner() 能正常返回模块，故 cron 路径在此可真实执行。
+
+import { describe, expect, it } from 'vitest'
+
+import {
+  computeNextCronRunAt,
+  computeNextCronRuns,
+  computeNextRuns,
+  normalizeCronExpression,
+  parseSchedule,
+} from '../parsing.js'
+
+describe('computeNextCronRunAt', () => {
+  it('返回有效时间戳（> Date.now()）', async () => {
+    const now = Date.now()
+    const next = await computeNextCronRunAt('*/10 * * * *')
+    expect(next).not.toBeUndefined()
+    expect(next!).toBeGreaterThan(now)
+  })
+
+  it('非法表达式返回 undefined', async () => {
+    const next = await computeNextCronRunAt('invalid expr')
+    expect(next).toBeUndefined()
+  })
+})
+
+describe('computeNextCronRuns', () => {
+  it('返回 count 个递增时间戳', async () => {
+    const from = Date.now()
+    const runs = await computeNextCronRuns('*/10 * * * *', from, 3)
+    expect(runs).toHaveLength(3)
+    // 严格递增
+    expect(runs[0]).toBeLessThan(runs[1]!)
+    expect(runs[1]).toBeLessThan(runs[2]!)
+    // 第一个应晚于 from
+    expect(runs[0]).toBeGreaterThan(from)
+  })
+
+  it('每两次执行间隔约 10 分钟（600000ms ± 容差）', async () => {
+    const from = Date.now()
+    const runs = await computeNextCronRuns('*/10 * * * *', from, 3)
+    const gap1 = runs[1]! - runs[0]!
+    const gap2 = runs[2]! - runs[1]!
+    // 10 分钟 = 600000ms，允许 ±2s 容差（cron 表达式按分钟边界对齐，间隔精确 10min）
+    expect(gap1).toBeGreaterThanOrEqual(600000 - 2000)
+    expect(gap1).toBeLessThanOrEqual(600000 + 2000)
+    expect(gap2).toBeGreaterThanOrEqual(600000 - 2000)
+    expect(gap2).toBeLessThanOrEqual(600000 + 2000)
+  })
+})
+
+describe('parseSchedule (cron 分支)', () => {
+  it('5 字段 cron 表达式补秒字段并附带 note', async () => {
+    const result = await parseSchedule('*/10 * * * *')
+    expect(result).toEqual({
+      spec: { mode: 'cron', cronExpression: '0 */10 * * * *' },
+      note: 'Auto-prepended seconds field (0)',
+    })
+  })
+
+  it('工作日 9 点 cron 表达式返回 cron mode', async () => {
+    const result = await parseSchedule('0 9 * * 1-5')
+    expect(result).toBeDefined()
+    expect(result!.spec.mode).toBe('cron')
+    expect(result!.spec).toEqual({ mode: 'cron', cronExpression: '0 0 9 * * 1-5' })
+  })
+
+  it('含空格但非法的表达式返回 undefined', async () => {
+    const result = await parseSchedule('invalid cron expr here')
+    expect(result).toBeUndefined()
+  })
+
+  it('非法分钟值（99）返回 undefined（croner 拒绝）', async () => {
+    const result = await parseSchedule('99 * * * *')
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('normalizeCronExpression', () => {
+  it('6 字段 cron 原样返回', () => {
+    const result = normalizeCronExpression('0 9 * * 1-5 0')
+    expect(result).toEqual({ expression: '0 9 * * 1-5 0' })
+  })
+
+  it('2 字段返回 undefined', () => {
+    expect(normalizeCronExpression('0 9')).toBeUndefined()
+  })
+})
+
+describe('computeNextRuns (cron mode)', () => {
+  it('返回 count 个递增时间戳', async () => {
+    const from = Date.now()
+    const spec = { mode: 'cron' as const, cronExpression: '*/10 * * * *' }
+    const runs = await computeNextRuns(spec, from, 2)
+    expect(runs).toHaveLength(2)
+    expect(runs[0]).toBeLessThan(runs[1]!)
+    expect(runs[0]).toBeGreaterThan(from)
+  })
+})

package/src/__tests__/format.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { autoName,formatRelativeTime, formatSchedule, generateTaskId, truncate } from '../format.js'
+import { formatDuration } from '../parsing.js'
+
+describe('formatSchedule', () => {
+  it('formats interval spec', () => {
+    expect(formatSchedule({ mode: 'interval', intervalMs: 300_000 })).toBe('every 5m')
+    expect(formatSchedule({ mode: 'interval', intervalMs: 3_600_000 })).toBe('every 1h')
+  })
+
+  it('formats cron spec', () => {
+    expect(formatSchedule({ mode: 'cron', cronExpression: '*/10 * * * *' })).toBe('*/10 * * * *')
+  })
+})
+
+describe('formatRelativeTime', () => {
+  // 固定系统时间避免 clock-boundary flake：formatRelativeTime 内部读 Date.now()，
+  // 若与测试捕获的 now 间有毫秒级偏差，正好压在 2h/1d 边界上的断言会偶发失败。
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-01-15T12:00:00.000Z'))
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('formats future time', () => {
+    const now = Date.now()
+    expect(formatRelativeTime(now + 300_000)).toBe('in 5m')
+    expect(formatRelativeTime(now + 7_200_000)).toBe('in 2h')
+  })
+
+  it('formats past time', () => {
+    const now = Date.now()
+    expect(formatRelativeTime(now - 300_000)).toBe('5m ago')
+    expect(formatRelativeTime(now - 86_400_000)).toBe('1d ago')
+  })
+
+  it('formats now for recent timestamps', () => {
+    const now = Date.now()
+    expect(formatRelativeTime(now)).toBe('now')
+    expect(formatRelativeTime(now + 2000)).toBe('now')
+    expect(formatRelativeTime(now - 2000)).toBe('now')
+  })
+
+  // 5 秒边界：源码 `< 5000` 严格小于。用显式 now 参数精确锁定，避免 fake-timer 漂移。
+  it('treats 4999ms as now and 5000ms as not-now (strict <)', () => {
+    const base = 1_700_000_000_000
+    expect(formatRelativeTime(base + 4999, base)).toBe('now')
+    expect(formatRelativeTime(base + 5000, base)).not.toBe('now')
+    expect(formatRelativeTime(base + 5000, base)).toBe('in 5s')
+  })
+})
+
+describe('truncate', () => {
+  it('returns original text if within limit', () => {
+    expect(truncate('hello', 10)).toBe('hello')
+    expect(truncate('hello', 5)).toBe('hello')
+  })
+
+  it('truncates and adds ellipsis', () => {
+    expect(truncate('hello world', 8)).toBe('hello...')
+    expect(truncate('a very long text', 10)).toBe('a very ...')
+  })
+
+  it('handles edge cases', () => {
+    expect(truncate('', 5)).toBe('')
+    expect(truncate('hi', 2)).toBe('hi')
+    expect(truncate('hi', 1)).toBe('h')
+  })
+
+  // maxLen<=3 分支：不加省略号，直接 slice
+  it('does not add ellipsis when maxLen <= 3', () => {
+    expect(truncate('hello', 3)).toBe('hel')
+    expect(truncate('hello', 0)).toBe('')
+  })
+})
+
+describe('formatDuration', () => {
+  // 秒兜底分支：>60s 但不能整除 m → 不被误判为 "1m"，走 Math.round(ms/1000)
+  it('falls back to seconds when not evenly divisible by larger units', () => {
+    expect(formatDuration(90_000)).toBe('90s')
+    expect(formatDuration(1500)).toBe('2s')
+  })
+})
+
+describe('generateTaskId', () => {
+  it('generates 8 character hex string', () => {
+    const id = generateTaskId()
+    expect(id).toHaveLength(8)
+    expect(id).toMatch(/^[0-9a-f]{8}$/)
+  })
+
+  it('generates unique ids', () => {
+    const ids = new Set(Array.from({ length: 100 }, () => generateTaskId()))
+    expect(ids.size).toBe(100)
+  })
+})
+
+describe('autoName', () => {
+  it('returns full prompt if <= 30 chars', () => {
+    expect(autoName('check build status')).toBe('check build status')
+    expect(autoName('a'.repeat(30))).toBe('a'.repeat(30))
+  })
+
+  it('truncates long prompt', () => {
+    const long = 'a'.repeat(50)
+    expect(autoName(long)).toBe('a'.repeat(27) + '...')
+  })
+
+  it('trims whitespace', () => {
+    expect(autoName('  hello  ')).toBe('hello')
+  })
+})

package/src/__tests__/parsing.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  computeNextRuns,
+  formatDuration,
+  normalizeCronExpression,
+  parseDuration,
+  parseSchedule,
+} from '../parsing.js'
+
+describe('parseDuration', () => {
+  it('parses seconds', () => {
+    expect(parseDuration('5s')).toBe(5000)
+    expect(parseDuration('30sec')).toBe(30_000)
+    expect(parseDuration('1second')).toBe(1000)
+    expect(parseDuration('2seconds')).toBe(2000)
+  })
+
+  it('parses minutes', () => {
+    expect(parseDuration('5m')).toBe(300_000)
+    expect(parseDuration('30min')).toBe(1_800_000)
+    expect(parseDuration('1minute')).toBe(60_000)
+    expect(parseDuration('2minutes')).toBe(120_000)
+  })
+
+  it('parses hours', () => {
+    expect(parseDuration('2h')).toBe(7_200_000)
+    expect(parseDuration('1hr')).toBe(3_600_000)
+    expect(parseDuration('1hour')).toBe(3_600_000)
+    expect(parseDuration('3hours')).toBe(10_800_000)
+  })
+
+  it('parses days', () => {
+    expect(parseDuration('1d')).toBe(86_400_000)
+    expect(parseDuration('7days')).toBe(604_800_000)
+  })
+
+  it('returns undefined for invalid input', () => {
+    expect(parseDuration('invalid')).toBeUndefined()
+    expect(parseDuration('')).toBeUndefined()
+    expect(parseDuration('5x')).toBeUndefined()
+    expect(parseDuration('abc5m')).toBeUndefined()
+  })
+
+  it('accepts zero value', () => {
+    expect(parseDuration('0s')).toBe(0)
+  })
+
+  it('returns undefined for bare number without unit', () => {
+    expect(parseDuration('5')).toBeUndefined()
+  })
+
+  it('trims leading/trailing whitespace', () => {
+    expect(parseDuration('  5m  ')).toBe(300_000)
+  })
+
+  it('accepts uppercase units (case-insensitive)', () => {
+    expect(parseDuration('5M')).toBe(300_000)
+    expect(parseDuration('5H')).toBe(18_000_000)
+  })
+})
+
+describe('formatDuration', () => {
+  it('formats milliseconds to readable string', () => {
+    expect(formatDuration(300_000)).toBe('5m')
+    expect(formatDuration(7_200_000)).toBe('2h')
+    expect(formatDuration(86_400_000)).toBe('1d')
+  })
+
+  it('uses largest unit possible', () => {
+    expect(formatDuration(3_600_000)).toBe('1h')
+    expect(formatDuration(60_000)).toBe('1m')
+    expect(formatDuration(1000)).toBe('1s')
+  })
+
+  it('handles edge cases', () => {
+    expect(formatDuration(0)).toBe('0s')
+    expect(formatDuration(-1000)).toBe('0s')
+  })
+})
+
+describe('normalizeCronExpression', () => {
+  it('prepends seconds field for 5-field cron', () => {
+    const result = normalizeCronExpression('*/10 * * * *')
+    expect(result).toEqual({
+      expression: '0 */10 * * * *',
+      note: 'Auto-prepended seconds field (0)',
+    })
+  })
+
+  it('keeps 6-field cron as-is', () => {
+    const result = normalizeCronExpression('0 */10 * * * *')
+    expect(result).toEqual({ expression: '0 */10 * * * *' })
+  })
+
+  it('returns undefined for invalid field count', () => {
+    expect(normalizeCronExpression('* * *')).toBeUndefined()
+    expect(normalizeCronExpression('')).toBeUndefined()
+  })
+})
+
+describe('parseSchedule', () => {
+  it('parses duration to interval mode', async () => {
+    const result = await parseSchedule('5m')
+    expect(result).toEqual({
+      spec: { mode: 'interval', intervalMs: 300_000 },
+    })
+  })
+
+  it('returns undefined for invalid duration', async () => {
+    const result = await parseSchedule('invalid')
+    expect(result).toBeUndefined()
+  })
+
+  it('returns undefined for empty input', async () => {
+    const result = await parseSchedule('')
+    expect(result).toBeUndefined()
+  })
+
+  // cron 分支：含空格的输入走 cron 解析（computeNextCronRunAt 验证有效性）
+  it('parses valid cron expression to cron mode', async () => {
+    const result = await parseSchedule('0 9 * * 1-5')
+    expect(result).toBeDefined()
+    expect(result!.spec.mode).toBe('cron')
+  })
+
+  it('returns undefined for invalid cron with spaces', async () => {
+    const result = await parseSchedule('not a valid cron')
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('computeNextRuns', () => {
+  it('computes interval runs', async () => {
+    const from = Date.now()
+    const spec = { mode: 'interval' as const, intervalMs: 60_000 }
+    const runs = await computeNextRuns(spec, from, 3)
+
+    expect(runs).toHaveLength(3)
+    expect(runs[0]).toBe(from + 60_000)
+    expect(runs[1]).toBe(from + 120_000)
+    expect(runs[2]).toBe(from + 180_000)
+  })
+
+  it('defaults to 5 runs', async () => {
+    const spec = { mode: 'interval' as const, intervalMs: 60_000 }
+    const runs = await computeNextRuns(spec)
+    expect(runs).toHaveLength(5)
+  })
+
+  // cron 分支：computeNextRuns 委托 computeNextCronRuns
+  it('computes cron runs (delegates to croner)', async () => {
+    const from = Date.now()
+    const spec = { mode: 'cron' as const, cronExpression: '*/10 * * * *' }
+    const runs = await computeNextRuns(spec, from, 3)
+    expect(runs).toHaveLength(3)
+    // cron runs 严格递增且都晚于 from
+    expect(runs[0]).toBeGreaterThan(from)
+    expect(runs[0]).toBeLessThan(runs[1]!)
+    expect(runs[1]).toBeLessThan(runs[2]!)
+  })
+})