openclaw-server 0.1.0

package/src/tasks/store.ts

@@ -0,0 +1,602 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import Database from "better-sqlite3";
+import { buildDateBounds, formatLocalDateTime } from "./timezone.js";
+import type {
+  ConversationDraft,
+  ReminderSummary,
+  ReminderStatus,
+  TaskScope,
+  TaskStats,
+  TaskStatus,
+  TaskSummary,
+} from "./types.js";
+
+type TaskRow = {
+  id: string;
+  user_id: string;
+  title: string;
+  source_text: string;
+  due_at: string;
+  timezone: string;
+  status: TaskStatus;
+  reminder_offset_minutes: number | null;
+  created_at: string;
+  updated_at: string;
+  completed_at: string | null;
+  cancelled_at: string | null;
+};
+
+type ReminderRow = {
+  id: string;
+  task_id: string;
+  user_id: string;
+  remind_at: string;
+  message: string;
+  status: ReminderStatus;
+  sent_at: string | null;
+  acked_at: string | null;
+  title: string;
+  due_at: string;
+  timezone: string;
+};
+
+type TaskStatsRow = {
+  totalTasks: number;
+  scheduledTasks: number | null;
+  doneTasks: number | null;
+  cancelledTasks: number | null;
+  overdueTasks: number | null;
+  todayTasks: number | null;
+  todayDoneTasks: number | null;
+};
+
+type CountRow = {
+  count: number;
+};
+
+function toIsoString(date: Date): string {
+  return date.toISOString();
+}
+
+function buildReminderMessage(title: string, dueAt: Date, timeZone: string): string {
+  return `提醒你：任务「${title}」时间为 ${formatLocalDateTime(dueAt, timeZone)}。回复：完成 / 延后10分钟 / 取消`;
+}
+
+function mapTask(row: TaskRow): TaskSummary {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    title: row.title,
+    sourceText: row.source_text,
+    dueAt: row.due_at,
+    dueAtText: formatLocalDateTime(new Date(row.due_at), row.timezone),
+    timezone: row.timezone,
+    status: row.status,
+    reminderOffsetMinutes: row.reminder_offset_minutes,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    completedAt: row.completed_at,
+    cancelledAt: row.cancelled_at,
+  };
+}
+
+function mapReminder(row: ReminderRow): ReminderSummary {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    userId: row.user_id,
+    title: row.title,
+    dueAt: row.due_at,
+    dueAtText: formatLocalDateTime(new Date(row.due_at), row.timezone),
+    remindAt: row.remind_at,
+    remindAtText: formatLocalDateTime(new Date(row.remind_at), row.timezone),
+    message: row.message,
+    status: row.status,
+  };
+}
+
+export class TaskStore {
+  private readonly db: Database;
+
+  constructor(
+    dbPath: string,
+    private readonly timezone: string,
+  ) {
+    if (dbPath !== ":memory:") {
+      fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    }
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS conversation_sessions (
+        user_id TEXT PRIMARY KEY,
+        status TEXT NOT NULL,
+        source_text TEXT NOT NULL,
+        title TEXT NOT NULL,
+        due_at TEXT NOT NULL,
+        reminder_offset_minutes INTEGER,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        source_text TEXT NOT NULL,
+        due_at TEXT NOT NULL,
+        timezone TEXT NOT NULL,
+        status TEXT NOT NULL,
+        reminder_offset_minutes INTEGER,
+        completed_at TEXT,
+        cancelled_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS task_reminders (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        remind_at TEXT NOT NULL,
+        message TEXT NOT NULL,
+        status TEXT NOT NULL,
+        sent_at TEXT,
+        acked_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY(task_id) REFERENCES tasks(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS task_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY(task_id) REFERENCES tasks(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_tasks_user_due ON tasks(user_id, due_at);
+      CREATE INDEX IF NOT EXISTS idx_tasks_user_status ON tasks(user_id, status);
+      CREATE INDEX IF NOT EXISTS idx_reminders_user_status_due ON task_reminders(user_id, status, remind_at);
+    `);
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  getConversation(userId: string): ConversationDraft | undefined {
+    const row = this.db
+      .prepare(
+        `SELECT
+           user_id AS userId,
+           status,
+           source_text AS sourceText,
+           title,
+           due_at AS dueAt,
+           reminder_offset_minutes AS reminderOffsetMinutes,
+           created_at AS createdAt,
+           updated_at AS updatedAt
+         FROM conversation_sessions
+         WHERE user_id = ?`,
+      )
+      .get(userId) as ConversationDraft | undefined;
+    return row;
+  }
+
+  upsertConversation(params: {
+    userId: string;
+    sourceText: string;
+    title: string;
+    dueAt: Date;
+    reminderOffsetMinutes: number | null;
+    now: Date;
+  }): ConversationDraft {
+    const nowIso = toIsoString(params.now);
+    const dueAtIso = toIsoString(params.dueAt);
+    this.db
+      .prepare(
+        `INSERT INTO conversation_sessions (
+           user_id, status, source_text, title, due_at, reminder_offset_minutes, created_at, updated_at
+         ) VALUES (?, 'awaiting_reminder', ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(user_id) DO UPDATE SET
+           status = excluded.status,
+           source_text = excluded.source_text,
+           title = excluded.title,
+           due_at = excluded.due_at,
+           reminder_offset_minutes = excluded.reminder_offset_minutes,
+           updated_at = excluded.updated_at`,
+      )
+      .run(
+        params.userId,
+        params.sourceText,
+        params.title,
+        dueAtIso,
+        params.reminderOffsetMinutes,
+        nowIso,
+        nowIso,
+      );
+
+    return {
+      userId: params.userId,
+      status: "awaiting_reminder",
+      sourceText: params.sourceText,
+      title: params.title,
+      dueAt: dueAtIso,
+      reminderOffsetMinutes: params.reminderOffsetMinutes,
+      createdAt: nowIso,
+      updatedAt: nowIso,
+    };
+  }
+
+  clearConversation(userId: string): void {
+    this.db.prepare(`DELETE FROM conversation_sessions WHERE user_id = ?`).run(userId);
+  }
+
+  createTask(params: {
+    userId: string;
+    title: string;
+    sourceText: string;
+    dueAt: Date;
+    reminderOffsetMinutes: number | null;
+    now: Date;
+  }): TaskSummary {
+    const id = randomUUID();
+    const nowIso = toIsoString(params.now);
+    const dueAtIso = toIsoString(params.dueAt);
+    this.db
+      .prepare(
+        `INSERT INTO tasks (
+          id, user_id, title, source_text, due_at, timezone, status, reminder_offset_minutes, created_at, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, 'scheduled', ?, ?, ?)`,
+      )
+      .run(
+        id,
+        params.userId,
+        params.title,
+        params.sourceText,
+        dueAtIso,
+        this.timezone,
+        params.reminderOffsetMinutes,
+        nowIso,
+        nowIso,
+      );
+
+    this.insertTaskEvent(
+      id,
+      "task.created",
+      {
+        title: params.title,
+        dueAt: dueAtIso,
+        reminderOffsetMinutes: params.reminderOffsetMinutes,
+      },
+      params.now,
+    );
+
+    if (params.reminderOffsetMinutes !== null) {
+      this.createReminder({
+        taskId: id,
+        userId: params.userId,
+        title: params.title,
+        dueAt: params.dueAt,
+        offsetMinutes: params.reminderOffsetMinutes,
+        timeZone: this.timezone,
+        now: params.now,
+      });
+    }
+
+    return this.getTask(id)!;
+  }
+
+  getTask(taskId: string): TaskSummary | undefined {
+    const row = this.db.prepare(`SELECT * FROM tasks WHERE id = ?`).get(taskId) as TaskRow | undefined;
+    return row ? mapTask(row) : undefined;
+  }
+
+  private createReminder(params: {
+    taskId: string;
+    userId: string;
+    title: string;
+    dueAt: Date;
+    offsetMinutes: number;
+    timeZone: string;
+    now: Date;
+  }): ReminderSummary {
+    const id = randomUUID();
+    const remindAt = new Date(
+      Math.max(params.now.getTime(), params.dueAt.getTime() - params.offsetMinutes * 60_000),
+    );
+    const nowIso = toIsoString(params.now);
+    const remindAtIso = toIsoString(remindAt);
+    this.db
+      .prepare(
+        `INSERT INTO task_reminders (
+          id, task_id, user_id, remind_at, message, status, created_at, updated_at
+         ) VALUES (?, ?, ?, ?, ?, 'scheduled', ?, ?)`,
+      )
+      .run(
+        id,
+        params.taskId,
+        params.userId,
+        remindAtIso,
+        buildReminderMessage(params.title, params.dueAt, params.timeZone),
+        nowIso,
+        nowIso,
+      );
+
+    this.insertTaskEvent(
+      params.taskId,
+      "task.reminder.scheduled",
+      {
+        remindAt: remindAtIso,
+        offsetMinutes: params.offsetMinutes,
+      },
+      params.now,
+    );
+
+    return {
+      id,
+      taskId: params.taskId,
+      userId: params.userId,
+      title: params.title,
+      dueAt: toIsoString(params.dueAt),
+      dueAtText: formatLocalDateTime(params.dueAt, params.timeZone),
+      remindAt: remindAtIso,
+      remindAtText: formatLocalDateTime(remindAt, params.timeZone),
+      message: buildReminderMessage(params.title, params.dueAt, params.timeZone),
+      status: "scheduled",
+    };
+  }
+
+  private insertTaskEvent(taskId: string, eventType: string, payload: unknown, now: Date): void {
+    this.db
+      .prepare(`INSERT INTO task_events (task_id, event_type, payload_json, created_at) VALUES (?, ?, ?, ?)`)
+      .run(taskId, eventType, JSON.stringify(payload), toIsoString(now));
+  }
+
+  dispatchDueReminders(now: Date): number {
+    const nowIso = toIsoString(now);
+    const dueRows = this.db
+      .prepare(
+        `SELECT task_reminders.id, task_reminders.task_id
+         FROM task_reminders
+         JOIN tasks ON tasks.id = task_reminders.task_id
+         WHERE task_reminders.status = 'scheduled'
+           AND tasks.status = 'scheduled'
+           AND task_reminders.remind_at <= ?
+         ORDER BY task_reminders.remind_at ASC`,
+      )
+      .all(nowIso) as Array<{ id: string; task_id: string }>;
+
+    if (dueRows.length === 0) {
+      return 0;
+    }
+
+    this.db.exec("BEGIN");
+    try {
+      for (const row of dueRows) {
+        this.db
+          .prepare(
+            `UPDATE task_reminders
+             SET status = 'sent', sent_at = ?, updated_at = ?
+             WHERE id = ? AND status = 'scheduled'`,
+          )
+          .run(nowIso, nowIso, row.id);
+        this.insertTaskEvent(row.task_id, "task.reminder.sent", { reminderId: row.id }, now);
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+        // Preserve the original reminder dispatch failure.
+      }
+      throw error;
+    }
+
+    return dueRows.length;
+  }
+
+  listPendingReminders(userId: string): ReminderSummary[] {
+    const rows = this.db
+      .prepare(
+        `SELECT
+           task_reminders.id,
+           task_reminders.task_id,
+           task_reminders.user_id,
+           task_reminders.remind_at,
+           task_reminders.message,
+           task_reminders.status,
+           task_reminders.sent_at,
+           task_reminders.acked_at,
+           tasks.title,
+           tasks.due_at,
+           tasks.timezone
+         FROM task_reminders
+         JOIN tasks ON tasks.id = task_reminders.task_id
+         WHERE task_reminders.user_id = ?
+           AND task_reminders.status = 'sent'
+           AND tasks.status = 'scheduled'
+         ORDER BY task_reminders.remind_at ASC`,
+      )
+      .all(userId) as ReminderRow[];
+    return rows.map(mapReminder);
+  }
+
+  findActionableTasks(userId: string): TaskSummary[] {
+    const rows = this.db
+      .prepare(
+        `SELECT DISTINCT tasks.*
+         FROM tasks
+         JOIN task_reminders ON task_reminders.task_id = tasks.id
+         WHERE tasks.user_id = ?
+           AND tasks.status = 'scheduled'
+           AND task_reminders.status = 'sent'
+         ORDER BY task_reminders.sent_at DESC, tasks.due_at ASC`,
+      )
+      .all(userId) as TaskRow[];
+    return rows.map(mapTask);
+  }
+
+  markTaskDone(taskId: string, now: Date): TaskSummary | undefined {
+    const nowIso = toIsoString(now);
+    this.db
+      .prepare(
+        `UPDATE tasks
+         SET status = 'done', completed_at = ?, updated_at = ?
+         WHERE id = ? AND status = 'scheduled'`,
+      )
+      .run(nowIso, nowIso, taskId);
+    this.db
+      .prepare(
+        `UPDATE task_reminders
+         SET status = 'acked', acked_at = ?, updated_at = ?
+         WHERE task_id = ? AND status IN ('scheduled', 'sent')`,
+      )
+      .run(nowIso, nowIso, taskId);
+    this.insertTaskEvent(taskId, "task.done", {}, now);
+    return this.getTask(taskId);
+  }
+
+  cancelTask(taskId: string, now: Date): TaskSummary | undefined {
+    const nowIso = toIsoString(now);
+    this.db
+      .prepare(
+        `UPDATE tasks
+         SET status = 'cancelled', cancelled_at = ?, updated_at = ?
+         WHERE id = ? AND status = 'scheduled'`,
+      )
+      .run(nowIso, nowIso, taskId);
+    this.db
+      .prepare(
+        `UPDATE task_reminders
+         SET status = 'cancelled', updated_at = ?
+         WHERE task_id = ? AND status IN ('scheduled', 'sent')`,
+      )
+      .run(nowIso, taskId);
+    this.insertTaskEvent(taskId, "task.cancelled", {}, now);
+    return this.getTask(taskId);
+  }
+
+  snoozeTask(taskId: string, minutes: number, now: Date): TaskSummary | undefined {
+    const task = this.getTask(taskId);
+    if (!task || task.status !== "scheduled") {
+      return task;
+    }
+
+    const currentDueAt = new Date(task.dueAt);
+    const base = currentDueAt.getTime() > now.getTime() ? currentDueAt : now;
+    const nextDueAt = new Date(base.getTime() + minutes * 60_000);
+    const nowIso = toIsoString(now);
+    const nextDueAtIso = toIsoString(nextDueAt);
+
+    this.db.prepare(`UPDATE tasks SET due_at = ?, updated_at = ? WHERE id = ?`).run(nextDueAtIso, nowIso, taskId);
+    this.db
+      .prepare(
+        `UPDATE task_reminders
+         SET status = 'cancelled', updated_at = ?
+         WHERE task_id = ? AND status IN ('scheduled', 'sent')`,
+      )
+      .run(nowIso, taskId);
+    this.insertTaskEvent(taskId, "task.snoozed", { minutes, dueAt: nextDueAtIso }, now);
+
+    if (task.reminderOffsetMinutes !== null) {
+      this.createReminder({
+        taskId,
+        userId: task.userId,
+        title: task.title,
+        dueAt: nextDueAt,
+        offsetMinutes: task.reminderOffsetMinutes,
+        timeZone: task.timezone,
+        now,
+      });
+    }
+
+    return this.getTask(taskId);
+  }
+
+  listTasks(userId: string, scope: TaskScope, now: Date): TaskSummary[] {
+    const bounds = buildDateBounds(now, this.timezone);
+    let query = `SELECT * FROM tasks WHERE user_id = ?`;
+    const params: unknown[] = [userId];
+
+    // Keep the heavy filtering in SQLite so task lists do not grow linearly in JS on each request.
+    switch (scope) {
+      case "today":
+        query += ` AND status = 'scheduled' AND due_at >= ? AND due_at < ?`;
+        params.push(bounds.todayStartIso, bounds.tomorrowStartIso);
+        break;
+      case "tomorrow":
+        query += ` AND status = 'scheduled' AND due_at >= ? AND due_at < ?`;
+        params.push(bounds.tomorrowStartIso, bounds.dayAfterTomorrowIso);
+        break;
+      case "week":
+        query += ` AND status = 'scheduled' AND due_at >= ? AND due_at < ?`;
+        params.push(bounds.todayStartIso, bounds.nextWeekStartIso);
+        break;
+      case "overdue":
+        query += ` AND status = 'scheduled' AND due_at < ?`;
+        params.push(bounds.nowIso);
+        break;
+      case "all":
+        break;
+    }
+
+    query += ` ORDER BY due_at ASC`;
+    const rows = this.db.prepare(query).all(...params) as TaskRow[];
+    return rows.map(mapTask);
+  }
+
+  getStats(userId: string, now: Date): TaskStats {
+    const bounds = buildDateBounds(now, this.timezone);
+    const row = this.db
+      .prepare(
+        `SELECT
+           COUNT(*) AS totalTasks,
+           SUM(CASE WHEN status = 'scheduled' THEN 1 ELSE 0 END) AS scheduledTasks,
+           SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) AS doneTasks,
+           SUM(CASE WHEN status = 'cancelled' THEN 1 ELSE 0 END) AS cancelledTasks,
+           SUM(CASE WHEN status = 'scheduled' AND due_at < ? THEN 1 ELSE 0 END) AS overdueTasks,
+           SUM(CASE WHEN due_at >= ? AND due_at < ? THEN 1 ELSE 0 END) AS todayTasks,
+           SUM(CASE WHEN completed_at >= ? AND completed_at < ? THEN 1 ELSE 0 END) AS todayDoneTasks
+         FROM tasks
+         WHERE user_id = ?`,
+      )
+      .get(
+        bounds.nowIso,
+        bounds.todayStartIso,
+        bounds.tomorrowStartIso,
+        bounds.todayStartIso,
+        bounds.tomorrowStartIso,
+        userId,
+      ) as TaskStatsRow | undefined;
+    const reminderRow = this.db
+      .prepare(
+        `SELECT COUNT(*) AS count
+         FROM task_reminders
+         JOIN tasks ON tasks.id = task_reminders.task_id
+         WHERE task_reminders.user_id = ?
+           AND task_reminders.status = 'sent'
+           AND tasks.status = 'scheduled'`,
+      )
+      .get(userId) as CountRow | undefined;
+
+    return {
+      totalTasks: row?.totalTasks ?? 0,
+      scheduledTasks: row?.scheduledTasks ?? 0,
+      doneTasks: row?.doneTasks ?? 0,
+      cancelledTasks: row?.cancelledTasks ?? 0,
+      overdueTasks: row?.overdueTasks ?? 0,
+      todayTasks: row?.todayTasks ?? 0,
+      todayDoneTasks: row?.todayDoneTasks ?? 0,
+      pendingReminders: reminderRow?.count ?? 0,
+    };
+  }
+}
+

package/src/tasks/time-parser.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import {
+  formatLocalDateTime,
+  parseReminderPreference,
+  parseTaskAction,
+  parseTaskDraft,
+  parseTaskQuery,
+} from "./time-parser.js";
+
+describe("task time parser", () => {
+  it("parses Chinese natural language task drafts", () => {
+    const now = new Date("2026-03-12T09:00:00+08:00");
+    const draft = parseTaskDraft("明天下午3点开会", now, "Asia/Shanghai");
+    expect(draft?.kind).toBe("ready");
+    if (!draft || draft.kind !== "ready") {
+      return;
+    }
+    expect(draft.title).toBe("开会");
+    expect(draft.dueAt.toISOString()).toBe("2026-03-13T07:00:00.000Z");
+  });
+
+  it("parses Chinese numerals and colloquial reminder phrases", () => {
+    const now = new Date("2026-03-12T09:00:00+08:00");
+
+    const chineseClockDraft = parseTaskDraft("明天下午五点开会", now, "Asia/Shanghai");
+    expect(chineseClockDraft?.kind).toBe("ready");
+    if (!chineseClockDraft || chineseClockDraft.kind !== "ready") {
+      return;
+    }
+    expect(chineseClockDraft.title).toBe("开会");
+    expect(chineseClockDraft.dueAt.toISOString()).toBe("2026-03-13T09:00:00.000Z");
+
+    const weekdayDraft = parseTaskDraft("周五晚上八点聚餐", now, "Asia/Shanghai");
+    expect(weekdayDraft?.kind).toBe("ready");
+    if (!weekdayDraft || weekdayDraft.kind !== "ready") {
+      return;
+    }
+    expect(weekdayDraft.title).toBe("聚餐");
+    expect(weekdayDraft.dueAt.toISOString()).toBe("2026-03-13T12:00:00.000Z");
+
+    const relativeDraft = parseTaskDraft("半小时后提醒我喝水", now, "Asia/Shanghai");
+    expect(relativeDraft?.kind).toBe("ready");
+    if (!relativeDraft || relativeDraft.kind !== "ready") {
+      return;
+    }
+    expect(relativeDraft.title).toBe("喝水");
+    expect(relativeDraft.dueAt.toISOString()).toBe("2026-03-12T01:30:00.000Z");
+
+    const monthDayDraft = parseTaskDraft("三月十五日下午三点开会", now, "Asia/Shanghai");
+    expect(monthDayDraft?.kind).toBe("ready");
+    if (!monthDayDraft || monthDayDraft.kind !== "ready") {
+      return;
+    }
+    expect(monthDayDraft.title).toBe("开会");
+    expect(monthDayDraft.dueAt.toISOString()).toBe("2026-03-15T07:00:00.000Z");
+  });
+
+  it("parses and formats task times in the configured timezone", () => {
+    const now = new Date("2026-03-12T09:00:00.000Z");
+    const draft = parseTaskDraft("明天下午3点开会", now, "America/Los_Angeles");
+    expect(draft?.kind).toBe("ready");
+    if (!draft || draft.kind !== "ready") {
+      return;
+    }
+    expect(draft.dueAt.toISOString()).toBe("2026-03-13T22:00:00.000Z");
+    expect(formatLocalDateTime(draft.dueAt, "America/Los_Angeles")).toBe("2026-03-13 15:00");
+  });
+
+  it("parses reminder preferences, task actions, and task queries", () => {
+    expect(parseReminderPreference("提前15分钟提醒")?.offsetMinutes).toBe(15);
+    expect(parseReminderPreference("提前十分钟提醒")?.offsetMinutes).toBe(10);
+    expect(parseReminderPreference("提前一个半小时提醒")?.offsetMinutes).toBe(90);
+    expect(parseReminderPreference("准时提醒")?.offsetMinutes).toBe(0);
+    expect(parseReminderPreference("不需要提醒")?.offsetMinutes).toBeNull();
+    expect(parseTaskAction("延后两小时")).toEqual({ kind: "snooze", minutes: 120 });
+    expect(parseTaskAction("延后半小时")).toEqual({ kind: "snooze", minutes: 30 });
+    expect(parseTaskQuery("今天有什么任务")).toBe("today");
+    expect(parseTaskQuery("我的任务")).toBe("all");
+    expect(parseTaskQuery("我有哪些任务？")).toBe("all");
+    expect(parseTaskQuery("查看我的待办")).toBe("all");
+  });
+
+  it("keeps embedded reminder offsets when creating drafts", () => {
+    const now = new Date("2026-03-12T09:00:00+08:00");
+    const draft = parseTaskDraft("明天下午五点提醒我开会提前一小时提醒", now, "Asia/Shanghai");
+    expect(draft?.kind).toBe("ready");
+    if (!draft || draft.kind !== "ready") {
+      return;
+    }
+    expect(draft.title).toBe("开会");
+    expect(draft.reminderOffsetMinutes).toBe(60);
+    expect(draft.dueAt.toISOString()).toBe("2026-03-13T09:00:00.000Z");
+  });
+});