dsh-worktodo 0.1.0 → 0.1.3

package/src/client/index.js

@@ -63,6 +63,14 @@ const zh = {
   'groupWeek': '本周',
   'groupLater': '以后',
   'groupCompleted': '已完成',
+  'viewDue': '按截止',
+  'viewProject': '按项目',
+  'noProject': '未归类',
+  'sortLabel': '排序',
+  'sortManual': '手动',
+  'sortPriority': '优先级',
+  'sortCreated': '创建时间',
+  'dragHint': '拖动调整顺序（会自动切到手动排序）',
   'expand': '展开',
   'collapse': '收起',
   'empty': '还没有待办',
@@ -122,6 +130,14 @@ const en = {
   'groupWeek': 'This week',
   'groupLater': 'Later',
   'groupCompleted': 'Completed',
+  'viewDue': 'By due',
+  'viewProject': 'By project',
+  'noProject': 'Uncategorized',
+  'sortLabel': 'Sort',
+  'sortManual': 'Manual',
+  'sortPriority': 'Priority',
+  'sortCreated': 'Created',
+  'dragHint': 'Drag to reorder (switches to manual sort)',
   'expand': 'Expand',
   'collapse': 'Collapse',
   'empty': 'No to-dos yet',
@@ -228,6 +244,18 @@ const STYLE_TEXT = `
   flex-direction: column; align-items: stretch; gap: 6px;
   border: 1px solid ${C.border1}; background: ${C.layer1};
 }
+.wt-seg {
+  display: inline-flex; align-items: center; border-radius: 8px; overflow: hidden;
+  border: 1px solid ${C.border}; background: ${C.bg2};
+}
+.wt-seg-btn {
+  appearance: none; border: 0; background: transparent; color: ${C.label2};
+  font: inherit; font-size: 11.5px; line-height: 1; padding: 5px 9px; cursor: pointer;
+}
+.wt-seg-btn.is-on { background: ${C.hover}; color: ${C.label}; font-weight: 600; }
+.wt-seg-btn:hover { color: ${C.label}; }
+.wt-row[draggable="true"] { cursor: grab; }
+.wt-row[draggable="true"]:active { cursor: grabbing; }
 .wt-group-head {
   display: flex; align-items: center; gap: 7px; padding: 3px 8px; border-radius: 8px;
   cursor: pointer; user-select: none; color: ${C.label2};
@@ -362,8 +390,10 @@ async function postJson(path, body) {
  * （stale-while-revalidate）。侧栏来回点的时候不该每次都转圈。
  */
 let lastList = null;
+// 排序模式跨「切走再切回」保持；manual = 尊重拖动顺序
+let lastSort = 'manual';
 
-function useList() {
+function useList(sort) {
   const [state, setState] = React.useState(() => (lastList
     ? { status: 'ready', data: lastList, error: null }
     : { status: 'loading', data: null, error: null }));
@@ -376,7 +406,7 @@ function useList() {
      * 用 open 时 groups.completed 恒为空，「已完成」那一组就永远出不来（也就没法折叠/展开）。
      * 统计 stats 不受 filter 影响（宿主按全量算），所以顶部数字仍然是全局口径。
      */
-    fetch(`${ROUTE_LIST}?filter=all`, { cache: 'no-store', credentials: 'same-origin' })
+    fetch(`${ROUTE_LIST}?filter=all&sort=${encodeURIComponent(sort || 'manual')}`, { cache: 'no-store', credentials: 'same-origin' })
       .then(async (response) => {
         if (!response.ok) throw new Error(`HTTP ${response.status}`);
         const body = await response.json().catch(() => null);
@@ -395,7 +425,7 @@ function useList() {
         }
       });
     return () => { alive = false; };
-  }, [tick]);
+  }, [tick, sort]);
 
   const refresh = React.useCallback(() => setTick((n) => n + 1), []);
   return { ...state, refresh };
@@ -477,7 +507,7 @@ function QuickAdd({ t, onAdd, busy }) {
  * 单行：查看 / 行内编辑 / 二次确认删除
  * 状态都留在这一行内部，所以在别的行上敲字、或者列表刷新，都不会把正在编辑的内容冲掉。
  * ------------------------------------------------------------------ */
-function TodoRow({ todo, today, t, onToggle, onRemove, onSave }) {
+function TodoRow({ todo, today, t, onToggle, onRemove, onSave, drag }) {
   const [editing, setEditing] = React.useState(false);
   const [draft, setDraft] = React.useState(null);
   const [notesOpen, setNotesOpen] = React.useState(false);
@@ -644,7 +674,25 @@ function TodoRow({ todo, today, t, onToggle, onRemove, onSave }) {
     }, row.source === 'agent' ? t('sourceAgent') : t('sourceSession')));
   }
 
-  return React.createElement('div', { className: 'wt-row' }, [
+  // 拖动属性：只有父级给了 drag 才可拖（未启用时行为与以前完全一致）
+  const dragAttrs = drag
+    ? {
+      draggable: true,
+      onDragStart: (event) => {
+        try {
+          event.dataTransfer?.setData('text/plain', row.id ?? '');
+          if (event.dataTransfer) event.dataTransfer.effectAllowed = 'move';
+        } catch { /* 少数环境不允许写 dataTransfer，忽略即可 */ }
+        drag.onStart?.(row.id);
+      },
+      onDragOver: (event) => { event.preventDefault(); drag.onOver?.(row.id); },
+      onDrop: (event) => { event.preventDefault(); drag.onDrop?.(row.id); },
+      onDragEnd: () => drag.onEnd?.(),
+      title: drag.hint,
+      style: drag.dragging ? { opacity: 0.45 } : undefined,
+    }
+    : {};
+  return React.createElement('div', { className: 'wt-row', ...dragAttrs }, [
     React.createElement('button', {
       key: 'check',
       type: 'button',
@@ -690,7 +738,7 @@ function TodoRow({ todo, today, t, onToggle, onRemove, onSave }) {
 /* ------------------------------------------------------------------ *
  * 分组：空组整块不渲染，避免五个空标题堆在面板上
  * ------------------------------------------------------------------ */
-function Group({ label, items, closed, t, today, onToggleOpen, onToggleTodo, onRemove, onSave }) {
+function Group({ label, items, meta, closed, t, today, onToggleOpen, onToggleTodo, onRemove, onSave, drag }) {
   const list = asArray(items);
   if (!list.length) return null;
   return React.createElement('div', { style: { marginTop: 6 } }, [
@@ -704,7 +752,7 @@ function Group({ label, items, closed, t, today, onToggleOpen, onToggleTodo, onR
     }, [
       React.createElement(IconChevron, { key: 'c', open: !closed }),
       React.createElement('span', { key: 'l', style: { fontWeight: 600, fontSize: 12 } }, label),
-      React.createElement('span', { key: 'n', style: { fontSize: 11, color: C.label3 } }, String(list.length)),
+      React.createElement('span', { key: 'n', style: { fontSize: 11, color: C.label3 } }, meta || String(list.length)),
       React.createElement('span', { key: 'sp', style: { flex: 1 } }),
       React.createElement('span', { key: 'h', style: { fontSize: 11, color: C.label3 } }, closed ? t('expand') : t('collapse')),
     ]),
@@ -716,6 +764,14 @@ function Group({ label, items, closed, t, today, onToggleOpen, onToggleTodo, onR
       onToggle: onToggleTodo,
       onRemove,
       onSave,
+        drag: drag ? {
+          dragging: drag.dragId === todo?.id,
+          hint: drag.hint,
+          onStart: drag.onStart,
+          onOver: drag.onOver,
+          onDrop: drag.onDrop,
+          onEnd: drag.onEnd,
+        } : undefined,
     }))),
   ]);
 }
@@ -779,7 +835,11 @@ const GROUPS = [
 function WorkTodoPanel(props) {
   // t 由 locale 服务通过 slot props 注入；拿不到时退回中文，至少不显示裸 key
   const t = typeof props?.t === 'function' ? props.t : (key) => zh[key] ?? key;
-  const { status, data, error, refresh } = useList();
+  // 排序：manual（默认，尊重拖动）/ priority / created；必须在 useList(sort) 之前声明
+  const [sort, setSortState] = React.useState(lastSort);
+  const setSort = React.useCallback((next) => { lastSort = next; setSortState(next); }, []);
+  const [dragId, setDragId] = React.useState(null);
+  const { status, data, error, refresh } = useList(sort);
 
   // 写操作的错误条；readError 是拉取错误（用户关掉之后，只有换成新错误才再弹）
   const [barError, setBarError] = React.useState(null);
@@ -791,6 +851,8 @@ function WorkTodoPanel(props) {
   const [pending, setPending] = React.useState(0);
   // 「已完成」默认折叠（做完的事不用占满屏幕），其余默认展开
   const [closed, setClosed] = React.useState({ completed: true });
+  // 视图：按截止（默认）或按项目
+  const [view, setView] = React.useState('due');
 
   /**
    * 所有写操作的统一外壳：成功清掉错误条，失败把宿主的 error 原文放上去，
@@ -830,6 +892,60 @@ function WorkTodoPanel(props) {
   const handleRemove = React.useCallback((ref) => runWrite(() => postJson('/remove', { ref })), [runWrite]);
   const handleSave = React.useCallback((ref, patch) => runWrite(() => postJson('/update', { ref, ...patch })), [runWrite]);
 
+  /** 把 dragId 挪到目标之前，得到新的完整顺序并落盘（manual 模式生效） */
+
+  const handleDropOn = React.useCallback((targetId) => {
+
+    const dragging = dragId;
+
+    setDragId(null);
+
+    if (!dragging || !targetId || dragging === targetId) return Promise.resolve(false);
+
+    const ids = asArray(data?.todos).map((todo) => todo?.id).filter(Boolean);
+
+    const from = ids.indexOf(dragging);
+
+    if (from === -1) return Promise.resolve(false);
+
+    ids.splice(from, 1);
+
+    const to = ids.indexOf(targetId);
+
+    ids.splice(to === -1 ? ids.length : to, 0, dragging);
+
+    return runWrite(() => postJson('/reorder', { ids })).then((result) => result.ok);
+
+  }, [dragId, data, runWrite]);
+
+  
+
+  const dragHandlers = React.useMemo(() => ({
+
+    dragId,
+
+    hint: t('dragHint'),
+
+    onStart: (id) => {
+
+      setDragId(id);
+
+      // 拖了就说明想自己定顺序：自动切到手动，否则松手后看起来「没生效」
+
+      if (sort !== 'manual') setSort('manual');
+
+    },
+
+    onOver: () => {},
+
+    onDrop: (id) => handleDropOn(id),
+
+    onEnd: () => setDragId(null),
+
+  }), [dragId, sort, t, setSort, handleDropOn]);
+
+  
+
   const handleAdopt = React.useCallback((sessionTodos) => runWrite(() => postJson('/adopt', { todos: sessionTodos }))
     .then((result) => {
       // runWrite 已经刷新过列表，这里补一句「提升了几条、跳过几条」的回执，否则点完像没反应
@@ -879,7 +995,17 @@ function WorkTodoPanel(props) {
   const store = data?.store ?? null;
   const num = (value) => (Number.isFinite(Number(value)) ? Number(value) : 0);
   const overdueCount = num(stats.overdue);
-  const totalVisible = GROUPS.reduce((sum, group) => sum + asArray(groups[group.key]).length, 0);
+  // 视图分桶：按截止（原有 GROUPS）或按项目（宿主给的 projectGroups，附 未完成/总数/逾期）
+  const projectGroups = asArray(data?.projectGroups);
+  const viewGroups = view === 'project'
+    ? projectGroups.map((bucket) => ({
+      key: `p:${bucket?.key ?? ''}`,
+      label: bucket?.project ? String(bucket.project) : t('noProject'),
+      meta: `${num(bucket?.open)}/${num(bucket?.total)}${num(bucket?.overdue) ? ` · ${t('statOverdue')} ${num(bucket.overdue)}` : ''}`,
+      items: bucket?.todos,
+    }))
+    : GROUPS.map((group) => ({ key: group.key, label: t(group.label), items: groups[group.key] }));
+  const totalVisible = viewGroups.reduce((sum, group) => sum + asArray(group.items).length, 0);
 
   const chips = [
     { key: 'open', label: t('statOpen'), value: num(stats.open) },
@@ -908,6 +1034,31 @@ function WorkTodoPanel(props) {
         React.createElement('span', { key: 'l', style: { color: C.label3 } }, chip.label),
         React.createElement('b', { key: 'v', style: { fontWeight: 650 } }, String(chip.value)),
       ])),
+      React.createElement('span', { key: 'sort', className: 'wt-seg', title: t('sortLabel') }, [
+        ...['manual', 'priority', 'created'].map((mode) => React.createElement('button', {
+          key: mode,
+          type: 'button',
+          className: `wt-seg-btn${sort === mode ? ' is-on' : ''}`,
+          title: mode === 'manual' ? t('dragHint') : `${t('sortLabel')}：${t(`sort${mode === 'manual' ? 'Manual' : mode === 'priority' ? 'Priority' : 'Created'}`)}`,
+          onClick: () => setSort(mode),
+        }, t(`sort${mode === 'manual' ? 'Manual' : mode === 'priority' ? 'Priority' : 'Created'}`))),
+      ]),
+      React.createElement('span', { key: 'view', className: 'wt-seg' }, [
+        React.createElement('button', {
+          key: 'due',
+          type: 'button',
+          className: `wt-seg-btn${view === 'due' ? ' is-on' : ''}`,
+          title: t('viewDue'),
+          onClick: () => setView('due'),
+        }, t('viewDue')),
+        React.createElement('button', {
+          key: 'proj',
+          type: 'button',
+          className: `wt-seg-btn${view === 'project' ? ' is-on' : ''}`,
+          title: t('viewProject'),
+          onClick: () => setView('project'),
+        }, t('viewProject')),
+      ]),
       React.createElement('span', { key: 'sp', style: { flex: 1 } }),
       React.createElement('button', {
         key: 'rf',
@@ -980,10 +1131,11 @@ function WorkTodoPanel(props) {
 
     /* 分组列表 */
     totalVisible
-      ? React.createElement('div', { key: 'groups' }, GROUPS.map((group) => React.createElement(Group, {
+      ? React.createElement('div', { key: 'groups' }, viewGroups.map((group) => React.createElement(Group, {
         key: group.key,
-        label: t(group.label),
-        items: groups[group.key],
+        label: group.label,
+        meta: group.meta,
+        items: group.items,
         closed: Boolean(closed[group.key]),
         t,
         today,
@@ -991,6 +1143,7 @@ function WorkTodoPanel(props) {
         onToggleTodo: handleToggle,
         onRemove: handleRemove,
         onSave: handleSave,
+        drag: dragHandlers,
       })))
       : React.createElement('div', {
         key: 'empty',

package/src/records.mjs

@@ -228,6 +228,7 @@ export function createRecord(input = {}, { now = Date.now(), source = 'human', i
     priority: normalizePriority(input.priority) ?? 'normal',
     due: normalizeDue(input.due, now),
     project: normalizeProject(input.project),
+    order: null,
     source,
     createdAt: now,
     updatedAt: now,
@@ -312,14 +313,19 @@ const PRIORITY_WEIGHT = { high: 0, normal: 1, low: 2 };
  * @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;
@@ -327,9 +333,36 @@ export function sortForView(records) {
     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 +370,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 +383,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 +393,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 };

package/src/schema.mjs

@@ -67,6 +67,8 @@ export function repairRecord(raw) {
   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;
@@ -80,6 +82,7 @@ export function repairRecord(raw) {
     // 相对日期（today/+3d）按「读到的这一刻」折算：手改文件的人想的当然是今天
     due: typeof raw.due === 'string' ? coerce(() => normalizeDue(raw.due, Date.now()), 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/tools.mjs

@@ -22,6 +22,7 @@
  */
 export const TOOL_NAMES = Object.freeze([
   'worktodo_add',
+  'worktodo_add_many',
   'worktodo_list',
   'worktodo_update',
   'worktodo_done',
@@ -127,6 +128,109 @@ export async function registerWorkTodoTools({ ctx, service, logger }) {
     presentCall: (args) => ({ card: 'generic', title: '登记工作待办', kind: 'other', rawInput: args.title }),
   })));
 
+  // ---- 批量新增（AI 友好：一口气登记多条）----
+  disposers.push(ctx.tools.register(defineTool({
+    name: 'worktodo_add_many',
+    description:
+      '一次登记多条工作待办（用户一口气说了好几件事、或你整理出一串要跟进的活时用它；分开一条条调 worktodo_add 也行，但这样更省调用）。'
+      + '某条不合法只跳过那一条并把原因回传，不影响其余条目。',
+    parameters: {
+      items: {
+        type: 'array',
+        required: true,
+        description: '要登记的事；每项至少给 title。',
+        items: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            title: { type: 'string', required: true, description: '待办内容（一句简短的祈使句）。' },
+            due: { type: 'string', description: '截止日期：YYYY-MM-DD / today / tomorrow / +3d。' },
+            priority: { type: 'string', enum: ['high', 'normal', 'low'], description: '默认 normal。' },
+            project: { type: 'string', description: '项目或领域标签。' },
+            notes: { type: 'string', description: '背景、链接、验收标准。' },
+            status: { type: 'string', enum: ['pending', 'in_progress', 'completed'], description: '默认 pending。' },
+          },
+        },
+      },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          count: { type: 'number', required: true },
+          created: {
+            type: 'array',
+            required: true,
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                id: { type: 'string', required: true },
+                title: { type: 'string', required: true },
+                due: { type: 'string' },
+                priority: { type: 'string', required: true },
+                project: { type: 'string' },
+                status: { type: 'string', required: true },
+              },
+            },
+          },
+          skipped: {
+            type: 'array',
+            required: true,
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                index: { type: 'number', required: true },
+                title: { type: 'string', required: true },
+                reason: { type: 'string', required: true },
+              },
+            },
+          },
+          stats: { type: 'object', additionalProperties: true },
+        },
+      },
+      render: (_args, value) => [{
+        type: 'text',
+        text: `已记入工作待办 ${value.count} 条`
+          + (value.skipped.length ? `，跳过 ${value.skipped.length} 条（${value.skipped.map((entry) => `#${entry.index} ${entry.reason}`).join('；')}）` : '')
+          + (value.stats ? `｜当前未完成 ${value.stats.open} 条，逾期 ${value.stats.overdue} 条` : ''),
+      }],
+    },
+    async execute(args) {
+      const created = [];
+      const skipped = [];
+      const items = Array.isArray(args.items) ? args.items : [];
+      for (const [index, item] of items.entries()) {
+        try {
+          const result = unwrap(await service.create(item ?? {}, { source: 'agent' }));
+          created.push(compact({
+            id: result.todo.id,
+            title: result.todo.title,
+            due: result.todo.due ?? undefined,
+            priority: result.todo.priority,
+            project: result.todo.project ?? undefined,
+            status: result.todo.status,
+          }));
+        } catch (error) {
+          skipped.push({
+            index,
+            title: typeof item?.title === 'string' ? item.title : '',
+            reason: String(error?.message ?? error),
+          });
+        }
+      }
+      return withStats(compact({ count: created.length, created, skipped }));
+    },
+    presentCall: (args) => ({
+      card: 'generic',
+      title: `登记 ${Array.isArray(args.items) ? args.items.length : 0} 条工作待办`,
+      kind: 'other',
+      rawInput: '',
+    }),
+  })));
+
   // ---- 查询 ----
   disposers.push(ctx.tools.register(defineTool({
     name: 'worktodo_list',
@@ -138,6 +242,7 @@ export async function registerWorkTodoTools({ ctx, service, logger }) {
       filter: { type: 'string', enum: ['open', 'today', 'overdue', 'week', 'doing', 'completed', 'all'], description: '默认 open（未完成）。' },
       project: { type: 'string', description: '只看某个项目标签。' },
       query: { type: 'string', description: '按标题或备注里的关键词过滤。' },
+      sort: { type: 'string', enum: ['manual', 'priority', 'created'], description: '排序：manual=尊重用户拖动过的顺序（默认，用户看到的顺序）；priority=高优先级在前；created=最近添加的在前。' },
     },
     output: {
       schema: {