nx-kv 0.19.0 → 0.21.0

package/CHANGELOG.md

@@ -2,6 +2,135 @@
 
 本文件记录对外可见的变更。格式参考 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)。
 
+## [0.21.0] - 2026-11-05 队列与编排的职责单一化 + store 损坏防护
+
+### Fixed
+
+- **store 损坏不再静默清空队列**：localtasks.json 读不出/解析失败时，先把坏文件**改名保留**为
+  `<store>.corrupt-<时间戳>`（同目录最多留 3 份，超出删最旧；改名失败则保留原文件等下次），
+  再落到空 store。此前坏文件留在原地，下一次任何写操作会把它原地覆盖——一次磁盘抖动
+  等于全部主题无声清零。
+
+### Changed
+
+- **localtask service 拆分**（原 2458 行单文件 → 16 个单一职责文件 + 47 行门面）：
+  对外 API 路径与行为**零变化**（CLI/HTTP/面板与所有调用方无感），模块内部分工见各文件头注释。
+- **就绪判定双实现合一**：任务行入口与快照入口此前是两套算法（闸门语义被编码两次），
+  现在共用同一张图与同一个内核判定；跨队列依赖（`"topicKey:id"`）的 fail-open 口径不变。
+  新增跨模型一致性测试，逐条钉住两个入口对同一份数据的结论必须相等。
+- **闸门谓词统一**（`isGateNode`）：此前散落 5 处且判定字段漂移（有的只认插件名、
+  有的连 scope 一起认），现收成一处并集口径。
+- **环检测实现下沉 `src/shared/graph.js`**：mutator 与两个前端组件（画布编排面板、目录编排
+  编辑器）共用一份 DFS——此前三份拷贝，其中一处曾因方向写反漏判 2 节点环。
+- **wait 编排拆分**：面板随行（拉起主面板/深链/窗口重开防风暴）搬进
+  `tasktool/panel-escort.js`，`waitForTask` 回归纯队列出口语义；三个 500ms 节拍的轮询
+  合并为一个 ticker。返回契约与 `--no-open` 行为逐字不变。
+
+## [0.20.0] - 2026-11-04 任务编排（DAG）进面板 + 面包屑/设置面板收拾 + 改归属项目即搬家
+
+### Added
+
+- **任务编排（DAG）进面板（任务 #40）**：目录落地页任务表与项目组「本组任务」列表支持编排——
+  - **拖动排序**：目录任务表待领取行可拖动换位（落点=上半行前/下半行后，青绿线指示），
+    走既有 `localtask reorder`（已领取行是固定历史，不可拖）；
+  - **编排编辑器**（行尾「⋮」→「编排依赖…」）：闸门开关、上游依赖（我等谁）、
+    下游任务（谁等我，逐条改对方 blockBy）三段勾选，保存前客户端查环——
+    会成环的组合直接禁用；闸门开启时上游段禁用并清空、下游自动覆盖（引擎约束对齐：
+    闸门的隐含边与上游边成环，`applySnapshotToTopic` 亦把闸门显式后继按冗余剪除）；
+  - **组页按队列表达**：组任务横跨多个成员队列，编排以**该任务所属队列**为作用域
+    （候选/闸门下游都取本队列），闸门×N 与锁定徽章上屏；
+  - 闸门徽章升级：显示被挡后续数（`闸门×N`，悬停列出 #id）。
+- 组任务行尾新增「⋮」行菜单（编排依赖 / 闸门开关），待领取行悬停可见。
+
+### Changed
+
+- **设置面板观感重做（任务 #41 重开反馈「ui 太丑了」→ 二轮「更丑了」）**：交互语义不变，只收拾
+  密度与层级——「提示词 / 模板」栏的竖排 tab 侧栏改成顶部一排药丸、内容限宽；提示词条目行去描边、
+  编号不用圆圈、**收起标题洗掉原始模板标记**（不再直接甩 `{{#goal}}〔…〕` 给人看）；操作条分隔线分组；
+  项目级设置从大卡片改成紧凑行（项目多时一屏 8 个而不是 2 个），「持续 get」关着时只留一枚行内小开关；
+  「提示词 / 模板」栏不再套卡（盒中盒显脏）。：交互语义不变，只收拾
+  密度与层级——「提示词 / 模板」栏的竖排 tab 侧栏改成顶部一排药丸、内容限宽；
+  提示词条目行去描边、编号不用圆圈；操作条分隔线分组；项目级设置从大卡片改成
+  紧凑行（项目多时一屏 8 个而不是 2 个），「持续 get」关着时只留一枚行内小开关。
+
+### Changed
+
+- **面包屑移到 maincontent 面板内顶部（任务 #44）**：路径条不再占窗口顶部通栏
+  （那是侧栏的地盘），改成挂在**当前主面板**顶部的一枚小药丸——目录任务表 /
+  任务详情页 / 项目组 / 全部目录总览 / 云端总览 / 仓库管理 / 任务模板 各面板
+  根部都有一条；MD 工作台里则直接放进顶部工具栏（`mdw-top`）内、标题左侧；
+  「← 返回」随路径条一起搬进面板（按来处返回的行为不变）。：路径条不再占窗口顶部通栏
+  （那是侧栏的地盘），改成挂在**当前主面板**顶部的一枚小药丸——目录任务表 /
+  任务详情页 / 项目组 / 全部目录总览 / 云端总览 / 仓库管理 / 任务模板 各面板
+  根部都有一条；「← 返回」随路径条一起搬进面板（按来处返回的行为不变）。
+
+### Fixed
+
+- **改归属项目即搬家（任务 #43「提交任务后发现归属项目填错了，重新修改提交无效」）**：
+  此前「归属决定落点」只在提交那一刻生效——提交后发现归属填错，改正文里的 project 再保存，
+  正文改了队列没动：任务还挂在旧项目队列里，旧项目的 agent 照旧领走，新项目的 agent 永远
+  看不见，组面板/目录页也都显示旧归属。现在 `localtask update --text` / `localtask reopen --text`
+  / 面板「保存并同步 / 重做」走与派任务同一套落点判定：effective frontmatter.project 解析到
+  哪个登记项目，任务就迁到哪个队列；介绍引用（projectIntro/projectDesc）随归属刷新。
+  约束如实说明：已领取的任务不能改归属（要改先 reopen）；带队列内依赖/闸门的任务搬运会
+  跨队列断链，先解除再改（明确报错，不静默）；搬家后任务拿到**新队列的 id**（面板页签自动
+  跟到新号，CLI 输出标注迁移）；指向它的跨队列引用（`topicKey:id`）改写到新地址。
+  另自愈历史脏数据：归属字段与所在队列对不上（上一轮只改字段没搬队列的残留）时，
+  保存即搬到归属队列；已领取/带队列内依赖的脏数据不搬也不拦普通编辑。
+
+- **顶部面包屑真正可见 + 补返回键（任务 #42）**：面包屑此前**渲染了却看不见**——
+  FlexLayout 的根是绝对定位（inset:0），铺满工作区把 26px 的路径条盖在下面
+  （侧栏面板压在上面，路径条点不到也看不见）。现在工作区有面包屑时布局整体下移一条；
+  侧栏也不再出页签条（#33「无页签化」的残留，页签条同样压在路径条上）。
+  面包屑条左侧新增「← 返回」：按**来处**返回（会话内路由历史栈）——
+  从项目组点任务（任务住在 dir 队列里，详情页落在 dir 作用域）时，返回会回到**组**
+  而不是掉进目录；没有上一级时不画返回键。
+
+### Changed
+
+- **可视化编排面板（任务 #40 验收反馈重开）**：目录与项目组**共用**一块编排面板，
+  从任务面板**头部右侧的绿色超链**进入（开在右侧主内容区）：
+  - **节点 = 小圆角卡片**，画布带网格底；节点纵向位置 = 队列顺序；
+  - **拖拽排序**：拖节点即改队列顺序（已领取节点是固定历史，不可拖）；
+  - **连线建立有向依赖**：从节点左侧把手拉到另一个节点 = 后者等前者（写入 blockBy）；
+    依赖边以曲线 + 箭头画在画布左侧，节点上显示「等 #N」芯片（可一键解除）；
+  - **节点工具**：设为闸门（挡住后续）/ 加时间目标（timegoal）/ 打开任务；
+  - 组视图进来可在**成员队列之间切换**（DAG 的排序/依赖/闸门都是队列内的）；
+  - 编排只改被碰过的那几项，没编排过的节点保持原队列序。
+- **设置面板交互收敛（任务 #41）**：
+  - **左边 tab 悬停即切换**（设置外层分区导航 + 「提示词 / 模板」栏内的三个分类），
+    点击保留为兜底；少一次点击。
+  - **提示词条目默认收起成标题行**（首行截断 + 字数），**点击才展开编辑**（单开手风琴）；
+    「添加一条…」新增后直接展开待填。
+  - **说明文字全部删除**：设置面板右侧的静态说明段（工作区/任务工具/项目级等）与
+    提示词栏的提示段一并清掉，只留状态与操作。
+  - **项目级「持续 get」一句话配置**：选模板（内置默认 + 全局回调提示词条目）→ 改一句话
+    （`%s` = 任务编号，存取时与 `{{task.id}}` 互转）→ 添加；不再手写整段模板。
+
+### Added
+
+- `localtask config --suffix-list "一条,二条"` / `--ack-list "一条,二条"`：**整体替换**多条
+  提示词列表（逗号分隔；HTTP body 传数组）。此前 action 只暴露单条 `--suffix`/`--ack`，
+  面板的多条保存无处可传（#41 实测发现并修）。
+
+### Fixed
+
+- **首次打开设置面板爆栈**（任务 #41 实测发现，#33 遗留）：`openPanel` 按区域分发时
+  FLOAT → `openFloatingPanel` → `openPanel`（未带 area）→ 又判成 FLOAT → 无限递归
+  （"Maximum call stack size exceeded"）。老布局因已存着设置浮窗、走 existing 早退而侥幸
+  没踩到，全新档案首次打开必崩。内层调用显式指定 `AREA.MAIN` 后收敛。
+- **回调 / ack 提示词在面板上保存不了**（任务 #41 实测发现，#32 遗留）：面板打的是
+  `taskSuffix`/`ackPrompt` 字段，action 未声明 → 请求 400 且**静默无效**（面板回显旧列表，
+  看起来像保存成功）。改为 `suffixList`/`ackList`（对应上面新增的列表 flag）后真正落库。
+- 侧栏搜索框降高响应式（任务 #38）：`label.sbox` 28px→24px 显式定高；「＋」按钮
+  `flex:none` 永不被挤掉；侧栏按实际像素宽分档降级（≤256 收间距 / ≤195 藏撤销重做 /
+  ≤150 藏标题+放大镜 / ≤125 藏品牌字+匹配数），高频件（搜索框、＋、收起/关闭、齿轮）
+  永远在场；`nx-title` 窄宽折两行一并修复。
+- 面板 maximize 键全线下线（任务 #39）：`tabSetEnableMaximize=false` 一关全断
+  （页签条 Maximize/Restore 按钮、右键菜单最大化项、双击标题栏最大化都走
+  `canMaximize()` 门控）；连带清理死翻译与死 CSS 变量。
+- 目录/组任务行的「⋮」菜单点击不再冒泡打开任务详情（stopPropagation）。
+
 ## [0.19.0] - 2026-11-04 提示词/模板收敛到设置面板 + 面板无页签化（面包屑 + 区域策略）+ DAG 引擎与 goal 插件族
 
 ### Added

package/assets/kv-get/references/wait-workflow.md

@@ -96,9 +96,10 @@ wait 必带一句当前现状总结（≤2000 字，连续空白会折叠为单
 - **配置**：`nx-kv localtask config --suffix "<模板>"`（占位符
   `{{goal.name}} {{goal.remainingHuman}} {{goal.prompt}} {{task.text}} {{source}} {{name}}…`，
   段落 `{{#goal}}…{{/goal}}` 上下文缺失整段消失；`--no-suffix` 关闭、
-  `--reset-suffix` 恢复默认）。字段缺席 = 已关闭或本轮没有可渲染内容。
+  `--reset-suffix` 恢复默认；**多条**用 `--suffix-list "第一条,第二条"`（逗号分隔）整体替换，
+  或 `--suffix-add` / `--suffix-remove <序号>` 按条增删）。字段缺席 = 已关闭或本轮没有可渲染内容。
 - **ack 提示词（完成总结的格式要求）**：`nx-kv localtask config --ack "<提示词>"`
-  （占位符同上，多条）。配置后，它会随 `instruction` 一起交给你——按它要求的格式
+  （占位符同上；多条用 `--ack-list "第一条,第二条"`（逗号分隔）整体替换）。配置后，它会随 `instruction` 一起交给你——按它要求的格式
   写 `localtask done --summary "<完成总结>"` 即可；没配置时 `instruction` 里没有
   这段，格式自便。设置面板「提示词 / 模板」一栏也能配。
 

package/package.json

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

package/src/core/workflow/project.js

@@ -1,7 +1,9 @@
 // 主题队列（localtask topic.tasks）↔ WorkflowSnapshot 双向投影。
 // 存盘形状仍是任务行；快照是引擎视图。正文不进快照（payload.textRef）。
+// 跨队列 blockBy（"topicKey:id"）不进引擎边，投影回写时必须保留。
 
-import { BUILTIN_GOALS, edgesFromTasks, taskToNode } from './types.js';
+import { edgesFromTasks, isGateNode, taskToNode } from './types.js';
+import { normalizeBlockBy, parseDepRef } from './readiness.js';
 
 /** @typedef {import('./types.js').WorkflowSnapshot} WorkflowSnapshot */
 /** @typedef {import('./types.js').WfNode} WfNode */
@@ -64,25 +66,23 @@ export function applySnapshotToTopic(topic, snap) {
 
   // 边 → blockBy（显式依赖）；闸门边由 blocksFollowing 表达，不写进每条 blockBy
   const gateIds = new Set(
-    (snap.nodes || [])
-      .filter(
-        (n) =>
-          n.kind === 'control' ||
-          (n.plugins || []).some((p) => p.name === BUILTIN_GOALS.blockgoal),
-      )
-      .map((n) => String(n.id)),
+    (snap.nodes || []).filter((n) => isGateNode(n)).map((n) => String(n.id)),
   );
 
   for (const task of tasks) {
     if (task.deletedAt || task.migratedTo) continue;
+    const keepForeign = normalizeBlockBy(task.blockBy, task.id).filter(
+      (d) => parseDepRef(d)?.kind === 'foreign',
+    );
     const incoming = (snap.edges || []).filter((e) => String(e.to) === String(task.id));
-    const deps = [];
+    const localDeps = [];
     for (const e of incoming) {
       // 跳过「闸门挡后续」推出来的边：from 是闸门且闸门在数组序上早于本任务时由 blocksFollowing 覆盖
       if (gateIds.has(String(e.from))) continue;
-      deps.push(e.from);
+      const n = Number(e.from);
+      if (Number.isFinite(n) && n > 0) localDeps.push(n);
     }
-    task.blockBy = deps.map((d) => Number(d)).filter((n) => Number.isFinite(n) && n > 0);
+    task.blockBy = normalizeBlockBy([...localDeps, ...keepForeign], task.id);
   }
 
   topic.workflowRevision = Number(snap.revision) || 0;
@@ -94,8 +94,7 @@ export function applySnapshotToTopic(topic, snap) {
 
 /** @param {object} task @param {WfNode} node */
 function syncTaskFromNode(task, node) {
-  const hasBlock = (node.plugins || []).some((p) => p.name === BUILTIN_GOALS.blockgoal);
-  task.blocksFollowing = node.kind === 'control' || hasBlock;
+  task.blocksFollowing = isGateNode(node);
 
   if (node.state === 'success') {
     if (!task.completedAt) {

package/src/core/workflow/readiness.js

@@ -1,17 +1,96 @@
-// 拓扑就绪（自 localtask/dag.js 下沉）。任务行与快照节点两套入口。
+// 拓扑就绪（自 localtask/dag.js 下沉）。任务行与快照节点两套入口，**一个内核**：
+// 任务行先投影成轻量图（taskToNode + edgesFromTasks），本地依赖与闸门判定直接
+// 复用 isNodeReady——两个模型对同一份数据产出同一张图，结论必然一致
+// （一致性由 tests/unit/readiness-consistency.test.mjs 钉死）。
+//
+// blockBy 支持：
+//   - 本地 id（number）——同队列依赖（兼容旧存盘）；入图，走内核判定
+//   - 跨队列引用 `"<topicKey>:<taskId>"`——组编排跨项目边；不入引擎图
+//     （edgesFromTasks 跳过），由 resolveForeign 前置直查，fail-open
 
-/** 规范化 blockBy：正整数 id、去重、丢掉自身 */
+import { edgesFromTasks, taskToNode, isGateNode } from './types.js';
+
+/** topicKey:id —— key 允许字母数字与 _-（含 __GLOBAL__） */
+const FOREIGN_RE = /^([A-Za-z0-9_-]+):(\d+)$/;
+
+/**
+ * @typedef {{ kind: 'local', id: number } | { kind: 'foreign', key: string, id: number }} DepRef
+ */
+
+/**
+ * 解析单条依赖引用。
+ * @param {unknown} x
+ * @returns {DepRef | null}
+ */
+export function parseDepRef(x) {
+  if (typeof x === 'number' && Number.isFinite(x) && x > 0) {
+    return { kind: 'local', id: Math.trunc(x) };
+  }
+  const s = String(x ?? '').trim();
+  if (!s) return null;
+  const m = FOREIGN_RE.exec(s);
+  if (m) return { kind: 'foreign', key: m[1], id: Number(m[2]) };
+  // 纯数字字符串 → 本地 id（避免把 "12" 当 foreign）
+  if (/^\d+$/.test(s)) {
+    const n = Number(s);
+    if (Number.isFinite(n) && n > 0) return { kind: 'local', id: n };
+  }
+  return null;
+}
+
+/** @param {DepRef} ref @returns {number|string} */
+export function formatDepRef(ref) {
+  if (!ref) return '';
+  if (ref.kind === 'foreign') return `${ref.key}:${ref.id}`;
+  return ref.id;
+}
+
+/**
+ * 规范化 blockBy：本地正整数 id + 跨队列 "key:id"、去重、丢掉本地自身。
+ * @param {unknown} raw
+ * @param {number|string} [selfId]
+ * @returns {Array<number|string>}
+ */
 export function normalizeBlockBy(raw, selfId) {
   const self = Number(selfId);
   const seen = new Set();
   const out = [];
-  for (const x of Array.isArray(raw) ? raw : []) {
-    const n = Number(x);
-    if (!Number.isFinite(n) || n <= 0) continue;
-    if (Number.isFinite(self) && n === self) continue;
-    if (seen.has(n)) continue;
-    seen.add(n);
-    out.push(n);
+
+  /** @type {unknown[]} */
+  let items = [];
+  if (raw == null || raw === '') items = [];
+  else if (Array.isArray(raw)) items = raw;
+  else if (typeof raw === 'string' && /[,，\s]/.test(raw) && !FOREIGN_RE.test(raw.trim())) {
+    items = raw.split(/[,，\s]+/).filter(Boolean);
+  } else {
+    items = [raw];
+  }
+
+  // 数组元素里也可能是逗号串（HTTP 偶发）
+  const flat = [];
+  for (const x of items) {
+    if (typeof x === 'string' && /[,，]/.test(x) && !FOREIGN_RE.test(x.trim())) {
+      flat.push(...x.split(/[,，\s]+/).filter(Boolean));
+    } else {
+      flat.push(x);
+    }
+  }
+
+  for (const x of flat) {
+    const ref = parseDepRef(x);
+    if (!ref) continue;
+    if (ref.kind === 'local') {
+      if (Number.isFinite(self) && ref.id === self) continue;
+      const token = String(ref.id);
+      if (seen.has(`L:${token}`)) continue;
+      seen.add(`L:${token}`);
+      out.push(ref.id);
+    } else {
+      const token = `${ref.key}:${ref.id}`;
+      if (seen.has(`F:${token}`)) continue;
+      seen.add(`F:${token}`);
+      out.push(token);
+    }
   }
   return out;
 }
@@ -28,38 +107,75 @@ function isPendingLike(t) {
   return isAlive(t) && t.status !== 'consumed';
 }
 
+/**
+ * @typedef {object} ReadyOpts
+ * @property {(topicKey: string, taskId: number) => object|null|undefined} [resolveForeign]
+ *   跨队列依赖解析；缺席或返回空 = fail-open（挡不住）
+ */
+
+/** 跨队列依赖是否未满足（true = 挡）。无解析器 / 解析不到 / 已删已迁 → fail-open 不挡。 */
+function foreignBlocked(task, opts) {
+  for (const d of normalizeBlockBy(task.blockBy, task.id)) {
+    const ref = parseDepRef(d);
+    if (!ref || ref.kind !== 'foreign') continue;
+    if (typeof opts?.resolveForeign !== 'function') continue;
+    const found = opts.resolveForeign(ref.key, ref.id);
+    const dep = found && isAlive(found) ? found : null;
+    if (dep && !isCompleted(dep)) return true;
+  }
+  return false;
+}
+
+/**
+ * 任务行 → 轻量图（与 topicToSnapshot 同源：taskToNode 投影节点、edgesFromTasks 产边）。
+ * blockBy 先过 normalizeBlockBy（去自身/去非法，与引擎写入路径同一口径）再产边；
+ * "key:id" 外部边不入图。这是两个模型共用的唯一边源。
+ * @param {object[]} tasks
+ * @returns {{ nodes: import('./types.js').WfNode[], edges: import('./types.js').WfEdge[] }}
+ */
+function rowsGraph(tasks) {
+  const alive = (tasks || []).filter(isAlive).map((t) => ({
+    ...t,
+    blockBy: normalizeBlockBy(t.blockBy, t.id),
+  }));
+  return { nodes: alive.map(taskToNode), edges: edgesFromTasks(alive) };
+}
+
+/** 图上判定：目标节点缺位（不在 all 里）→ true；否则交给 isNodeReady 内核。 */
+function readyInGraph(graph, taskId) {
+  const node = (graph.nodes || []).find((n) => String(n.id) === String(taskId));
+  if (!node) return true;
+  return isNodeReady(graph, node);
+}
+
 /**
  * 某条 pending 现在能不能领（任务行模型）。
+ * 本地依赖 + 闸门走快照同一内核（isNodeReady）；跨队列依赖走 resolveForeign 前置直查。
+ * 前驱判定口径：completedAt ⇔ 节点 success（taskToNode 映射），闸门 = control 屏障。
  * @param {object} task
  * @param {object[]} all
+ * @param {ReadyOpts} [opts]
  */
-export function isReadyToClaim(task, all = []) {
+export function isReadyToClaim(task, all = [], opts = {}) {
   if (!isPendingLike(task)) return false;
-  const byId = new Map((all || []).filter(isAlive).map((t) => [Number(t.id), t]));
-
-  const deps = normalizeBlockBy(task.blockBy, task.id);
-  for (const id of deps) {
-    const dep = byId.get(id);
-    if (!dep) continue;
-    if (!isCompleted(dep)) return false;
-  }
-
-  const idx = (all || []).indexOf(task);
-  const order = all || [];
-  const myPos = idx >= 0 ? idx : order.findIndex((t) => Number(t.id) === Number(task.id));
-  if (myPos < 0) return true;
-  for (let i = 0; i < myPos; i += 1) {
-    const prev = order[i];
-    if (!isAlive(prev) || !prev.blocksFollowing) continue;
-    if (!isCompleted(prev)) return false;
-  }
-  return true;
+  if (foreignBlocked(task, opts)) return false;
+  return readyInGraph(rowsGraph(all), task.id);
 }
 
-/** 按数组序找第一条可领取的 pending；没有 → null */
-export function findFirstReadyPending(tasks = []) {
-  for (const t of tasks || []) {
-    if (isReadyToClaim(t, tasks)) return t;
+/**
+ * 按数组序找第一条可领取的 pending；没有 → null。
+ * 图一次构建逐条判定（结论与逐条 isReadyToClaim 相同，省掉每条重建图）。
+ * @param {object[]} tasks
+ * @param {ReadyOpts} [opts]
+ */
+export function findFirstReadyPending(tasks = [], opts = {}) {
+  const list = tasks || [];
+  const graph = rowsGraph(list);
+  for (const t of list) {
+    if (!isPendingLike(t)) continue;
+    if (foreignBlocked(t, opts)) continue;
+    const node = graph.nodes.find((n) => String(n.id) === String(t.id));
+    if (!node || isNodeReady(graph, node)) return t;
   }
   return null;
 }
@@ -82,10 +198,7 @@ export function isNodeReady(snap, node, isBarrierOpen) {
   for (const e of preds) {
     const pred = byId.get(String(e.from));
     if (!pred) continue;
-    const isControl =
-      pred.kind === 'control' ||
-      (pred.plugins || []).some((p) => p.name === 'blockgoal' || p.scope === 'control');
-    if (isControl) {
+    if (isGateNode(pred)) {
       const open = isBarrierOpen
         ? isBarrierOpen(snap, pred.id)
         : pred.state === 'success';

package/src/core/workflow/types.js

@@ -108,6 +108,21 @@ export const BUILTIN_GOALS = Object.freeze({
   timegoal: 'timegoal',
 });
 
+/**
+ * 这个节点是不是「闸门」（控制屏障）——唯一的判定口径，全系统共用
+ * （曾散落 5 处且字段漂移：有的只认 blockgoal 名、有的连 scope==='control' 一起认）。
+ * 并集口径：kind=control，或绑了 blockgoal，或绑了任意 control-scope 插件。
+ * @param {WfNode} node
+ * @returns {boolean}
+ */
+export function isGateNode(node) {
+  if (!node) return false;
+  if (node.kind === 'control') return true;
+  return (node.plugins || []).some(
+    (p) => p.name === BUILTIN_GOALS.blockgoal || p.scope === 'control'
+  );
+}
+
 /**
  * 把现有 localtask 任务行投影成契约节点（只读适配，不改存盘形状）。
  * @param {object} task
@@ -155,7 +170,10 @@ export const edgesFromTasks = (tasks = []) => {
   const alive = (tasks || []).filter((t) => t && !t.deletedAt && !t.migratedTo);
   for (const t of alive) {
     for (const dep of Array.isArray(t.blockBy) ? t.blockBy : []) {
-      edges.push({ from: dep, to: t.id });
+      // 引擎快照只认本队列数字边；跨队列 "key:id" 留给 get/ready 解析
+      const n = Number(dep);
+      if (!Number.isFinite(n) || n <= 0 || String(dep).includes(':')) continue;
+      edges.push({ from: n, to: t.id });
     }
   }
   for (let i = 0; i < alive.length; i += 1) {

package/src/modules/localtask/dag.js

@@ -1,5 +1,7 @@
 // 过渡再导出：实现已下沉 core/workflow/readiness.js
 export {
+  parseDepRef,
+  formatDepRef,
   normalizeBlockBy,
   isReadyToClaim,
   findFirstReadyPending,

package/src/modules/localtask/deletion.js

@@ -0,0 +1,129 @@
+// （#54 自 service.js 拆出）主题删除：四条删除路径共用的同一套判定（deleteGuard：
+// 全局池/等待中/有未领取 → 需 --force）+ 单个/批量删除。
+import { badInput } from '../../core/errors.js';
+import { isGlobalKey, normalizeCwd, resolveTopicKey } from './paths.js';
+import { loadStore, saveStore } from './store-io.js';
+import { isLiveWaiting, isPending, topicView } from './task-view.js';
+// ─── 删除判定：四条删除路径共用同一套规则 ──────────────────────────────
+//
+// 以前「删任务 / 删主题 / 批量删除 / prune」各有各的保护规则，
+// 面板只暴露其中两套 → 同一个动作在 CLI 与面板上表现不一样，看着像乱。
+// 现在规则只写一份，四个入口都调它：
+//
+//   protected（全局共享池）→ 需要 --force
+//   waiting（正阻塞等待）  → 需要 --force（agent 会超时收尾）
+//   has_pending（有未领取）→ 需要 --force（活还没人领）
+//   manual（手动登记的目录）→ 只在 prune 里保留，不参与普通删除
+//
+// force=true 仍然强删（老用法不变）。
+export const DELETE_REASONS = {
+  protected: '全局共享池',
+  waiting: '等待中',
+  has_pending: '有未领取任务',
+  manual: '手动登记',
+};
+
+/**
+ * 判定一个主题能不能删。
+ * @returns {{ok:boolean, reason?:string, pending?:number, message?:string}}
+ */
+export function deleteGuard(topic, { force = false, key = '', scope = 'topic' } = {}) {
+  if (isGlobalKey(key)) {
+    return force
+      ? { ok: true }
+      : { ok: false, reason: 'protected', message: '全局主题是共享任务池，默认不能删除（确认要清空请加 --force）' };
+  }
+  if (isLiveWaiting(topic)) {
+    return force
+      ? { ok: true }
+      : { ok: false, reason: 'waiting', message: '主题正在等待中，不能删除（确认要删请加 --force，agent 将超时收尾）' };
+  }
+  const pending = countPending(topic);
+  // prune 只清"旧脏数据"，不是"删主题"：它不因未领取任务而跳过
+  //（否则会改变 prune 既有语义——它本来就只清空主题/旧模型主题）。
+  if (scope !== 'prune' && pending > 0 && !force) {
+    return {
+      ok: false,
+      reason: 'has_pending',
+      pending,
+      message: `主题「${topic.name || key}」还有 ${pending} 条未领取任务，删除会一并丢掉（确认要删请加 --force）`,
+    };
+  }
+  if (scope === 'prune' && topic.manual) {
+    return { ok: false, reason: 'manual', message: '手动登记的目录不会被 prune 清理（请用 topic remove）' };
+  }
+  return { ok: true };
+}
+
+// 主题里还有多少条**未领取且未删除**的任务（= 还没人领的活）。
+// 删除保护用它：队列里还堆着活就不该被一声不吭地清空。
+function countPending(t) {
+  if (!t || !Array.isArray(t.tasks)) return 0;
+  return t.tasks.filter(isPending).length;
+}
+
+// 删除整个主题（连同其全部任务）。默认拒绝删除「等待中」主题——那会让正阻塞的
+// agent 只能等到超时；force=true 才强删（agent 随后超时收尾）。
+// 全局主题同样默认拒绝（共享池，删掉会让所有 worker 的候补来源消失）；
+// force=true 清空全局任务池。
+export async function removeTopic({ cwd: rawCwd, key: rawKey, force = false } = {}) {
+  if (!rawKey && !rawCwd) {
+    throw badInput('需要 --cwd "<工作目录>" 或 --key "<主题key>"');
+  }
+  const key = resolveTopicKey({ key: rawKey, cwd: rawCwd });
+  const store = await loadStore();
+  const t = store.topics[key];
+  if (!t) {
+    const { notFound } = await import('../../core/errors.js');
+    throw notFound(`主题不存在（key ${key}）`);
+  }
+  // 删除判定只写一份（deleteGuard）：全局共享池 / 等待中 / 有未领取任务 → 都要 --force。
+  const guard = deleteGuard(t, { force, key });
+  if (!guard.ok) throw badInput(guard.message);
+  const view = topicView(t);
+  delete store.topics[key];
+  await saveStore(store);
+  return { status: 'removed', key, name: t.name, cwd: t.cwd, topic: view };
+}
+
+// 批量删除主题：keys / cwds（数组，可并用），或 all=true 清空全部。
+// 默认把「等待中」「不存在」计入 skipped 而不删；force=true 连等待中一起删。
+export async function removeTopics({ keys, cwds, all = false, force = false } = {}) {
+  const hasList = (a) => Array.isArray(a) && a.some((x) => String(x).trim());
+  if (!all && !hasList(keys) && !hasList(cwds)) {
+    throw badInput('需要 --keys "<key,key>" 或 --cwds "<目录,目录>"，或 --all');
+  }
+
+  const store = await loadStore();
+  let targets;
+  if (all) {
+    targets = Object.keys(store.topics);
+  } else {
+    const list = [];
+    if (Array.isArray(keys)) list.push(...keys.map((x) => String(x).trim()).filter(Boolean));
+    if (Array.isArray(cwds)) {
+      for (const c of cwds) if (String(c).trim()) list.push(normalizeCwd(c).key);
+    }
+    targets = [...new Set(list)];
+  }
+
+  const removed = [];
+  const skipped = [];
+  for (const key of targets) {
+    const t = store.topics[key];
+    if (!t) {
+      skipped.push({ key, reason: 'not_found' });
+      continue;
+    }
+    // 判定与单删共用同一套规则（deleteGuard）——批量与单个的语义必须一致
+    const g = deleteGuard(t, { force, key });
+    if (!g.ok) {
+      skipped.push({ key, name: t.name, cwd: t.cwd, reason: g.reason, pending: g.pending || 0 });
+      continue;
+    }
+    removed.push({ key, name: t.name, cwd: t.cwd });
+    delete store.topics[key];
+  }
+  if (removed.length) await saveStore(store);
+  return { status: 'ok', all: !!all, count: removed.length, removed, skipped };
+}