dsh-worktodo 0.1.0 → 0.2.0

package/src/parse-due.mjs

@@ -0,0 +1,170 @@
+/**
+ * 自然语言日期解析：从一句人话里认出「截止日期 / 时间」，并把认出来的词从标题里摘掉。
+ *
+ * 设计原则（保守优先）：
+ *   1. 只认**明确的日期词**，宁可漏也不误吞（"买3个苹果" 里的 3 不能变成"3 天后"）；
+ *   2. 出现多个星期几时取**最后**一个（"周一例会改到周三" → 周三）；
+ *   3. 结果的每一处都能追溯到原文片段（matched），人类侧据此显示"从标题识别"并可撤销；
+ *   4. 与 `normalizeDue` 的既有说法保持兼容（今天/明天/昨天/+3d/本周）。
+ *
+ * 人类面板与 worktodo_* 工具共用这一份实现（本文件零依赖，可直接被打进客户端 bundle），
+ * 避免两边理解不一致。
+ */
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/** 本地时区的 YYYY-MM-DD（与 records.mjs 的 dayKey 同语义）。 */
+function dayKey(stamp) {
+  const d = new Date(stamp);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+/** 所在周的周一（本地时区，与 records.mjs 的 weekStartKey 同语义）。 */
+function weekStartKey(stamp) {
+  const d = new Date(stamp);
+  const day = (d.getDay() + 6) % 7; // 周一=0
+  const monday = new Date(d.getFullYear(), d.getMonth(), d.getDate() - day);
+  return dayKey(monday.getTime());
+}
+
+
+const CN_NUM = { 零: 0, 一: 1, 两: 2, 二: 2, 三: 3, 四: 4, 五: 5, 六: 6, 七: 7, 八: 8, 九: 9, 十: 10 };
+const WEEKDAY = { 一: 1, 二: 2, 三: 3, 四: 4, 五: 5, 六: 6, 日: 7, 天: 7 };
+const PERIOD_HOUR = { 今早: 9, 早上: 9, 早晨: 9, 上午: 9, 中午: 12, 下午: 15, 傍晚: 18, 今晚: 20, 明晚: 20, 晚上: 20, 晚: 20, 夜里: 21 };
+
+const toCnNumber = (raw) => {
+  if (/^\d+$/.test(raw)) return Number(raw);
+  if (raw === '十') return 10;
+  if (raw.startsWith('十')) return 10 + (CN_NUM[raw[1]] ?? 0);
+  if (raw.includes('十')) {
+    const [a, b] = raw.split('十');
+    return (CN_NUM[a] ?? 1) * 10 + (CN_NUM[b] ?? 0);
+  }
+  return CN_NUM[raw] ?? null;
+};
+
+/**
+ * @param {string} text 用户输入
+ * @param {number} [now] 基准时刻
+ * @returns {{title:string, due:string|null, dueTime:string|null, matched:string[]}}
+ */
+export function parseNaturalDue(text, now = Date.now()) {
+  const source = typeof text === 'string' ? text : '';
+  const spans = []; // {start, end, kind:'date'|'time'}
+  let due = null;
+  let dueTime = null;
+  let hourFromPeriod = null; // 「今晚」这类只给时段，兜底时间
+
+  const today = dayKey(now);
+  const todayStart = new Date(`${today}T00:00:00`).getTime();
+
+  // ---------- 1) 绝对日期：2026-10-20 / 10月20日 / 10/20 ----------
+  let m = /(\d{4})[-/年](\d{1,2})[-/月](\d{1,2})日?/.exec(source);
+  if (m) {
+    due = dayKey(new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3])).getTime());
+    spans.push({ start: m.index, end: m.index + m[0].length, kind: 'date' });
+  } else {
+    m = /(\d{1,2})月(\d{1,2})日?/.exec(source);
+    if (m) {
+      // 省略年份：取「最近一次」（已过去就顺延到明年）
+      let year = new Date(now).getFullYear();
+      let candidate = dayKey(new Date(year, Number(m[1]) - 1, Number(m[2])).getTime());
+      if (candidate < today) candidate = dayKey(new Date(year + 1, Number(m[1]) - 1, Number(m[2])).getTime());
+      due = candidate;
+      spans.push({ start: m.index, end: m.index + m[0].length, kind: 'date' });
+    }
+  }
+
+  // ---------- 2) 星期：周X / 星期X / 礼拜X / 下周一（多个取最后一个） ----------
+  const weekRe = /(下下|下个|下|本|这)?(?:周|星期|礼拜)([一二三四五六日天1-7])/g;
+  for (let w = weekRe.exec(source); w; w = weekRe.exec(source)) {
+    const offsetWeeks = w[1] === '下' || w[1] === '下个' ? 1 : w[1] === '下下' ? 2 : 0;
+    const target = WEEKDAY[w[2]] ?? Number(w[2]);
+    const thisWeekStart = new Date(`${weekStartKey(now)}T00:00:00`).getTime();
+    let stamp = thisWeekStart + (target - 1) * DAY_MS + offsetWeeks * 7 * DAY_MS;
+    if (offsetWeeks === 0 && stamp < todayStart) stamp += 7 * DAY_MS; // 已过则算下周
+    const candidate = dayKey(stamp);
+    // 后面的星期几覆盖前面的（"改到周三"的语义）
+    if (due === null || spans.some((s) => s.kind === 'date' && s.weekday)) {
+      spans.filter((s) => s.weekday).forEach((s) => { s.dropped = true; });
+    }
+    due = candidate;
+    spans.push({ start: w.index, end: w.index + w[0].length, kind: 'date', weekday: true });
+  }
+
+  // ---------- 3) 相对天数：今天/明天/后天/大后天/3天后/+3d ----------
+  if (due === null) {
+    const relWords = { 今天: 0, 今日: 0, 明天: 1, 明日: 1, 后天: 2, 大后天: 3, 昨天: -1, 昨: -1 };
+    for (const [word, offset] of Object.entries(relWords)) {
+      const at = source.indexOf(word);
+      if (at !== -1) {
+        due = dayKey(now + offset * DAY_MS);
+        spans.push({ start: at, end: at + word.length, kind: 'date' });
+        break;
+      }
+    }
+  }
+  if (due === null) {
+    const plus = /\+(\d{1,3})\s*d(?:ay)?s?/.exec(source);
+    const cn = /([0-9零一两二三四五六七八九十]+)\s*天\s*(?:后|以后|之后)/.exec(source);
+    if (plus) {
+      due = dayKey(now + Number(plus[1]) * DAY_MS);
+      spans.push({ start: plus.index, end: plus.index + plus[0].length, kind: 'date' });
+    } else if (cn) {
+      const n = toCnNumber(cn[1]);
+      if (n !== null) {
+        due = dayKey(now + n * DAY_MS);
+        spans.push({ start: cn.index, end: cn.index + cn[0].length, kind: 'date' });
+      }
+    }
+  }
+
+  // ---------- 4) 时段词：今晚 / 明早 / 下午 / 早上 ----------
+  const periodRe = /(今晚|明晚|明早|早上|早晨|上午|中午|下午|傍晚|晚上|夜里)/;
+  const period = periodRe.exec(source);
+  if (period) {
+    hourFromPeriod = PERIOD_HOUR[period[1]] ?? null;
+    if (due === null) {
+      if (period[1] === '今晚' || period[1] === '明晚') due = dayKey(now + (period[1] === '明晚' ? 1 : 0) * DAY_MS);
+      if (period[1] === '明早') due = dayKey(now + DAY_MS);
+    }
+    spans.push({ start: period.index, end: period.index + period[1].length, kind: 'time' });
+  }
+
+  // ---------- 5) 具体时间：下午3点 / 3点半 / 15:00 / 上午10点 ----------
+  const hm = /(\d{1,2})[:：](\d{2})/.exec(source);
+  const cnHour = /([0-9零一两二三四五六七八九十]+)\s*[点时](半|[0-9零一两二三四五六七八九十]{1,3}分)?/.exec(source);
+  if (hm) {
+    const h = Number(hm[1]);
+    if (h <= 23 && Number(hm[2]) <= 59) dueTime = `${String(h).padStart(2, '0')}:${hm[2]}`;
+    spans.push({ start: hm.index, end: hm.index + hm[0].length, kind: 'time' });
+  } else if (cnHour) {
+    let h = toCnNumber(cnHour[1]);
+    if (h !== null && h <= 23) {
+      if (h <= 12 && hourFromPeriod !== null && hourFromPeriod >= 12) h = h === 12 ? 12 : h + 12; // 下午3点 → 15
+      const minute = cnHour[2] === '半' ? 30 : cnHour[2] ? (toCnNumber(cnHour[2].replace('分', '')) ?? 0) : 0;
+      if (minute <= 59) dueTime = `${String(h).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+      spans.push({ start: cnHour.index, end: cnHour.index + cnHour[0].length, kind: 'time' });
+    }
+  } else if (hourFromPeriod !== null) {
+    dueTime = `${String(hourFromPeriod).padStart(2, '0')}:00`; // 只有时段词 → 用该时段默认钟点
+  }
+
+  // 只认到时间、没认到日期 → 今天（用户决定④）
+  if (dueTime && !due) due = today;
+
+  // ---------- 6) 摘除：把认出来的片段从标题里去掉 ----------
+  const kept = spans.filter((s) => !s.dropped).sort((a, b) => a.start - b.start);
+  let title = source;
+  for (const span of [...kept].reverse()) {
+    title = title.slice(0, span.start) + ' ' + title.slice(span.end);
+  }
+  title = title.replace(/\s+/g, ' ').trim();
+
+  return {
+    title: title || source.trim(),
+    due,
+    dueTime,
+    matched: kept.map((s) => source.slice(s.start, s.end)),
+  };
+}

package/src/records.mjs

@@ -16,7 +16,7 @@
 /** 状态：与官方 todo_write 同名同义，便于互相提升。 */
 export const STATUSES = ['pending', 'in_progress', 'completed'];
 /** 优先级：只留三档，避免用户在选择上犹豫。 */
-export const PRIORITIES = ['high', 'normal', 'low'];
+export const PRIORITIES = ['high', 'normal', 'low', 'none'];
 /** 来源：人加的 / agent 加的 / 从会话 todos 提升的。 */
 export const SOURCES = ['human', 'agent', 'session'];
 
@@ -147,6 +147,7 @@ export function normalizePriority(value) {
     p0: 'high', urgent: 'high', high: 'high', 高: 'high', 紧急: 'high', 重要: 'high',
     p1: 'normal', normal: 'normal', medium: 'normal', mid: 'normal', 中: 'normal', 普通: 'normal',
     p2: 'low', low: 'low', 低: 'low', 次要: 'low',
+    none: 'none', no: 'none', 无: 'none', 不设: 'none', 无优先级: 'none',
   };
   const resolved = alias[raw];
   if (!resolved) throw new WorkTodoError('bad-priority', `优先级只能是 ${PRIORITIES.join(' / ')}，收到 ${JSON.stringify(value)}`);
@@ -202,6 +203,25 @@ export function normalizeDue(value, now = Date.now()) {
  * @param {number} now
  * @returns {string}
  */
+/**
+ * 截止时间（可选，只有配了截止日期才有意义）：接受 "14:30" / "9:05" / "1430" / "14"。
+ * 空值（undefined/null/''/none）返回 null；写坏了抛错，别悄悄丢掉用户填的时间。
+ * @param {unknown} value
+ * @returns {string|null} HH:MM
+ */
+export function normalizeDueTime(value) {
+  if (value === undefined || value === null || value === '') return null;
+  if (typeof value !== 'string') throw new WorkTodoError('bad-due-time', '截止时间必须是文本');
+  const raw = value.trim().toLowerCase();
+  if (!raw || raw === 'none' || raw === 'null' || raw === 'clear') return null;
+  const m = /^(\d{1,2})(?::?(\d{2}))?$/.exec(raw);
+  if (!m) throw new WorkTodoError('bad-due-time', '截止时间要写成 HH:MM（例如 14:30）');
+  const hour = Number(m[1]);
+  const minute = m[2] === undefined ? 0 : Number(m[2]);
+  if (hour > 23 || minute > 59) throw new WorkTodoError('bad-due-time', '截止时间超出范围（00:00–23:59）');
+  return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+}
+
 export function newId(now = Date.now(), rand = Math.random) {
   const t = Math.floor(now).toString(36);
   const r = Math.floor(rand() * 36 ** 4).toString(36).padStart(4, '0');
@@ -220,14 +240,18 @@ export function newId(now = Date.now(), rand = Math.random) {
 export function createRecord(input = {}, { now = Date.now(), source = 'human', id } = {}) {
   if (!SOURCES.includes(source)) throw new WorkTodoError('bad-source', `来源只能是 ${SOURCES.join(' / ')}`);
   const status = normalizeStatus(input.status) ?? 'pending';
+  const due = normalizeDue(input.due, now);
   const record = {
     id: id ?? newId(now),
     title: normalizeTitle(input.title),
     notes: normalizeNotes(input.notes),
     status,
-    priority: normalizePriority(input.priority) ?? 'normal',
-    due: normalizeDue(input.due, now),
+    priority: normalizePriority(input.priority) ?? 'none',
+    due,
+    // 没有截止日期就没有截止时间（避免出现「有时间没日期」的怪状态）
+    dueTime: due ? normalizeDueTime(input.dueTime) : null,
     project: normalizeProject(input.project),
+    order: null,
     source,
     createdAt: now,
     updatedAt: now,
@@ -253,7 +277,16 @@ export function patchRecord(record, patch = {}, now = Date.now()) {
   if (take('notes')) { next.notes = normalizeNotes(patch.notes); touched = true; }
   if (take('project')) { next.project = normalizeProject(patch.project); touched = true; }
   if (take('priority')) { next.priority = normalizePriority(patch.priority) ?? next.priority; touched = true; }
-  if (take('due')) { next.due = normalizeDue(patch.due, now); touched = true; }
+  if (take('due')) {
+    next.due = normalizeDue(patch.due, now);
+    if (!next.due) next.dueTime = null; // 清掉日期时时间一并清掉
+    touched = true;
+  }
+  if (take('dueTime')) {
+    // 只给时间不给日期是无效的：没有日期就存 null
+    next.dueTime = next.due ? normalizeDueTime(patch.dueTime) : null;
+    touched = true;
+  }
 
   const status = normalizeStatus(patch.status);
   if (status && status !== next.status) {
@@ -305,31 +338,69 @@ export function resolveRef(records, ref) {
  * ------------------------------------------------------------------ */
 
 /** 优先级权重，用于排序（高的在前）。 */
-const PRIORITY_WEIGHT = { high: 0, normal: 1, low: 2 };
+// 「无」排在最后（未定优先级的不该挡在已定优先级的前面），但仍排在「已完成」之前
+const PRIORITY_WEIGHT = { high: 0, normal: 1, low: 2, none: 3 };
 
 /**
  * 视图排序：未完成在前；同组内 优先级 → 截止日期（无日期排最后）→ 创建时间。
  * @param {object[]} records
  * @returns {object[]} 新数组
  */
-export function sortForView(records) {
+export const SORT_MODES = ['manual', 'priority', 'created'];
+
+/**
+ * 视图排序。三种模式共用同一套「已完成永远沉底」的规则：
+ *   - `priority`（默认）：优先级 → 截止日期 → 创建时间（早的在前）
+ *   - `created`：创建时间**倒序**（刚加的在前）
+ *   - `manual`：拖过顺序的（`order` 是有限数）按 order 升序在前；没拖过的按 priority 规则排在后面
+ * @param {object[]} records
+ * @param {'manual'|'priority'|'created'} [mode]
+ */
+export function sortForView(records, mode = 'priority') {
   const rank = (r) => (r.status === 'completed' ? 1 : 0);
-  return [...records].sort((a, b) => {
-    if (rank(a) !== rank(b)) return rank(a) - rank(b);
-    if (a.status === 'completed' && b.status === 'completed') {
-      // 已完成按完成时间倒序：最近做完的先看到
-      return (b.completedAt ?? b.updatedAt) - (a.completedAt ?? a.updatedAt);
-    }
+  const byFallback = (a, b) => {
     const pa = PRIORITY_WEIGHT[a.priority] ?? 1;
     const pb = PRIORITY_WEIGHT[b.priority] ?? 1;
     if (pa !== pb) return pa - pb;
     if (a.due && b.due && a.due !== b.due) return a.due < b.due ? -1 : 1;
+    if (a.due === b.due) {
+      const ta = a.dueTime ?? '99:99'; // 同一天：有时间的在前，没时间的垫后
+      const tb = b.dueTime ?? '99:99';
+      if (ta !== tb) return ta < tb ? -1 : 1;
+    }
     if (a.due && !b.due) return -1;
     if (!a.due && b.due) return 1;
     return a.createdAt - b.createdAt;
+  };
+  const manualRank = (r) => (Number.isFinite(r.order) ? 0 : 1);
+  return [...records].sort((a, b) => {
+    if (rank(a) !== rank(b)) return rank(a) - rank(b);
+    if (a.status === 'completed' && b.status === 'completed') {
+      // 已完成按完成时间倒序：最近做完的先看到
+      return (b.completedAt ?? b.updatedAt) - (a.completedAt ?? a.updatedAt);
+    }
+    if (mode === 'created') return b.createdAt - a.createdAt;
+    if (mode === 'manual') {
+      if (manualRank(a) !== manualRank(b)) return manualRank(a) - manualRank(b);
+      if (manualRank(a) === 0 && a.order !== b.order) return a.order - b.order;
+      return byFallback(a, b);
+    }
+    return byFallback(a, b);
   });
 }
 
+/**
+ * 把「新的完整顺序」落到记录上：ids[i] 的记录得到 order=i。
+ * 不在 ids 里的记录保持原样（order 为 null 的继续按自动规则排）。
+ * 纯函数：返回新数组，不改入参。
+ * @param {object[]} records
+ * @param {string[]} ids
+ */
+export function applyManualOrder(records, ids) {
+  const position = new Map(ids.map((id, index) => [id, index]));
+  return records.map((record) => (position.has(record.id) ? { ...record, order: position.get(record.id) } : record));
+}
+
 /**
  * 分组成面板的五个区。
  * 「本周」= 今天之后到本周日；无截止日期的进「以后」。
@@ -337,7 +408,7 @@ export function sortForView(records) {
  * @param {number} [now]
  * @returns {{overdue: object[], today: object[], week: object[], later: object[], completed: object[]}}
  */
-export function groupRecords(records, now = Date.now()) {
+export function groupRecords(records, now = Date.now(), mode = 'priority') {
   const today = dayKey(now);
   const weekEnd = dayKey(dayStart(weekStartKey(now)) + 6 * DAY_MS);
   const groups = { overdue: [], today: [], week: [], later: [], completed: [] };
@@ -350,7 +421,7 @@ export function groupRecords(records, now = Date.now()) {
     if (due <= weekEnd) { groups.week.push(record); continue; }
     groups.later.push(record);
   }
-  for (const key of Object.keys(groups)) groups[key] = sortForView(groups[key]);
+  for (const key of Object.keys(groups)) groups[key] = sortForView(groups[key], mode);
   return groups;
 }
 
@@ -360,6 +431,49 @@ export function groupRecords(records, now = Date.now()) {
  * @param {number} [now]
  * @returns {{total: number, open: number, overdue: number, today: number, doing: number, completed: number, completedToday: number}}
  */
+/**
+ * 按项目分组：面板的「按项目」视图。
+ *
+ * 规则：
+ *   - 没写 project 的记录归入「未归类」桶（project 为 null，永远排在最后）；
+ *   - 桶的排序：未完成条数多的在前 → 未完成里最早的截止日期更早的在前 → 名字字典序；
+ *   - 桶内沿用 sortForView（未完成在前、高优先级在前、临近截止在前）；
+ *   - 每个桶附 total / open / overdue，面板可直接显示「项目名 · 未完成/总数」。
+ *
+ * @param {object[]} records
+ * @param {number} [now]
+ * @returns {{project: string|null, key: string, todos: object[], total: number, open: number, overdue: number}[]}
+ */
+export function groupByProject(records, now = Date.now(), mode = 'priority') {
+  const today = dayKey(now);
+  const buckets = new Map();
+  for (const record of records) {
+    const project = record.project ?? null;
+    const key = project ?? '';
+    if (!buckets.has(key)) buckets.set(key, { project, key, todos: [], total: 0, open: 0, overdue: 0 });
+    const bucket = buckets.get(key);
+    bucket.todos.push(record);
+    bucket.total += 1;
+    if (record.status !== 'completed') {
+      bucket.open += 1;
+      if (record.due && record.due < today) bucket.overdue += 1;
+    }
+  }
+  const list = [...buckets.values()];
+  for (const bucket of list) bucket.todos = sortForView(bucket.todos, mode);
+  const earliestOpenDue = (bucket) =>
+    bucket.todos.filter((t) => t.status !== 'completed' && t.due).map((t) => t.due).sort()[0] ?? '9999-99-99';
+  return list.sort((a, b) => {
+    // 未归类永远最后：它不是一个真正的项目
+    if ((a.project === null) !== (b.project === null)) return a.project === null ? 1 : -1;
+    if (a.open !== b.open) return b.open - a.open;
+    const da = earliestOpenDue(a);
+    const db = earliestOpenDue(b);
+    if (da !== db) return da < db ? -1 : 1;
+    return (a.project ?? '').localeCompare(b.project ?? '');
+  });
+}
+
 export function statsOf(records, now = Date.now()) {
   const today = dayKey(now);
   const stats = { total: records.length, open: 0, overdue: 0, today: 0, doing: 0, completed: 0, completedToday: 0 };
@@ -413,7 +527,7 @@ export function filterRecords(records, filter = 'open', now = Date.now()) {
  * ------------------------------------------------------------------ */
 
 /** 优先级在文本里的记号：让模型一眼看出轻重，且不占多少 token。 */
-const PRIORITY_MARK = { high: '!', normal: '', low: '·' };
+const PRIORITY_MARK = { high: '!', normal: '', low: '·', none: '' };
 
 /**
  * 把一条记录渲染成单行文本，例如：
@@ -427,10 +541,11 @@ export function formatLine(record, now = Date.now()) {
   const box = record.status === 'completed' ? '[x]' : record.status === 'in_progress' ? '[~]' : '[ ]';
   const bits = [];
   if (record.priority === 'high') bits.push('高');
+  else if (record.priority === 'normal') bits.push('中');
   else if (record.priority === 'low') bits.push('低');
   if (record.due) {
     const overdue = record.status !== 'completed' && record.due < today;
-    bits.push(`${overdue ? '已逾期 ' : '截止 '}${record.due}`);
+    bits.push(`${overdue ? '已逾期 ' : '截止 '}${record.due}${record.dueTime ? ` ${record.dueTime}` : ''}`);
   }
   if (record.project) bits.push(`#${record.project}`);
   const suffix = bits.length ? `  (${bits.join(', ')})` : '';

package/src/schema.mjs

@@ -19,6 +19,7 @@ import {
   dayKey,
   newId,
   normalizeDue,
+  normalizeDueTime,
   normalizePriority,
   normalizeStatus,
 } from './records.mjs';
@@ -63,10 +64,12 @@ export function repairRecord(raw) {
   const id = typeof raw.id === 'string' && raw.id.trim() ? raw.id.trim() : newId();
   // 状态/优先级/日期都过一遍同义词归一：手改成 done / 高 / 2026/10/20 也要能懂
   const status = STATUSES.includes(raw.status) ? raw.status : coerce(() => normalizeStatus(raw.status), 'pending');
-  const priority = PRIORITIES.includes(raw.priority) ? raw.priority : coerce(() => normalizePriority(raw.priority), 'normal');
+  const priority = PRIORITIES.includes(raw.priority) ? raw.priority : coerce(() => normalizePriority(raw.priority), 'none');
   const source = SOURCES.includes(raw.source) ? raw.source : 'human';
   const createdAt = Number.isFinite(raw.createdAt) ? Number(raw.createdAt) : Date.now();
   const updatedAt = Number.isFinite(raw.updatedAt) ? Number(raw.updatedAt) : createdAt;
+  // 手动排序位置：只有拖过的记录才有；null 表示「按优先级/截止/创建时间自动排」
+  const order = Number.isFinite(raw.order) ? Number(raw.order) : null;
   const completedAt = status === 'completed'
     ? (Number.isFinite(raw.completedAt) ? Number(raw.completedAt) : updatedAt)
     : null;
@@ -79,7 +82,12 @@ export function repairRecord(raw) {
     priority,
     // 相对日期（today/+3d）按「读到的这一刻」折算：手改文件的人想的当然是今天
     due: typeof raw.due === 'string' ? coerce(() => normalizeDue(raw.due, Date.now()), null) : null,
+    // 时间只在有日期时保留（同 createRecord/patchRecord 的约定）
+    dueTime: typeof raw.dueTime === 'string' && typeof raw.due === 'string'
+      ? coerce(() => normalizeDueTime(raw.dueTime), null)
+      : null,
     project: typeof raw.project === 'string' && raw.project.trim() ? raw.project.trim() : null,
+    order,
     source,
     createdAt,
     updatedAt,

package/src/service.mjs

@@ -16,7 +16,10 @@ import {
   adoptSessionTodos,
   createRecord,
   dayKey,
+  SORT_MODES,
+  applyManualOrder,
   filterRecords,
+  groupByProject,
   groupRecords,
   patchRecord,
   resolveRef,
@@ -79,7 +82,9 @@ export function createWorkTodoService({ store, clock = () => Date.now(), logger
    * @param {string} [options.query] 标题/备注里的关键词
    * @returns {Promise<object>} 显式状态
    */
-  async function list({ filter = 'open', project, query } = {}) {
+  async function list({ filter = 'open', project, query, sort } = {}) {
+    // 默认 manual：拖过的顺序优先，没拖过的自动退回优先级/截止/创建时间（所以初看依然合理）
+    const mode = SORT_MODES.includes(sort) ? sort : 'manual';
     const now = clock();
     let records;
     try {
@@ -101,12 +106,28 @@ export function createWorkTodoService({ store, clock = () => Date.now(), logger
     });
     if (!picked.ok) return picked;
 
+    // 项目视图用的分组：**不套 project 收窄**，否则面板上只剩当前项目、没法切到别处
+    const forProjects = attempt(() => {
+      let subset = records;
+      if (query) {
+        const needle = String(query).trim().toLowerCase();
+        subset = subset.filter((r) => r.title.toLowerCase().includes(needle) || (r.notes ?? '').toLowerCase().includes(needle));
+      }
+      return filterRecords(subset, filter, now);
+    });
+    if (!forProjects.ok) return forProjects;
+
     return {
       ok: true,
-      todos: picked.value,
-      groups: groupRecords(picked.value, now),
+      // filterRecords 内部按优先级排过序；这里按当前模式再排一次，
+      // 否则「平铺列表」会和「分组」用两套顺序（sort=created/manual 时最明显）
+      todos: sortForView(picked.value, mode),
+      groups: groupRecords(picked.value, now, mode),
+      // 「按项目」视图：每个项目一个桶，附 total/open/overdue
+      projectGroups: groupByProject(forProjects.value, now, mode),
       // 统计基于**全部**记录，而不是当前筛选结果：面板顶部的「逾期 3 条」不该因为
       // 用户切到「已完成」标签就变成 0
+      sort: mode,
       stats: statsOf(records, now),
       today: dayKey(now),
       store: { kind: store.kind, location: store.location },
@@ -134,6 +155,39 @@ export function createWorkTodoService({ store, clock = () => Date.now(), logger
     return { ok: true, todo: built.value };
   }
 
+  /**
+   * 手动排序：ids 是「新的完整顺序」，ids[i] 的记录得到 order=i。
+   * 只写真正变了的记录；不在 ids 里的记录保持原样（order 仍为 null，继续按自动规则排）。
+   * @param {{ids?: string[]}} [input]
+   */
+  async function reorder({ ids } = {}) {
+    const order = Array.isArray(ids) ? ids.filter((id) => typeof id === 'string' && id.trim()) : [];
+    if (!order.length) return { ok: false, reason: 'empty-order', message: '需要给出待办 id 的顺序数组' };
+    let records;
+    try {
+      records = await all();
+    } catch (error) {
+      return { ok: false, reason: 'store-unreadable', message: `读取待办失败：${error?.message ?? error}` };
+    }
+    const known = new Set(records.map((record) => record.id));
+    const unknownIds = order.filter((id) => !known.has(id));
+    if (unknownIds.length) return { ok: false, reason: 'not-found', message: `这些 id 不存在：${unknownIds.join('、')}` };
+
+    const next = applyManualOrder(records, order);
+    let updated = 0;
+    for (let index = 0; index < next.length; index += 1) {
+      if (next[index] === records[index]) continue; // 顺序没变的记录不写盘
+      try {
+        await store.put(next[index]);
+        updated += 1;
+      } catch (error) {
+        return { ok: false, reason: 'store-write-failed', message: `保存顺序失败：${error?.message ?? error}` };
+      }
+    }
+    emit({ operation: 'reorder', updated });
+    return { ok: true, updated, order };
+  }
+
   /**
    * 改一条：按引用定位，只覆盖显式给出的字段。
    * @param {string} ref id 或标题
@@ -243,6 +297,7 @@ export function createWorkTodoService({ store, clock = () => Date.now(), logger
 
   return {
     list,
+    reorder,
     create,
     update,
     setStatus,

package/src/store.mjs

@@ -209,7 +209,10 @@ export async function openWorkTodoStore({ ctx, config = {}, logger } = {}) {
 
   // ctx.get 对未提供的服务返回 undefined，不抛错；storage 服务可能晚于本插件注册，
   // 但 dsh-base 的层序在 profile 组合之前，所以这里探测到不存在时才回退。
-  const storageDomain = explicitPath ? undefined : ctx?.get?.('storageDomain') ?? ctx?.storageDomain;
+  // ⚠️ 只用 ctx.get 探测，**绝不**退回 `ctx.storageDomain`：直接访问未在 inject 里声明的服务
+  // 会被 cordis 守卫抛错（"cannot get property … without inject"），而那个异常会让整个插件挂载失败——
+  // 实测插件「时好时坏」就是这里（服务尚未注册时 ctx.get 返回 undefined，兜底访问随即抛错）
+  const storageDomain = explicitPath ? undefined : ctx?.get?.('storageDomain');
 
   if (storageDomain && typeof storageDomain.open === 'function') {
     try {