@zhushanwen/pi-scheduler 0.0.2

package/src/__tests__/runtime.test.ts

@@ -0,0 +1,232 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// M11：mock store 模块，避免 SchedulerRuntime 触发真实 FS 写入。
+// 原实现用 new SchedulerRuntime('/test', ...) → createStore('/test') 会写
+// ~/.pi/agent/scheduler/root/test/scheduler.json（store.test.ts:87 stderr 已证实）。
+// mock 后 load 返回空 store、persist/persistSync 为 no-op，runtime 完全不碰 FS。
+vi.mock('../store.js', () => ({
+  createStore: () => ({
+    load: () => ({ version: 1, tasks: [] }),
+    persist: vi.fn(),
+    persistSync: vi.fn(),
+    storePath: '/mocked/scheduler.json',
+  }),
+}))
+
+import { SchedulerRuntime } from '../runtime.js'
+
+// Mock pi 和 ctx
+const mockPi = { sendMessage: vi.fn() }
+const mockCtx = { isIdle: () => true, hasPendingMessages: () => false }
+
+describe('SchedulerRuntime', () => {
+  let runtime: SchedulerRuntime
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    runtime = new SchedulerRuntime('/test', mockPi as never, mockCtx as never)
+  })
+
+  describe('addTask', () => {
+    it('creates a new task', async () => {
+      const task = await runtime.addTask('check build', { mode: 'interval', intervalMs: 60000 })
+      expect(task.id).toHaveLength(8)
+      expect(task.prompt).toBe('check build')
+      expect(task.enabled).toBe(true)
+    })
+
+    it('throws when task limit reached', async () => {
+      for (let i = 0; i < 50; i++) {
+        await runtime.addTask(`task ${i}`, { mode: 'interval', intervalMs: 60000 })
+      }
+      await expect(runtime.addTask('one more', { mode: 'interval', intervalMs: 60000 }))
+        .rejects.toThrow('Task limit reached')
+    })
+  })
+
+  describe('listTasks', () => {
+    it('returns tasks sorted by nextRunAt', async () => {
+      await runtime.addTask('task 1', { mode: 'interval', intervalMs: 60000 })
+      await runtime.addTask('task 2', { mode: 'interval', intervalMs: 30000 })
+      const tasks = runtime.listTasks()
+      expect(tasks).toHaveLength(2)
+      // 30s interval 的 nextRunAt 早于 60s 的，应排前
+      expect(tasks[0]!.nextRunAt).toBeLessThan(tasks[1]!.nextRunAt)
+    })
+
+    // 强化断言：30s 任务 nextRunAt 更小（更早），应是 listTasks()[0]
+    it('orders shorter-interval task first', async () => {
+      const t60 = await runtime.addTask('60s', { mode: 'interval', intervalMs: 60000 })
+      const t30 = await runtime.addTask('30s', { mode: 'interval', intervalMs: 30000 })
+      const tasks = runtime.listTasks()
+      expect(tasks[0]!.id).toBe(t30.id)
+      expect(tasks[0]!.nextRunAt).toBeLessThan(t60.nextRunAt)
+    })
+  })
+
+  describe('toggleTask', () => {
+    it('toggles task enabled state', async () => {
+      const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+      expect(await runtime.toggleTask(task.id, false)).toBe(true)
+      expect(runtime.getTask(task.id)?.enabled).toBe(false)
+    })
+
+    it('returns false for non-existent task', async () => {
+      expect(await runtime.toggleTask('nonexistent', true)).toBe(false)
+    })
+  })
+
+  describe('deleteTask', () => {
+    it('deletes existing task', async () => {
+      const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+      expect(runtime.deleteTask(task.id)).toBe(true)
+      expect(runtime.getTask(task.id)).toBeUndefined()
+    })
+
+    it('returns false for non-existent task', () => {
+      expect(runtime.deleteTask('nonexistent')).toBe(false)
+    })
+  })
+
+  describe('dispatchTask', () => {
+    it('dispatches task when idle', async () => {
+      const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+      runtime.dispatchTask(task)
+      expect(mockPi.sendMessage).toHaveBeenCalledWith(
+        expect.objectContaining({ content: 'test' }),
+        expect.any(Object),
+      )
+    })
+
+    it('skips disabled task', async () => {
+      const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+      await runtime.toggleTask(task.id, false)
+      runtime.dispatchTask(task)
+      expect(mockPi.sendMessage).not.toHaveBeenCalled()
+    })
+
+    it('skips when not idle and force is false', async () => {
+      const busyCtx = { isIdle: () => false, hasPendingMessages: () => false }
+      const busyRuntime = new SchedulerRuntime('/test', mockPi as never, busyCtx as never)
+      const task = await busyRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+      busyRuntime.dispatchTask(task)
+      expect(mockPi.sendMessage).not.toHaveBeenCalled()
+    })
+
+    it('dispatches when force is true even if busy', async () => {
+      const busyCtx = { isIdle: () => false, hasPendingMessages: () => false }
+      const busyRuntime = new SchedulerRuntime('/test', mockPi as never, busyCtx as never)
+      const task = await busyRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 }, { force: true })
+      busyRuntime.dispatchTask(task)
+      expect(mockPi.sendMessage).toHaveBeenCalled()
+    })
+
+    // OR 组合补全：源码 `!isIdle() || hasPendingMessages()` 任一为真即跳过。
+    // idle=true 但有 pending message → dispatch 应被跳过。
+    it('skips when idle but has pending messages', async () => {
+      const pendingCtx = { isIdle: () => true, hasPendingMessages: () => true }
+      const pendingRuntime = new SchedulerRuntime('/test', mockPi as never, pendingCtx as never)
+      const task = await pendingRuntime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+      pendingRuntime.dispatchTask(task)
+      expect(mockPi.sendMessage).not.toHaveBeenCalled()
+    })
+  })
+
+  // ── M10b：rate-limit ──
+  // dispatchTask 受 RATE_LIMIT_PER_MINUTE=6 限制。前 6 次成功（sendMessage 被调），
+  // 第 7 次被 hasDispatchCapacity 拒绝（dispatchTimestamps.length 已达 6）。
+  describe('rate-limit', () => {
+    beforeEach(() => {
+      vi.useFakeTimers()
+      vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
+    })
+
+    it('rate-limits dispatch to 6 per minute', async () => {
+      // force=true 保证不被 idle/busy 干扰，直接命中 rate-limit
+      const tasks: Awaited<ReturnType<typeof runtime.addTask>>[] = []
+      for (let i = 0; i < 7; i++) {
+        tasks.push(await runtime.addTask(`task ${i}`, { mode: 'interval', intervalMs: 60000 }, { force: true }))
+      }
+
+      // 7 次 dispatch 全在同一分钟内（fake time 不前进）
+      for (const task of tasks) {
+        await runtime.dispatchTask(task)
+      }
+
+      // 前 6 次成功，第 7 次被限流：sendMessage 只被调 6 次
+      expect(mockPi.sendMessage).toHaveBeenCalledTimes(6)
+    })
+
+    it('allows dispatch again after 1 minute window slides', async () => {
+      const task = await runtime.addTask('t', { mode: 'interval', intervalMs: 60000 }, { force: true })
+      // 先消耗完 6 次配额
+      for (let i = 0; i < 6; i++) {
+        // 同一 task 反复 dispatch（interval 模式每次重算 nextRunAt，不影响 rate-limit 计数）
+        await runtime.dispatchTask(task)
+      }
+      expect(mockPi.sendMessage).toHaveBeenCalledTimes(6)
+
+      // 时间前进 61 秒：旧 timestamp 滑出窗口，配额恢复
+      vi.setSystemTime(new Date('2026-01-01T00:01:01Z'))
+      const dispatched = await runtime.dispatchTask(task)
+      expect(dispatched).toBe(true)
+      expect(mockPi.sendMessage).toHaveBeenCalledTimes(7)
+    })
+  })
+
+  // ── M10d：tickScheduler ──
+  describe('tickScheduler', () => {
+    afterEach(() => {
+      vi.useRealTimers()
+    })
+
+    it('dispatches due interval tasks and advances nextRunAt', async () => {
+      vi.useFakeTimers()
+      const start = new Date('2026-01-01T00:00:00Z')
+      vi.setSystemTime(start)
+
+      const task = await runtime.addTask('tick me', { mode: 'interval', intervalMs: 60000 })
+      // 手动让任务过期（nextRunAt 设为过去）
+      task.nextRunAt = Date.now() - 1000
+
+      await runtime.tickScheduler()
+
+      // 已 dispatch
+      expect(mockPi.sendMessage).toHaveBeenCalledTimes(1)
+      const updated = runtime.getTask(task.id)
+      expect(updated).toBeDefined()
+      expect(updated!.runCount).toBe(1)
+      // nextRunAt 推进到 now + intervalMs（60000ms）
+      expect(updated!.nextRunAt).toBe(Date.now() + 60000)
+    })
+
+    it('removes expired tasks (expiresAt in the past)', async () => {
+      vi.useFakeTimers()
+      vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
+
+      const task = await runtime.addTask('expire me', { mode: 'interval', intervalMs: 60000 })
+      // expiresAt 已过：tick 的第 1 步清理会删除
+      task.expiresAt = Date.now() - 1000
+
+      await runtime.tickScheduler()
+
+      expect(runtime.getTask(task.id)).toBeUndefined()
+      // 过期清理先于 dispatch，不应 dispatch
+      expect(mockPi.sendMessage).not.toHaveBeenCalled()
+    })
+
+    it('deletes once task after dispatch', async () => {
+      vi.useFakeTimers()
+      vi.setSystemTime(new Date('2026-01-01T00:00:00Z'))
+
+      const task = await runtime.addTask('one-shot', { mode: 'interval', intervalMs: 60000 }, { kind: 'once' })
+      task.nextRunAt = Date.now() - 1000
+
+      await runtime.tickScheduler()
+
+      // once 任务 dispatch 后自删
+      expect(runtime.getTask(task.id)).toBeUndefined()
+      expect(mockPi.sendMessage).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/src/__tests__/sdk-contract.test.ts

@@ -0,0 +1,178 @@
+// src/__tests__/sdk-contract.test.ts
+//
+// SDK 契约测试：验证 pi-scheduler 扩展对 Pi SDK 的消费符合契约。
+// 保护本次 PR 修复的 4 个 tool 注册 bug 不回归：
+//   1. tool 注册名为 schedule / schedule_control
+//   2. tool 有 execute 函数字段（不是 handler/fn）
+//   3. execute 是 async function（SDK 期望返回 Promise）
+//   4. handler 抛错被 catch 转为 { isError: true }（standards.md §4.2 禁止抛）
+//
+// 不导入 SchedulerRuntime 的内部：只通过 index.ts 的 default export 测，
+// 保证 tool 注册逻辑的入口契约。
+//
+// 关键回归点：runtime 在 session_start 前为 null。execute 通过 getRuntime() 延迟
+// 读取——若在 factory 顶层捕获 runtime! 非空断言，注册时 runtime 为 null，
+// execute 调用会 NPE。此套件验证 session_start 前 execute 优雅返回 isError 而非 crash。
+
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import { describe, expect, it, vi } from 'vitest'
+
+// Mock store 模块：避免 runtime 触发真实 FS 写入（session_start 会创建 SchedulerRuntime，
+// 进而 createStore(cwd) 写 ~/.pi/agent/scheduler/...）。sdk-contract 只验证注册契约，
+// 不关心持久化，故 store 返回空状态 + no-op persist。
+vi.mock('../store.js', () => ({
+  createStore: () => ({
+    load: () => ({ version: 1, tasks: [] }),
+    persist: vi.fn(),
+    persistSync: vi.fn(),
+    storePath: '/mocked/scheduler.json',
+  }),
+}))
+
+import schedulerExtension from '../index.js'
+
+/**
+ * 构造 mock pi：捕获 registerTool 收到的 tool definition + registerCommand + 事件 handler。
+ * sendMessage 为空 vi.fn()，dispatch 路径会调用它但不影响契约断言。
+ */
+/** 捕获到的 tool definition：只关心我们要断言的字段。 */
+interface CapturedTool {
+  name: string
+  execute: (...args: unknown[]) => Promise<Record<string, unknown>>
+  handler?: unknown
+  fn?: unknown
+  [key: string]: unknown
+}
+
+function createMockPi(): {
+  pi: ExtensionAPI
+  tools: CapturedTool[]
+  commands: { name: string; opts: Record<string, unknown> }[]
+  events: Map<string, (...args: unknown[]) => void>
+} {
+  const tools: CapturedTool[] = []
+  const commands: { name: string; opts: Record<string, unknown> }[] = []
+  const events = new Map<string, (...args: unknown[]) => void>()
+  const pi = {
+    registerTool: (tool: CapturedTool) => tools.push(tool),
+    registerCommand: (name: string, opts: Record<string, unknown>) => commands.push({ name, opts }),
+    on: (event: string, handler: (...args: unknown[]) => void) => events.set(event, handler),
+    sendMessage: vi.fn(),
+  } as unknown as ExtensionAPI
+  return { pi, tools, commands, events }
+}
+
+/**
+ * 构造最小 fakeCtx：覆盖 index.ts 在 session_start/refreshWidget 中读到的字段。
+ * setWidget 在 session_start 立即调用一次（refreshWidget），故必须存在。
+ */
+function createFakeCtx(): ExtensionContext {
+  return {
+    cwd: '/test',
+    isIdle: () => true,
+    hasPendingMessages: () => false,
+    ui: { setWidget: vi.fn() },
+  } as unknown as ExtensionContext
+}
+
+describe('pi-scheduler SDK contract', () => {
+  it('registerTool 被调 2 次，name 为 schedule / schedule_control', () => {
+    const { pi, tools } = createMockPi()
+    schedulerExtension(pi)
+    expect(tools).toHaveLength(2)
+    expect(tools.map(t => t.name).sort()).toEqual(['schedule', 'schedule_control'])
+  })
+
+  it('每个 tool 有 execute 函数字段（不是 handler/fn）—— 本 PR 修的核心 bug', () => {
+    const { pi, tools } = createMockPi()
+    schedulerExtension(pi)
+    for (const tool of tools) {
+      expect(typeof tool.execute).toBe('function')
+      // 反回归：旧的错误字段名不应存在
+      expect(tool.handler).toBeUndefined()
+      expect(tool.fn).toBeUndefined()
+    }
+  })
+
+  it('execute 是 async function', () => {
+    const { pi, tools } = createMockPi()
+    schedulerExtension(pi)
+    for (const tool of tools) {
+      // async function 的 constructor 是 AsyncFunction
+      expect(tool.execute.constructor.name).toBe('AsyncFunction')
+    }
+  })
+
+  it('session_start 前 execute 抛错返回 isError（runtime 未初始化）', async () => {
+    const { pi, tools, events } = createMockPi()
+    schedulerExtension(pi)
+    const fakeCtx = createFakeCtx()
+
+    // 不触发 session_start，runtime 仍为 null
+    expect(events.get('session_start')).toBeDefined()
+
+    const result = await tools[0]!.execute('call-1', { prompt: 'x', schedule: '5m' }, undefined, undefined, fakeCtx)
+    expect(result).toEqual({
+      content: [{ type: 'text', text: 'Error: Scheduler not initialized: session not started' }],
+      details: {},
+      isError: true,
+    })
+  })
+
+  it('session_start 后 execute 正常返回结果', async () => {
+    const { pi, tools, events } = createMockPi()
+    schedulerExtension(pi)
+    const fakeCtx = createFakeCtx()
+
+    // 触发 session_start：runtime 被创建、loadTasks、startScheduler、refreshWidget
+    const sessionStart = events.get('session_start')!
+    await sessionStart({ type: 'session_start', reason: 'startup' }, fakeCtx)
+
+    const result = await tools[0]!.execute('call-2', { prompt: 'check build', schedule: '5m' }, undefined, undefined, fakeCtx)
+    // 正常路径：返回 content（非 isError）
+    expect(result.isError).toBeFalsy()
+    expect(result.content[0].text).toContain('Task "check build"')
+  })
+
+  it('execute 签名兼容 SDK 全签名（5 参数：toolCallId, params, signal, onUpdate, ctx）', async () => {
+    const { pi, tools, events } = createMockPi()
+    schedulerExtension(pi)
+    const fakeCtx = createFakeCtx()
+    await events.get('session_start')!({ type: 'session_start', reason: 'startup' }, fakeCtx)
+
+    // 传全 5 参，signal/onUpdate 为 undefined，不应抛
+    const result = await tools[0]!.execute('call-full', { prompt: 'x', schedule: '1h' }, undefined, undefined, fakeCtx)
+    expect(result.isError).toBeFalsy()
+  })
+
+  it('handler 抛错被 catch 为 isError（而非 throw）—— standards.md §4.2 契约', async () => {
+    const { pi, tools, events } = createMockPi()
+    schedulerExtension(pi)
+    const fakeCtx = createFakeCtx()
+    await events.get('session_start')!({ type: 'session_start', reason: 'startup' }, fakeCtx)
+
+    // 非法 cron 表达式：parseSchedule 会 reject，handler 抛 'Invalid schedule'，
+    // execute 应 catch 为 isError 而非让 promise reject。
+    const result = await tools[0]!.execute('call-err', { prompt: 'x', schedule: 'invalid-cron-expr-xxx' }, undefined, undefined, fakeCtx)
+    expect(result.isError).toBe(true)
+    expect(result.content[0].text).toContain('Error:')
+  })
+
+  it('schedule_control tool 同样 catch handler 错误', async () => {
+    const { pi, tools, events } = createMockPi()
+    schedulerExtension(pi)
+    const fakeCtx = createFakeCtx()
+    await events.get('session_start')!({ type: 'session_start', reason: 'startup' }, fakeCtx)
+
+    // toggle 不存在的 task id：handler 抛 'Task xxx not found'，应被 catch
+    const controlTool = tools.find(t => t.name === 'schedule_control')!
+    const result = await controlTool.execute('call-ctrl', { action: 'toggle', id: 'deadbeef', enabled: false }, undefined, undefined, fakeCtx)
+    expect(result.isError).toBe(true)
+  })
+
+  it('registerCommand 注册了名为 schedule 的命令', () => {
+    const { pi, commands } = createMockPi()
+    schedulerExtension(pi)
+    expect(commands.map(c => c.name)).toContain('schedule')
+  })
+})

package/src/__tests__/store.test.ts

@@ -0,0 +1,161 @@
+import * as fs from 'node:fs'
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { createStore, getStorePath } from '../store.js'
+import type { SchedulerStore } from '../types.js'
+
+// Mock fs 模块
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+}))
+
+describe('getStorePath', () => {
+  it('returns path under ~/.pi/agent/scheduler/', () => {
+    const p = getStorePath('/Users/test/project')
+    expect(p).toContain('.pi')
+    expect(p).toContain('agent')
+    expect(p).toContain('scheduler')
+    expect(p).toContain('scheduler.json')
+  })
+
+  it('generates different paths for different cwds', () => {
+    const p1 = getStorePath('/Users/test/project1')
+    const p2 = getStorePath('/Users/test/project2')
+    expect(p1).not.toBe(p2)
+  })
+})
+
+describe('createStore', () => {
+  const mockCwd = '/test/project'
+  let store: ReturnType<typeof createStore>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    store = createStore(mockCwd)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('load', () => {
+    it('returns empty store when file does not exist', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false)
+      const result = store.load()
+      expect(result).toEqual({ version: 1, tasks: [] })
+    })
+
+    it('parses valid JSON file', () => {
+      const mockStore: SchedulerStore = {
+        version: 1,
+        tasks: [{
+          id: 'abc12345',
+          name: 'test',
+          prompt: 'test prompt',
+          kind: 'recurring',
+          schedule: { mode: 'interval', intervalMs: 60000 },
+          enabled: true,
+          force: false,
+          createdAt: Date.now(),
+          nextRunAt: Date.now() + 60000,
+          runCount: 0,
+          history: [],
+        }],
+      }
+      vi.mocked(fs.existsSync).mockReturnValue(true)
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockStore))
+      const result = store.load()
+      expect(result.tasks).toHaveLength(1)
+      expect(result.tasks[0]!.id).toBe('abc12345')
+    })
+
+    it('returns empty store on corrupted JSON', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true)
+      vi.mocked(fs.readFileSync).mockReturnValue('invalid json{{{')
+      const result = store.load()
+      expect(result).toEqual({ version: 1, tasks: [] })
+    })
+  })
+
+  describe('persistSync', () => {
+    it('writes store to file', () => {
+      const mockStore: SchedulerStore = { version: 1, tasks: [] }
+      store.persistSync(mockStore)
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        expect.stringContaining('scheduler.json'),
+        expect.any(String),
+        'utf-8',
+      )
+    })
+
+    it('removes expired tasks', () => {
+      const now = Date.now()
+      const mockStore: SchedulerStore = {
+        version: 1,
+        tasks: [
+          {
+            id: 'expired',
+            name: 'expired task',
+            prompt: 'test',
+            kind: 'recurring',
+            schedule: { mode: 'interval', intervalMs: 60000 },
+            enabled: true,
+            force: false,
+            createdAt: now - 100000,
+            nextRunAt: now - 50000,
+            expiresAt: now - 10000,
+            runCount: 0,
+            history: [],
+          },
+          {
+            id: 'active',
+            name: 'active task',
+            prompt: 'test',
+            kind: 'recurring',
+            schedule: { mode: 'interval', intervalMs: 60000 },
+            enabled: true,
+            force: false,
+            createdAt: now,
+            nextRunAt: now + 60000,
+            runCount: 0,
+            history: [],
+          },
+        ],
+      }
+      store.persistSync(mockStore)
+      const written = JSON.parse(vi.mocked(fs.writeFileSync).mock.calls[0]![1] as string)
+      expect(written.tasks).toHaveLength(1)
+      expect(written.tasks[0].id).toBe('active')
+    })
+
+    it('trims history to 20 entries', () => {
+      const history = Array.from({ length: 25 }, (_, i) => ({
+        at: i * 1000,
+        status: 'success' as const,
+      }))
+      const mockStore: SchedulerStore = {
+        version: 1,
+        tasks: [{
+          id: 'task1',
+          name: 'task',
+          prompt: 'test',
+          kind: 'recurring',
+          schedule: { mode: 'interval', intervalMs: 60000 },
+          enabled: true,
+          force: false,
+          createdAt: 0,
+          nextRunAt: 60000,
+          runCount: 25,
+          history,
+        }],
+      }
+      store.persistSync(mockStore)
+      const written = JSON.parse(vi.mocked(fs.writeFileSync).mock.calls[0]![1] as string)
+      expect(written.tasks[0].history).toHaveLength(20)
+    })
+  })
+})

package/src/__tests__/tool.test.ts

@@ -0,0 +1,74 @@
+import { beforeEach,describe, expect, it, vi } from 'vitest'
+
+import { SchedulerRuntime } from '../runtime.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 handler: ReturnType<typeof createScheduleHandler>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    runtime = new SchedulerRuntime('/test', mockPi as never, mockCtx as never)
+    handler = createScheduleHandler(runtime)
+  })
+
+  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 })
+  })
+
+  it('throws for invalid schedule', async () => {
+    await expect(handler({ prompt: 'test', schedule: 'invalid' }))
+      .rejects.toThrow('Invalid schedule')
+  })
+})
+
+describe('schedule_control tool', () => {
+  let runtime: SchedulerRuntime
+  let handler: ReturnType<typeof createScheduleControlHandler>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    runtime = new SchedulerRuntime('/test', mockPi as never, mockCtx as never)
+    handler = createScheduleControlHandler(runtime)
+  })
+
+  it('lists tasks', async () => {
+    await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+    const result = await handler({ action: 'list' })
+    expect(result.content[0]!.text).toContain('test')
+  })
+
+  it('returns empty message when no tasks', async () => {
+    const result = await handler({ action: 'list' })
+    expect(result.content[0]!.text).toBe('No scheduled tasks.')
+  })
+
+  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 })
+    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('deletes task', async () => {
+    const task = await runtime.addTask('test', { mode: 'interval', intervalMs: 60000 })
+    const result = await handler({ action: 'delete', id: 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 })
+    expect(result.content[0]!.text).toContain('executed')
+  })
+})