nx-kv 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -2,10 +2,107 @@
 
 本文件记录对外可见的变更。格式参考 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)。
 
-## [0.12.0] - 2026-10-30 仓库身份改用全局唯一 key + 导入导出重做
+## [0.13.0] - 2026-10-31 任务模板可配置 + 完成任务可删除 + 无队列仓库可从侧边栏新建任务 + 仓库前缀分组
 
 ### Added
 
+- **点项目组/项目目录 = 看表格**：
+  - 新增**项目组详情**（`#/group/<看板 id>`）：组里的**子目录**以表格呈现 ——
+    目录 / 路径 / 说明 / 待领取 / 归属（手动 vs 按前缀）。点组行进这里，点表行进该目录。
+  - 目录工作台的落地页改成**子任务表**（表格）：编号 / 任务 / 状态 / 创建 / 领取 /
+    删除。列表把「什么时候建、什么时候被领走」压成一行就丢了，表格才看得到。
+  - 侧栏点击语义分开：**点行 = 去看内容**（组 → 组表，目录 → 子任务表），
+    **点 chevron = 在树里展开/收起**。以前两者抢同一个点击，展开就没法兼得。
+- **仓库按前缀分组**：「仓库名以 nx 开头 → 归成一类」这类规则现在有了。
+  - 规则只改**成员关系**，看板仍是唯一分组载体 —— 侧边栏分组、仓库页看板筛选、
+    成员管理全都自动跟着生效，不用各改一遍。
+  - 规则存服务端（仓库 store 的 `prefixGroups`），换浏览器/换机一致；
+    规则同时记看板 id 与 key（改名不失效、导入换机有兜底）。
+  - CLI：`board prefix list` / `board prefix add <前缀> [--board <看板>]` /
+    `board prefix remove <前缀>`；HTTP 同构：
+    `GET/POST /api/boards/prefix-groups`、`DELETE /api/boards/prefix-groups/:prefix`。
+    目标看板留空 = 按前缀名**自动建同名看板**（如 `board prefix add nx`）。
+  - 面板：仓库管理页「看板」区新增「按前缀分组」区块（规则 chip + 前缀/看板输入 + 添加）。
+  - 删规则时，**规则建的空看板**一并清掉；看板里有手动成员则只删规则、不动看板。
+- **侧边栏分组读成组**：看板的成员行原本混在全局名称序里（组标题与成员不相邻，
+  「nx 一类」看着只是一堆缩进行）。现在成员紧跟在自己的看板行下面，未归组的仓库
+  排在所有组之后。
+- **任务模板（`template` 命令族 + 面板管理）**：MD 工作台「新建页」的起始正文不再写死。
+  - 存 `~/.nx-kv/templates.json`（`NX_KV_TEMPLATES_STORE` 可覆盖）；内置一条默认模板
+    （不可删），删掉自定义默认后默认回落到内置。
+  - 面板：管理入口在**侧边栏设置**（齿轮 → 「任务模板…」弹窗：新增 / 编辑 / 删除 /
+    设为默认）。弹窗头部写明新建页默认用哪个模板；每行给正文前几行的等宽预览；
+    正文用 **MD 编辑器**（源码 + 实时预览 + 格式工具条 B/I/代码/链接/列表/待办/引用/
+    H2/H3，Ctrl/⌘+B/I/E/K，视图可切并排/源码/预览）——模板本身就是 Markdown，
+    配置它不该是一个裸 textarea；编辑是行内表单（Ctrl/⌘+Enter 保存）；删除带确认。
+    落地页「模板 ▾」菜单按模板直接开新页（✓ 标默认）。「新建页」「新任务」一律取
+    默认模板正文，API 不可达时退回内置骨架（与旧版行为一致）。设置与工作台共享
+    同一份模板数据，改完即时生效。
+  - CLI：`template list` / `template add <name> [--body <md> | --body-file <文件> | --body -]`
+    `[--setDefault]` / `template update <id> [--name] [--body|--body-file]` /
+    `template remove <id>` / `template default <id>`；HTTP 同构：
+    `GET/POST /api/templates`、`PATCH /api/templates/:id`、
+    `DELETE /api/templates/:id`、`PATCH /api/templates/default`。
+    多行 Markdown 正文在 cmd.exe 里塞不进参数，所以给了 `--body-file`（读文件）与
+    `--body -`（读标准输入）——这两条**只在 CLI 生效**，HTTP 不暴露读本机文件。
+- **设置齿轮图标画错**：原来的 `gear` 是「圆心 + 八向光线」的日芒/亮度形状，不像设置。
+  重画为标准齿轮（中心圆 + 齿圈）。
+- **旧版 serve 进程配新版面板资产时，模板弹窗只说「加载失败」**：路由在进程启动时加载、
+  静态资产从磁盘现读——跑着旧进程时新 UI 会拿到 `/api/templates` 404。现在识别出
+  「接口不存在」这种版本偏差，弹窗明说「本机面板服务较旧，重启面板后重试」并隐藏
+  必然失败的表单，只留「重试」；普通瞬时失败同样给「重试」。
+
+### Fixed
+
+- **绑定的仓库没有任务队列时，侧边栏展不开也建不了任务**：仓库行的展开键在无队列时
+  是空串，渲染判断永远为 false——「＋ 新建页」子行根本不出现；直接跳工作台又会因
+  找不到队列主题落「目录不存在」。现在点无队列仓库能正常展开，点「新建页」/行菜单
+  「打开详情」/收起态 rail 图标会先自动登记该目录为任务队列（幂等、防 prune），再进
+  工作台。
+- **本地任务完成后没有任何删除入口**：完成（consumed）的任务此前只能留存在列表里。
+  现在两处都可删：落地页列表行悬停出「✕」；打开的页面在工具栏「更多」里有「删除」。
+  删除是**软删除**（`deletedAt` 标记，CLI `localtask task restore` 可恢复），已打开的
+  页签会随手关闭。
+
+## [0.12.1] - 2026-10-30 key 归一化修复 + remote 对齐反馈
+
+### Fixed
+
+- **keyFromRemote 在 Linux 上多一个前导斜杠**：同一地址在「派生」（keyFromRemote）与
+  「归一」（normalizeKey）两条路上算出的 key 必须一致。Linux 的 `file:///tmp/x` 剥协议后
+  带前导斜杠，于是「派生」得 `/tmp/x`、「归一」得 `tmp/x` —— 同一份数据算出两个 key，
+  导入时参考关系直接连不上（「参考仓库不存在」）。Windows 上是盘符所以走不到这个分支，
+  只有 CI 红。keyFromRemote 的结果现在就规范化（它是「key 的来源」，不该产出非规范形态）。
+- **remote 对齐弹窗的「检查」点了像没反应**：git ls-remote 要几秒，期间界面毫无变化；
+  出错又被 toast 吞掉（一闪而过）。改成点击即显示「检查中…」，错误原因直接写进弹窗
+  （错误信息不该只活 3 秒）。
+
+### Changed
+
+- 并入三个工作树的成果：md-desc（关系改 key + 导入占位 + remote 对齐）、
+  sidebar-repo-boards（侧边栏改用仓库登记 + 看板）、fix-checkbox-width
+  （勾选框被 width:100% 撑满 → 选项列表看着一片空白）。
+
+## [0.12.0] - 2026-10-30 仓库身份改用全局唯一 key + 导入导出重做
+
+### Changed
+
+- **侧边栏不再自建一套「目录 + 分组」，改为直接用仓库登记与看板**。
+  以前侧边栏的「目录」是本地任务队列按 cwd 自动生成的主题，「分组」存在浏览器
+  localStorage 里（`prefs.groups` / `prefs.dirGroups`）——后者与仓库页的看板是
+  **两套互不相干的数据**：换浏览器分组就没了，改看板侧边栏也不知道。
+  现在：
+  - 目录行 = **仓库登记**里的开发仓库（带全局唯一 key、描述、路径）；
+  - 分组行 = **看板**（展开看成员），归属关系就是看板的成员表；
+  - 侧边栏只保留纯 UI 偏好：排序、隐藏、展开态、收起态（`prefs` 里的
+    `groups` / `dirGroups` 已废弃并在读取时从 localStorage 抹掉）；
+  - 行菜单改操作真实数据：「归入/移出看板」走 `board assign`，
+    「＋」菜单变成「登记仓库 / 新建看板」（原来建的是任务队列主题，不是仓库登记）；
+  - 拖拽只改顺序（显示态），归属一律走行菜单——拖拽不再写本地分组。
+- 仓库模块：看板成员从随机 id（`repoIds`）迁到 **key**（`repoKeys`），读时自动
+  迁移并落盘；绑定目标同样记 key；`keyFromRemote` 剥 `file://` URL 的盘符冒号
+  （否则 `normalizeKey` 会把 `:` 压成 `-`，导致「登记的是 A、成员表里是 B」）。
+
 - **内部关系全面改用 key（不再是随机 id）+ 导入分组的「本地未拥有」占位**：
   - **关系一律用 key**：看板成员存 `repoKeys`（不是 `repoIds`）、组内描述按 key、
     绑定关系（linked，ref 侧与 dev 侧双向记录）也按 key。`repo.id` / `board.id`
@@ -22,6 +119,25 @@
     `repo remote check`（`git ls-remote` 检查远端是否存在，**存在 / 不存在 /
     不可达**三种结论分清）。面板上每行有「remote」按钮，弹窗里下拉切换 + 存在性徽标。
 
+- **MD 工作台编辑器专业对齐（10 轮 UI/UX 循环，纪要见 `plan/LOOP-MD-EDITOR.md`）**：
+  - **标题不再截断**：live 与源码两态的标题改为自动增高 textarea，长标题按宽度软换行；
+    Enter 不产生换行、直接把焦点交给正文（live 进首块 / 源码回正文 0 位）
+  - **工具栏分层**：模式 | 格式 | 插入三簇 hairline 分组，格式组去灰底容器（hover 才显底），
+    次级动作去描边转文本态，视觉重量留给主按钮
+  - **自适应改容器查询**：`.mdw-main` 声明 container，工具栏/纸面按「编辑列」实际宽度三级折叠
+    （1280 收转变组 / 960 收进溢出菜单 / 640 纸面紧凑）——修掉右侧进程 rail 一开就静默裁按钮的缺陷
+  - **溢出菜单 portal 到 body**：修 `···`/`更多` 菜单被工具栏 `overflow:hidden` 整条裁掉的缺陷
+  - **阅读态补题头**：三态标题呈现统一，题头与正文同轴同宽
+  - **空文档幽灵引导**：空文档渲染 Notion 式引导条，点击直接聚焦首块
+  - **撤销/重做**：新增文档级历史栈——受控 textarea 的程序化改写会冲掉浏览器原生 undo 栈，
+    原先「Ctrl+B 加粗 → Ctrl+Z」毫无反应；现在格式操作、输入段均可撤销/重做，
+    且撤销后光标回到改动处（源码精确，live 跨块自动跳转并接管焦点）
+  - **Ctrl/⌘S 保存 + 页签未保存圆点**：改动即在页签挂一颗点，保存/提交后摘除
+  - **快捷键速查面板**：Ctrl/⌘ / 或工具栏问号唤起，15 条键位分三组
+  - **实时预览块级查找**：Ctrl/⌘F 在预览态可用，n/m 计数 + 命中块高亮 + 滚动定位
+  - **无障碍**：编辑区 aria-label 补齐、状态栏小字对比度提到 WCAG AA
+
+
 - **仓库获得全局唯一 key，导入导出改以 key 为身份（v3）+ 全屏导入导出面板**：
   - **key**：归一化远程地址派生（`git@c:o/r.git`、`https://c/o/r`、
     `ssh://git@ssh.github.com:443/o/r.git`、带端口、带 `.git` 都是同一个

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx-kv",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "nx-kv — KV 清单管理中枢（远程）+ 本机本地任务队列（localtask）：serve 驱动 CLI 与 Web 面板，同源同构，附带可安装 skill 供 agent 提交 / 领取 / 阻塞接收任务",
   "type": "module",
   "bin": {
@@ -52,6 +52,7 @@
     "vite": "^8.3.0"
   },
   "dependencies": {
+    "flexlayout-react": "0.11.1",
     "react": "^19.3.0",
     "react-dom": "^19.3.0"
   }

package/src/modules/auth/index.js

@@ -32,7 +32,8 @@ export default {
   id: 'auth',
   title: '认证（登录态）',
   order: 10,
-  view: () => import('./view.jsx'),
+  // 登录 UI 已合并进云端页（frontend todo view），此处只保留 CLI/HTTP action；
+  // 独立面板视图已下线（2026-10-30）。
 
   actions: [
     {

package/src/modules/localtask/index.js

@@ -216,6 +216,29 @@ export default {
           ? `已彻底删除主题「${d.name}」#${d.removed.id}: ${d.removed.text}（不可恢复）`
           : `已删除主题「${d.name}」#${d.removed.id}: ${d.removed.text}（可用 localtask task restore 恢复）`,
     },
+    {
+      id: 'localtask.removeMany',
+      cli: ['localtask', 'remove-many'],
+      http: ['DELETE', '/api/localtasks/items'],
+      summary:
+        '批量删除任务（按 --ids，定位到 --cwd 主题或 --key）：一次落盘，逐条软删除（可 restore 恢复）；缺失的编号不阻断其余删除',
+      flags: {
+        ids: { type: 'array', required: true, hint: '任务编号，逗号分隔或给多次' },
+        cwd: CWD,
+        key: KEY,
+        purge: { type: 'boolean', hint: '彻底删除（不可恢复）；不加就是软删除' },
+      },
+      run: (ctx) => service.removeTasks({ ids: ctx.ids, cwd: ctx.cwd, key: ctx.key, purge: ctx.purge }),
+      render: (d) => {
+        const done = d.removed.map((x) => `#${x.id}`).join(' ');
+        const head = d.count
+          ? `${d.purged ? '已彻底删除' : '已删除'}主题「${d.name}」${d.count} 条（${done}）`
+          : `主题「${d.name}」没有可删的任务`;
+        const tail = d.missing.length ? `；未找到 #${d.missing.join(' #')}` : '';
+        const how = d.count && !d.purged ? '；可用 localtask task restore 恢复' : '';
+        return head + tail + how;
+      },
+    },
     {
       id: 'localtask.task.restore',
       cli: ['localtask', 'task', 'restore'],

package/src/modules/localtask/service.js

@@ -931,6 +931,61 @@ export async function removeTask({ cwd: rawCwd, key: rawKey, id, purge = false }
   return { status: 'ok', purged: false, key, cwd: t.cwd || cwd, name: t.name, removed: normalizeTask(task) };
 }
 
+/**
+ * 批量删除（面板「删除选中 n」用）：一次 loadStore / saveStore 处理多条。
+ *
+ * 单条语义与 removeTask 完全一致（软删除打 deletedAt，purge 彻底摘除），
+ * 但**不因个别 id 不存在而整体失败**：缺失的 id 收进 missing 让面板照实提示。
+ * 为什么不做成「循环调 removeTask」：那会变成 N 次读盘 + N 次整份写盘，
+ * 中间任何一次失败都会留下「删了一半、不知道删到哪」的状态。
+ *
+ * 重复删除同一条是幂等的（deletedAt 已有值就不再改写时间戳）。
+ */
+export async function removeTasks({ cwd: rawCwd, key: rawKey, ids, purge = false } = {}) {
+  const key = resolveTaskKey({ key: rawKey, cwd: rawCwd });
+  const { cwd } = normalizeCwd(rawCwd);
+  const wants = (Array.isArray(ids) ? ids : [ids])
+    .map((x) => Number(String(x ?? '').trim()))
+    .filter((n) => Number.isFinite(n) && n > 0);
+  if (!wants.length) throw badInput('缺少参数 --ids <任务编号，逗号分隔或给多次>');
+
+  const store = await loadStore();
+  const t = store.topics[key];
+  const removed = [];
+  const missing = [];
+  for (const want of wants) {
+    const index = t ? t.tasks.findIndex((x) => Number(x.id) === want) : -1;
+    if (index < 0) {
+      missing.push(want);
+      continue;
+    }
+    const task = t.tasks[index];
+    if (purge) {
+      // 彻底清除：行真的摘出去（不可恢复）。与 removeTask 同一套词汇。
+      t.tasks.splice(index, 1);
+      removed.push({ ...normalizeTask(task), purged: true });
+      continue;
+    }
+    if (!task.deletedAt) task.deletedAt = stampNow();
+    task.trashIndex = index; // 恢复时放回原位（与 removeTask 一致）
+    removed.push({ ...normalizeTask(task), purged: false });
+  }
+  if (removed.length) {
+    t.updatedAt = stampNow();
+    await saveStore(store);
+  }
+  return {
+    status: 'ok',
+    key,
+    cwd: t ? t.cwd || cwd : cwd,
+    name: t ? t.name : key,
+    purged: !!purge,
+    removed,
+    missing,
+    count: removed.length,
+  };
+}
+
 /**
  * 恢复一条被软删除的任务（撤销删除）。
  * 与 removeTask 互为逆操作：任务仍在队列里，只是带着 deletedAt 标记。

package/src/modules/localtask/view-overview.jsx

@@ -1,15 +1,153 @@
-// 全部目录总览（#/overview）：目录概览条（chip：名称+待领取数+等待标记）
-// + 按目录分组的待领取列表（v1 跨目录视角的接棒者）。
-import { useMemo } from 'react';
+// 全部目录总览（#/overview）：筛选条（chip：目录名+待领取数+等待标记，**只筛选不跳转**）
+// + 按目录分组的任务列表（待领取 + 可折叠的已领取历史）。
+//
+// 交互约定（2026-10-31 三次修订）：
+//   1. **顶部 chip 只做筛选**：点 = 选中/取消该目录（多选），「全部」清空筛选。
+//      不再点 chip 跳目录——进目录走分区标题链接，进任务详情点任务行。
+//   2. **每行任务带状态 tag**（待领取 / 已领取 / 已迁移 / 已删除，口径与
+//      splitQueueTasks / taskToProgress 一致）；已领取历史默认折叠，点开可见。
+//   3. **批量删除的落点在底部操作条**：勾选任意行后出现（position:sticky），
+//      跨目录一次删完（按目录分组逐个调 DELETE /api/localtasks/items）；
+//      仍是软删除（CLI localtask task restore 可恢复）。分区头只留「全选」。
+//   4. 任务行可点：直接进该任务的工作台详情（#/dir/<key>?task=<id>）；
+//      已领取行同样可点（详情页以「已回填」进度卡呈现）。
+import { useMemo, useState } from 'react';
+import { api } from '../../web/frontend/api/client.js';
 import { Icon } from '../../web/frontend/components/icons.jsx';
-import { splitQueueTasks } from './board.js';
+import { useToast } from '../../web/frontend/components/ui.jsx';
+import { titleFromMd } from '../../web/frontend/modules/md-workspace/md-parse.js';
+import { GLOBAL_KEY, splitQueueTasks } from './board.js';
+
+const NO_IDS = new Set();
+
+/** 任务状态 tag：与 board.splitQueueTasks、md-workspace taskToProgress 同一口径。 */
+function statusTag(t) {
+  if (t.deletedAt) return { label: '已删除', cls: 't-gone' };
+  if (t.migratedTo) return { label: '已迁移', cls: 't-gone' };
+  if (t.status === 'consumed') return { label: '已领取', cls: 't-done' };
+  return { label: '待领取', cls: 't-pend' };
+}
+
+export default function Overview({ rows, onNavigate, refreshLocal }) {
+  const toast = useToast();
+  // 勾选状态：Map<分区 key, Set<任务编号>>。行会随轮询刷新而消失，所以计数与删除
+  // 一律与「当前队列里仍存在且未删除」取交集，不额外做清理 effect。
+  const [sel, setSel] = useState(() => new Map());
+  // 筛选：选中的分区 key 集合；空集 = 全部。chip 只改这里，不做导航。
+  const [filter, setFilter] = useState(() => new Set());
+  // 「已领取」历史折叠：展开的分区 key 集合（默认全收起）。
+  const [doneOpen, setDoneOpen] = useState(() => new Set());
 
-export default function Overview({ rows, onNavigate }) {
   const dirs = useMemo(() => rows.filter((r) => !r.isGlobal), [rows]);
   const globalRow = rows.find((r) => r.isGlobal);
   const totalPending = dirs.reduce((n, r) => n + (r.pending || 0), 0) + (globalRow?.pending || 0);
   const waiting = rows.filter((r) => r.waiting);
 
+  const secKeyOf = (r) => (r.isGlobal ? GLOBAL_KEY : r.key);
+
+  // 跨目录的当前选中总数（只数仍存在且未删除的）
+  const selCount = useMemo(() => {
+    let n = 0;
+    for (const r of rows) {
+      const cur = sel.get(secKeyOf(r));
+      if (!cur || !cur.size) continue;
+      for (const t of r.tasks || []) if (cur.has(Number(t.id)) && !t.deletedAt) n += 1;
+    }
+    return n;
+  }, [rows, sel]);
+
+  const idsOf = (secKey) => sel.get(secKey) || NO_IDS;
+  const pickedOf = (secKey, pending) => {
+    const cur = idsOf(secKey);
+    return cur.size ? pending.map((t) => Number(t.id)).filter((id) => cur.has(id)) : [];
+  };
+
+  const toggleOne = (secKey, id) => {
+    setSel((prev) => {
+      const next = new Map(prev);
+      const cur = new Set(next.get(secKey) || []);
+      if (cur.has(id)) cur.delete(id);
+      else cur.add(id);
+      if (cur.size) next.set(secKey, cur);
+      else next.delete(secKey);
+      return next;
+    });
+  };
+
+  const toggleAll = (secKey, pending, clear) => {
+    setSel((prev) => {
+      const next = new Map(prev);
+      if (clear) next.delete(secKey);
+      else next.set(secKey, new Set(pending.map((t) => Number(t.id))));
+      return next;
+    });
+  };
+
+  const toggleFilter = (key) => {
+    setFilter((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  };
+
+  const toggleDone = (secKey) => {
+    setDoneOpen((prev) => {
+      const next = new Set(prev);
+      if (next.has(secKey)) next.delete(secKey);
+      else next.add(secKey);
+      return next;
+    });
+  };
+
+  /** 底部操作条的删除：把选中项按目录分组，逐组调批量删除接口。 */
+  const dropAll = async () => {
+    const groups = [];
+    for (const r of rows) {
+      const key = secKeyOf(r);
+      const cur = sel.get(key);
+      if (!cur || !cur.size) continue;
+      const ids = (r.tasks || [])
+        .filter((t) => cur.has(Number(t.id)) && !t.deletedAt)
+        .map((t) => Number(t.id));
+      if (ids.length) groups.push({ key, name: r.name || key, ids });
+    }
+    const total = groups.reduce((n, g) => n + g.ids.length, 0);
+    if (!total) return;
+    const scope = groups.length > 1 ? `（跨 ${groups.length} 个目录）` : '';
+    if (!confirm(`删除 ${total} 条任务${scope}？\n软删除：CLI localtask task restore 可恢复。`)) return;
+    let n = 0;
+    let miss = 0;
+    const errs = [];
+    for (const g of groups) {
+      try {
+        const r = await api('/api/localtasks/items', { method: 'DELETE', body: { key: g.key, ids: g.ids } });
+        n += Number(r?.count ?? 0);
+        miss += (r?.missing || []).length;
+      } catch (e) {
+        const msg = String(e.message || e);
+        // 路由在 serve 进程启动时加载：跑着旧进程时静态资产是新的、接口是旧的
+        if (/接口不存在/.test(msg)) {
+          toast('本机面板服务较旧，重启面板后再试（批量删除接口未上线）');
+          return;
+        }
+        errs.push(`${g.name}: ${msg}`);
+      }
+    }
+    if (errs.length) {
+      toast(`已删除 ${n} 条；${errs.length} 个目录失败：${errs[0]}${errs.length > 1 ? ` 等 ${errs.length} 项` : ''}`);
+    } else {
+      toast(`已删除 ${n} 条${miss ? `（${miss} 条未找到，可能已被删除）` : ''}`);
+    }
+    setSel(new Map());
+    refreshLocal?.();
+  };
+
+  const openTask = (base, id) => onNavigate(`${base}?task=${encodeURIComponent(id)}`);
+  const dirBase = (key) => '#/dir/' + encodeURIComponent(key);
+  const shown = (key) => !filter.size || filter.has(key);
+
   return (
     <div className="ov-wrap">
       <div className="ov-head">
@@ -21,8 +159,22 @@ export default function Overview({ rows, onNavigate }) {
       </div>
 
       <div className="ov-chips">
+        <span className="ov-filter-label">筛选</span>
+        <button
+          type="button"
+          className={'ov-chip' + (!filter.size ? ' on' : '')}
+          onClick={() => setFilter(new Set())}
+          title="显示全部目录"
+        >
+          全部
+        </button>
         {globalRow && (
-          <button className="ov-chip" onClick={() => onNavigate('#/global')}>
+          <button
+            type="button"
+            className={'ov-chip' + (filter.has(GLOBAL_KEY) ? ' on' : '') + (globalRow.waiting ? ' wait' : '')}
+            onClick={() => toggleFilter(GLOBAL_KEY)}
+            title="筛选：只看全局任务"
+          >
             <Icon name="globe" size={13} /> 全局任务
             <span className="c">{globalRow.pending || 0}</span>
             {globalRow.waiting && <span className="wdot" />}
@@ -30,10 +182,11 @@ export default function Overview({ rows, onNavigate }) {
         )}
         {dirs.map((d) => (
           <button
+            type="button"
             key={d.key}
-            className={'ov-chip' + (d.waiting ? ' wait' : '')}
-            onClick={() => onNavigate('#/dir/' + encodeURIComponent(d.key))}
-            title={d.cwd}
+            className={'ov-chip' + (filter.has(d.key) ? ' on' : '') + (d.waiting ? ' wait' : '')}
+            onClick={() => toggleFilter(d.key)}
+            title={`筛选：${filter.has(d.key) ? '取消' : '只看'}「${d.name}」`}
           >
             <Icon name="folder" size={13} /> {d.name}
             <span className="c">{d.pending || 0}</span>
@@ -45,52 +198,171 @@ export default function Overview({ rows, onNavigate }) {
         )}
       </div>
 
-      {globalRow && (globalRow.pending || 0) > 0 && (
-        <section className="ov-sec">
-          <div className="ov-sec-h">
-            <Icon name="globe" size={13} /> 全局任务
-            <span className="c">{globalRow.pending} 待领取</span>
-            <span className="grow" />
-            <button className="mini" onClick={() => onNavigate('#/global')}>打开</button>
-          </div>
-          {(globalRow.tasks || []).slice(0, 0).map(() => null)}
-          <PendingList tasks={globalRow.tasks} />
-        </section>
+      {globalRow && shown(GLOBAL_KEY) && ((globalRow.pending || 0) > 0 || globalRow.waiting) && (
+        <Sec
+          secKey={GLOBAL_KEY}
+          icon="globe"
+          title="全局任务"
+          cwd=""
+          tasks={globalRow.tasks}
+          waiting={!!globalRow.waiting}
+          selected={pickedOf(GLOBAL_KEY, splitQueueTasks(globalRow.tasks || []).pending)}
+          doneOpen={doneOpen.has(GLOBAL_KEY)}
+          onToggle={(id) => toggleOne(GLOBAL_KEY, id)}
+          onToggleAll={(clear, pending) => toggleAll(GLOBAL_KEY, pending, clear)}
+          onToggleDone={() => toggleDone(GLOBAL_KEY)}
+          onOpenDir={() => onNavigate('#/global')}
+          onOpenTask={(id) => openTask('#/global', id)}
+        />
       )}
 
       {dirs.map((d) => {
         const split = splitQueueTasks(d.tasks || []);
+        if (!shown(d.key)) return null;
         if (!split.pending.length && !d.waiting) return null;
         return (
-          <section className="ov-sec" key={d.key}>
-            <div className="ov-sec-h">
-              <Icon name="folder" size={13} /> {d.name}
-              <span className="c mono">{d.cwd}</span>
-              <span className="c">{split.pending.length} 待领取</span>
-              {d.waiting && <span className="badge-wait"><span className="pulse" /> 等待回填</span>}
-              <span className="grow" />
-              <button className="mini" onClick={() => onNavigate('#/dir/' + encodeURIComponent(d.key))}>打开</button>
-            </div>
-            <PendingList tasks={d.tasks} />
-          </section>
+          <Sec
+            key={d.key}
+            secKey={d.key}
+            icon="folder"
+            title={d.name}
+            cwd={d.cwd}
+            tasks={d.tasks}
+            waiting={!!d.waiting}
+            selected={pickedOf(d.key, split.pending)}
+            doneOpen={doneOpen.has(d.key)}
+            onToggle={(id) => toggleOne(d.key, id)}
+            onToggleAll={(clear, pending) => toggleAll(d.key, pending, clear)}
+            onToggleDone={() => toggleDone(d.key)}
+            onOpenDir={() => onNavigate(dirBase(d.key))}
+            onOpenTask={(id) => openTask(dirBase(d.key), id)}
+          />
         );
       })}
+
+      {filter.size > 0 &&
+        !((globalRow && shown(GLOBAL_KEY) && ((globalRow.pending || 0) > 0 || globalRow.waiting)) ||
+          dirs.some((d) => shown(d.key) && (splitQueueTasks(d.tasks || []).pending.length || d.waiting))) && (
+        <div className="muted" style={{ padding: '12px 4px' }}>没有匹配当前筛选的目录。</div>
+      )}
+
+      {selCount > 0 && (
+        <div className="ov-bar" role="toolbar" aria-label="批量删除操作条">
+          <span className="ov-bar-n">
+            已选 <b>{selCount}</b> 条任务
+          </span>
+          <span className="grow" />
+          <button type="button" className="mini" onClick={() => setSel(new Map())}>
+            取消选择
+          </button>
+          <button type="button" className="btn small danger" onClick={dropAll}>
+            删除选中 {selCount}
+          </button>
+        </div>
+      )}
     </div>
   );
 }
 
-function PendingList({ tasks }) {
+/**
+ * 一个目录分区：标题（可点进落地页）+ 计数 + 全选 + 待领取行 + 可折叠的已领取历史。
+ * `selected` 是**已经与当前待领取取过交集**的编号数组，全选判定只看它。
+ */
+function Sec({ secKey, icon, title, cwd, tasks, waiting, selected, doneOpen, onToggle, onToggleAll, onToggleDone, onOpenDir, onOpenTask }) {
   const split = splitQueueTasks(tasks || []);
-  if (!split.pending.length) return <div className="ov-task muted">（队列为空）</div>;
+  const pending = split.pending;
+  const consumed = split.consumed;
+  const on = new Set(selected);
+  const allOn = pending.length > 0 && pending.every((t) => on.has(Number(t.id)));
+  const someOn = on.size > 0 && !allOn;
+
   return (
-    <>
-      {split.pending.map((t) => (
-        <div className="ov-task" key={t.id}>
-          <span className="mono faint">#{t.id}</span>
-          <span className="tx" title={t.text}>{t.text}</span>
-          <span className="m mono">{t.from === 'cloud' ? '来自云端' : ''}</span>
-        </div>
+    <section className="ov-sec" data-sec={secKey}>
+      <div className="ov-sec-h">
+        <Icon name={icon} size={13} />
+        <button type="button" className="ov-sec-t" onClick={onOpenDir} title={`进入「${title}」`}>
+          {title}
+        </button>
+        {cwd ? <span className="c mono">{cwd}</span> : null}
+        <span className="c">{pending.length} 待领取</span>
+        {waiting && (
+          <span className="badge-wait">
+            <span className="pulse" /> 等待回填
+          </span>
+        )}
+        <span className="grow" />
+        {pending.length > 0 && (
+          <label className="ov-all">
+            <input
+              type="checkbox"
+              checked={allOn}
+              ref={(el) => {
+                if (el) el.indeterminate = someOn;
+              }}
+              onChange={() => onToggleAll(allOn, pending)}
+              aria-label={`全选「${title}」的待领取任务`}
+            />
+            全选
+          </label>
+        )}
+      </div>
+
+      {!pending.length && <div className="ov-task muted">（队列为空）</div>}
+      {pending.map((t) => (
+        <TaskRow key={t.id} t={t} checked={on.has(Number(t.id))} onToggle={onToggle} onOpenTask={onOpenTask} />
       ))}
-    </>
+
+      {consumed.length > 0 && (
+        <>
+          <button type="button" className="ov-done-toggle" onClick={onToggleDone} aria-expanded={doneOpen}>
+            <span className={'tri' + (doneOpen ? ' open' : '')} aria-hidden="true">
+              ▸
+            </span>
+            已领取 {consumed.length}
+          </button>
+          {doneOpen &&
+            consumed.map((t) => (
+              <TaskRow
+                key={t.id}
+                t={t}
+                checked={on.has(Number(t.id))}
+                onToggle={onToggle}
+                onOpenTask={onOpenTask}
+                meta={t.consumedAt ? String(t.consumedAt).slice(5, 16) : ''}
+              />
+            ))}
+        </>
+      )}
+    </section>
+  );
+}
+
+/** 一行任务：勾选框 + 编号 + 标题 + （云端来源 tag）+ （时间）+ 状态 tag。整行可点进详情。 */
+function TaskRow({ t, checked, onToggle, onOpenTask, meta = '' }) {
+  const tag = statusTag(t);
+  return (
+    <div
+      className="ov-task link"
+      role="button"
+      tabIndex={0}
+      title="打开任务详情"
+      onClick={() => onOpenTask(t.id)}
+      onKeyDown={(e) => {
+        if (e.key !== 'Enter' && e.key !== ' ') return;
+        e.preventDefault();
+        onOpenTask(t.id);
+      }}
+    >
+      <label className="ov-ck" onClick={(e) => e.stopPropagation()}>
+        <input type="checkbox" checked={checked} onChange={() => onToggle(Number(t.id))} aria-label={`选择 #${t.id}`} />
+      </label>
+      <span className="mono faint">#{t.id}</span>
+      <span className="tx" title={t.text}>
+        {titleFromMd(t.text, t.text || '未命名任务')}
+      </span>
+      {t.from === 'cloud' && <span className="tag t-cloud">云端</span>}
+      {meta ? <span className="m mono">{meta}</span> : null}
+      <span className={'tag ' + tag.cls}>{tag.label}</span>
+    </div>
   );
 }