dsh-tree-task-flow 0.3.13 → 0.3.15

package/config.example.yml

@@ -1,6 +1,12 @@
 # 这个文件只是示例，插件不需要它——**安装即启用**，装完就能用。
 #
-# **默认值一律是"开"。** 插件还没有配置界面，功能默认关等于这个功能不存在。
+# **两个开关平时不用改这里。** 打开侧边栏的「插件」页，在「已安装」里点
+# `dsh-tree-task-flow` 那张卡，页面上就是这两个开关——那是活的，改完立刻生效，
+# 而且**盖过这里写的值**。优先级是：
+#
+#     插件页里改过的  >  profile 里的 config  >  DEFAULT_CONFIG
+#
+# 这里留给"连插件页也不想点"的场合（比如要一次性写进 profile 发给别人）。
 # 想改成默认以外的东西时，把下面这段抄进 profile 自己的 cordis.patch.yml
 # （通常是 $DSH_HOME/profiles/<名字>/cordis.patch.yml）：
 #
@@ -16,14 +22,15 @@
     # 总开关。默认 true（装上即启用）；写 false 就一句话关掉，
     # 关掉后插件不注册工具、不加提示词、不折叠上下文、不续行，一个字节都不碰会话。
     enabled: true
-    # 模型停下时是否自动续行。默认 true —— 一条总规矩：插件还没有配置界面，
-    # 功能就不能默认关（默认关等于这个功能不存在）。怕它停不下来不必靠这里：
-    # 你按下停止会落盘 held/stopped，续行自己就被拦住，真人再发一条消息才解除。
-    autoContinue: true
+    # 模型停下时是否自动续行。**默认 false（不续）。**
+    # 它会在你没看着的时候自己往下跑，所以默认交给插件页里的人来点——
+    # 插件页里的那两个开关是活的，改完立刻生效，不用重启。
+    autoContinue: false
     # 连续自动续行的轮次上限，达到就停；只有真人发言才重置配额。
     maxAutoRounds: 5
     # 意外中断后是否自动拉起（见 README「意外中断自动拉起」）。默认 true：
-    # 它只在「这一轮不是正常结束」时动手，正常停下不受影响。
+    # 它只在「这一轮不是正常结束」时动手，正常停下不受影响。同样能在插件页里开关，
+    # 而且改完立刻生效——这一项是"要不要救"，与上一项"要不要往前推"是两件事。
     interruptRecovery: true
     # 网络/API 类中断的拉起时刻，单位毫秒，默认 [1分钟, 5分钟, 10分钟, 30分钟]；
     # null 表示用内置默认值。工具执行中断不看这张表，它永远立即拉一次。

package/cordis.patch.yml

@@ -12,14 +12,16 @@
 #    字段一次写全。可覆盖的字段见 DEFAULT_CONFIG：
 #
 #   enabled             总开关                  默认 true（写 false 关掉）
-#   autoContinue        是否允许自动续行        默认 true
+#   autoContinue        是否允许自动续行        默认 false（插件页里能改）
 #   maxAutoRounds       连续自动续行轮次上限    默认 5
-#   interruptRecovery   意外中断是否自动拉起    默认 true
+#   interruptRecovery   意外中断是否自动拉起    默认 true（插件页里能改）
 #   interruptDelaysMs   网络类中断拉起时刻      默认 null（= 1/5/10/30 分钟）
 #   promptOrder         工具说明段顺序          默认 1800
 #   rootDir             插件状态目录            默认 $DSH_HOME/dsh-task-tree
 #
-# 默认值一律是"开"。插件还没有配置界面，功能默认关等于这个功能不存在。
+# 两个布尔开关（autoContinue / interruptRecovery）平时不用在这里改：
+# **侧边栏「插件」页**里点开 `dsh-tree-task-flow` 这张卡，页面上就有这两个开关——
+# **改完立刻生效、并且盖过这里写的值**（插件页 > profile config > DEFAULT_CONFIG）。
 - insert:
     - id: task-tree
       name: 'dsh-tree-task-flow'

package/lib/commands.js

@@ -8,16 +8,38 @@
  * @module dsh-tree-task-flow/commands
  */
 
-import { activePath, checkpointOf, complete, dropNode, levelLabel, renderTree } from "./plan.js";
+import {
+  activePath,
+  checkpointOf,
+  complete,
+  deleteNode,
+  dropNode,
+  findNode,
+  goalsOf,
+  levelLabel,
+  renderGoal,
+  renderTree,
+} from "./plan.js";
+import { renderList } from "./render.js";
+import {
+  activeRequirement,
+  deleteRequirement,
+  dropRequirement,
+  listActive,
+  listArchived,
+  listDrafts,
+  requirementOf,
+} from "./requirement.js";
 
 /** 用法说明，status 和 help 都会带上。 */
 const USAGE = [
-  "/task-tree                     查看本会话的任务树与检查点状态",
-  "/task-tree done <id> <结果>     提交某个节点的结果并完成它",
-  "/task-tree drop <id>           丢弃某个节点",
+  "/task-tree                     查看本会话的需求列表与当前进度",
+  "/task-tree done <id> <结果>     提交某个节点（需求 / 任务 / 步骤）的结果并完成它",
+  "/task-tree drop <id>           放弃：留着可查，标记为不做了",
+  "/task-tree delete <id>         删除：连下面的一起摘掉，不看状态",
   "/task-tree pause               暂停：当前工具跑完后停住，不再往下推进",
   "/task-tree resume              继续：从停住的地方接着跑，不插消息",
-  "/task-tree reset               清掉本会话的计划树",
+  "/task-tree reset               清掉本会话的计划（需求、任务全没）",
 ].join("\n");
 
 /** 插件被配置关掉时唯一要说的话：现在是关的，以及怎么打开。 */
@@ -25,6 +47,25 @@ const DISABLED_NOTE =
   "dsh-tree-task-flow 已被配置**关闭**（config 里 enabled 不是 true）：它没有注册工具，" +
   "也不会折叠任何上下文。要打开请在 profile 的 cordis.patch.yml 里把 enabled 设为 true。";
 
+/**
+ * 需求列表的文本：与面板、工具共用同一份渲染（`render.renderList`）。
+ *
+ * @param plan - 计划树。
+ * @returns 多行 Markdown。
+ */
+function listText(plan) {
+  const pick = (rows) => rows.map((row) => requirementOf(plan, row.id)).filter((item) => item !== null);
+  return renderList(
+    plan,
+    {
+      active: pick(listActive(plan)),
+      archived: pick(listArchived(plan)),
+      drafts: listDrafts(plan),
+    },
+    activeRequirement(plan),
+  );
+}
+
 /**
  * 把检查点那句话拼出来。措辞与 `plan.js` 的 `renderContinue` 一致。
  *
@@ -59,8 +100,9 @@ export function registerCommands(ctx, { store, cfg, pause = null, enabled = fals
 
   commands.register({
     name: "task-tree",
-    description: "查看与管理任务树：status / done <id> <结果> / drop <id> / pause / resume / reset",
-    input: { hint: "status | done <id> <结果> | drop <id> | pause | resume | reset" },
+    description:
+      "查看与管理任务树：status / done <id> <结果> / drop <id> / delete <id> / pause / resume / reset",
+    input: { hint: "status | done <id> <结果> | drop <id> | delete <id> | pause | resume | reset" },
     handler: (invocation) => {
       const sessionId = invocation?.agent?.session?.id;
       if (sessionId === undefined) {
@@ -127,12 +169,12 @@ export function registerCommands(ctx, { store, cfg, pause = null, enabled = fals
           };
         }
         const plan = store.readPlan(sessionId);
-        if (plan === null) return { kind: "error", text: "本会话还没有计划。" };
+        if (plan === null) return { kind: "error", text: "本会话还没有需求。" };
         const outcome = complete(plan, id, result);
         if (!outcome.ok) return { kind: "error", text: `没有完成：${outcome.reason}` };
         store.writePlan(sessionId, plan);
-        // `complete` 已经把检查点提示放进 events 了，这里只补上折叠后的树。
-        return { kind: "success", text: [...outcome.events, "", renderTree(plan)].join("\n") };
+        // `complete` 已经把检查点提示放进 events 了，这里只补上最新的需求列表。
+        return { kind: "success", text: [...outcome.events, "", listText(plan)].join("\n") };
       }
 
       if (verb === "drop") {
@@ -141,29 +183,60 @@ export function registerCommands(ctx, { store, cfg, pause = null, enabled = fals
           return { kind: "error", text: `用法：/task-tree drop <节点 id>\n\n${USAGE}` };
         }
         const plan = store.readPlan(sessionId);
-        if (plan === null) return { kind: "error", text: "本会话还没有计划。" };
-        const result = dropNode(plan, id);
-        if (!result.ok) return { kind: "error", text: `没有丢弃：${result.reason}` };
+        if (plan === null) return { kind: "error", text: "本会话还没有需求。" };
+        const isRequirement = requirementOf(plan, id) !== null;
+        const result = isRequirement ? dropRequirement(plan, id) : dropNode(plan, id);
+        if (!result.ok) return { kind: "error", text: `没有放弃：${result.reason}` };
         store.writePlan(sessionId, plan);
         return {
           kind: "success",
-          text: [`已丢弃：${result.dropped.join("、")}`, "", renderTree(plan)].join("\n"),
+          text: [`已放弃：${result.dropped.join("、")}`, "", listText(plan)].join("\n"),
         };
       }
 
+      if (verb === "delete") {
+        const id = rest[0];
+        if (id === undefined) {
+          return { kind: "error", text: `用法：/task-tree delete <节点 id>\n\n${USAGE}` };
+        }
+        const plan = store.readPlan(sessionId);
+        if (plan === null) return { kind: "error", text: "本会话还没有需求。" };
+        // 摘掉之后就查不到"这次动的是哪条需求"了，先记一份。
+        const touched = findNode(plan, id);
+        const isRequirement = requirementOf(plan, id) !== null;
+        const result = isRequirement ? deleteRequirement(plan, id) : deleteNode(plan, id);
+        if (!result.ok) return { kind: "error", text: `没有删除：${result.reason}` };
+        store.writePlan(sessionId, plan);
+
+        const lines = [`已删除：${result.removed.join("、")}`, ""];
+        if (touched !== null && touched.level !== "goal") {
+          // 删的是任务或步骤：它所在的那条需求还在，只给它那条需求的列表。
+          lines.push(listText(plan));
+        } else {
+          const left = goalsOf(plan).length;
+          lines.push(
+            left === 0
+              ? "这个会话现在没有需求了。"
+              : `这个会话还剩 ${left} 条需求，要看全部用 /task-tree status。`,
+          );
+        }
+        return { kind: "success", text: lines.join("\n") };
+      }
+
       if (verb !== "status") {
         return { kind: "error", text: `不认识的子命令：${verb}\n\n${USAGE}` };
       }
 
       const plan = store.readPlan(sessionId);
-      const lines = [renderTree(plan)];
+      const lines = [];
 
       if (enabled !== true) {
-        lines.push("", DISABLED_NOTE);
+        lines.push(DISABLED_NOTE);
       } else if (plan === null) {
-        lines.push("", "本会话还没有计划。用 tree_task_plan 建立目标与任务。");
+        lines.push("本会话还没有需求。用 tree_task_create 记一条需求草稿，跟用户确认之后才算真需求。");
       } else {
-        // 检查点优先于"当前节点"：那一刻要推进的不是某个子任务，
+        lines.push(listText(plan));
+        // 检查点优先于"当前节点"：那一刻要推进的不是某个步骤，
         // 而是"这一层到底做完了没有"这个判断。
         const checkpoint = checkpointOf(plan);
         const active = activePath(plan);

package/lib/http.js

@@ -14,6 +14,8 @@
  *   - **暂停状态**：条目上的暂停/继续按钮写的就是这个。暂停挂的是
  *     `agent/pre-step`（见 `pause.js`），不插消息、不改计划，所以它不属于计划树，
  *     单独回传。
+ *   - **设置**：面板上那两个开关（见 `settings.js`）。它跟会话无关，读的时候顺手带上，
+ *     改的时候写盘并**就地改活配置**，所以改完立刻生效，不用重启。
  *
  * 条目上的按钮都写计划树，所以写完要把**新的**活动路径、结果与检查点一并回传，
  * 免得条目还要再发一次请求才知道自己按出了什么效果。
@@ -21,7 +23,23 @@
  * @module dsh-tree-task-flow/http
  */
 
-import { activePath, checkpointOf, complete, dropNode, levelLabel } from "./plan.js";
+import { activePath, complete, deleteNode, dropNode, levelLabel } from "./plan.js";
+import { SETTING_KEYS, settingsSnapshot } from "./settings.js";
+import {
+  addDraft,
+  currentVersion,
+  deleteRequirement,
+  dropRequirement,
+  listActive,
+  listArchived,
+  listDrafts,
+  missingPrerequisites,
+  nextTaskOf,
+  progressOf,
+  requirementOf,
+  setArchived,
+  updateByUser,
+} from "./requirement.js";
 
 /** 统一的 JSON 响应。 */
 function sendJson(response, status, body) {
@@ -44,30 +62,98 @@ async function readJsonBody(request) {
   }
 }
 
-/** 活动路径压成面板要的形状：三层各自的 id，没到那层就是 null。 */
-function activeInfo(plan) {
-  const active = activePath(plan);
-  if (active === null) return null;
+/**
+ * 一条需求压成面板要的形状。
+ *
+ * 列表上只显示标题、简介与状态；`detail` 与 `versions` 也一起给——面板是本机的，
+ * 展开时不用再发一次请求，而"要不要展示"是面板自己的事。
+ *
+ * @param plan - 计划树。
+ * @param requirement - 需求节点。
+ * @returns 面板用的行对象。
+ */
+function rowOf(plan, requirement) {
+  const task = nextTaskOf(requirement);
   return {
-    goalId: active.goal.id,
-    taskId: active.task?.id ?? null,
-    stepId: active.step?.id ?? null,
+    id: requirement.id,
+    title: requirement.title,
+    intro: requirement.intro,
+    detail: requirement.detail,
+    status: requirement.status,
+    archived: requirement.archived === true,
+    pending: requirement.pending
+      ? {
+          title: requirement.pending.title,
+          intro: requirement.pending.intro,
+          detail: requirement.pending.detail,
+          change: requirement.pending.change,
+          question: requirement.pending.question,
+          at: requirement.pending.at,
+        }
+      : null,
+    missing: missingPrerequisites(plan, requirement).map((item) => ({
+      id: item.id,
+      state: item.state,
+    })),
+    prerequisites: requirement.prerequisites ?? [],
+    nextTask: task === null ? null : { id: task.id, title: task.title },
+    version: currentVersion(requirement),
+    changes: (requirement.versions ?? []).length,
+    updatedAt: requirement.updatedAt ?? null,
+    result: requirement.result?.text ?? null,
+    tasks: (requirement.tasks ?? []).map((each) => ({
+      id: each.id,
+      title: each.title,
+      status: each.status,
+      result: each.result?.text ?? null,
+      steps: (each.steps ?? []).map((step) => ({
+        id: step.id,
+        title: step.title,
+        status: step.status,
+        result: step.result?.text ?? null,
+      })),
+    })),
   };
 }
 
-/** 检查点压成面板要的形状；没有检查点就是 null。 */
-function checkpointInfo(plan) {
-  const found = checkpointOf(plan);
-  if (found === null) return null;
+/**
+ * 面板要的整份数据：两个列表 + 草稿区 + 当前进行中的展开。
+ *
+ * 「当前进行中」由**最后执行的那个任务**推导（`activeRequirement`），面板不另存状态。
+ *
+ * @param plan - 计划树。
+ * @returns 面板用的数据；没有计划时三个列表都是空的。
+ */
+function panelData(plan) {
+  if (plan === null) {
+    return {
+      requirements: { active: [], archived: [], drafts: [] },
+      current: null,
+      progress: [],
+    };
+  }
+  const active = listActive(plan).map((row) => rowOf(plan, requirementOf(plan, row.id)));
+  const archived = listArchived(plan).map((row) => rowOf(plan, requirementOf(plan, row.id)));
+  const drafts = listDrafts(plan).map((requirement) => rowOf(plan, requirement));
+  // 当前进行中的那一条：它的任务与步骤要在列表里就地展开。
+  const live = active.find((row) => row.status === "pending") ?? null;
+  const current = live ?? null;
   return {
-    id: found.node.id,
-    level: found.level,
-    label: levelLabel(found.level),
-    title: found.node.title,
+    requirements: { active, archived, drafts },
+    current: current === null ? null : current.id,
+    progress:
+      current === null
+        ? []
+        : progressOf(requirementOf(plan, current.id)).map(({ task, steps }) => ({
+            id: task.id,
+            title: task.title,
+            status: task.status,
+            steps: steps.map((step) => ({ id: step.id, title: step.title, status: step.status })),
+          })),
   };
 }
 
-/** 一个节点提交过的结果；还没提交就是 null。 */
+/** 一条节点提交过的结果；还没提交就是 null。 */
 function resultOf(node) {
   if (!node?.result) return null;
   return {
@@ -78,35 +164,23 @@ function resultOf(node) {
   };
 }
 
-/** 活动路径上每一层各自提交的结果。 */
-function levelResults(plan) {
-  const active = activePath(plan);
-  return {
-    goal: resultOf(active?.goal),
-    task: resultOf(active?.task),
-    step: resultOf(active?.step),
-  };
-}
-
 /** 一次写操作之后，面板需要的全部新状态。 */
 function afterWrite(plan) {
-  return {
-    active: activeInfo(plan),
-    checkpoint: checkpointInfo(plan),
-    results: levelResults(plan),
-  };
+  return panelData(plan);
 }
 
 /**
  * 注册全部面板接口。
  *
  * @param ctx - 挂载本行的 Cordis 上下文。
- * @param options - `{ store, autoContinue, pause }`；插件被关闭时后两者是 null。
+ * @param options - `{ store, autoContinue, pause, cfg }`；插件被关闭时 `autoContinue`
+ *   与 `pause` 是 null。`cfg` 是那一份**活的对象**：读的时候用它报当前开关，
+ *   改的时候就地改它——各模块按事件现读，所以下一刻就生效。
  */
-export function registerHttp(ctx, { store, autoContinue, pause = null }) {
+export function registerHttp(ctx, { store, autoContinue, pause = null, cfg = null }) {
   ctx.inject(["webServer"], (host) => {
     host.effect(() => {
-      // 一棵树的全部信息：结构 + 每层结果 + 检查点 + 当前路径 + 三层折叠游标。
+      // 面板要的全部数据：需求两个列表 + 草稿区 + 当前进行中的展开 + 按住状态。
       host.webServer.register(
         {
           kind: "exact",
@@ -116,26 +190,38 @@ export function registerHttp(ctx, { store, autoContinue, pause = null }) {
             const url = new URL(request.url ?? "/", "http://localhost");
             const sessionId = url.searchParams.get("sessionId") ?? "";
             const plan = store.readPlan(sessionId);
-            if (plan === null) return sendJson(response, 404, { ok: false, error: "这个会话没有计划" });
 
-            const cursors = store.readSurfaces(sessionId);
             sendJson(response, 200, {
               ok: true,
-              plan,
+              sessionId,
               ...afterWrite(plan),
-              cursors: {
-                goal: cursors.goal ?? null,
-                task: cursors.task ?? null,
-                step: cursors.step ?? null,
-              },
               stopped: autoContinue?.isStopped?.(sessionId) === true,
               paused: pause?.isPaused?.(sessionId) === true,
+              settings: settingsSnapshot(cfg),
             });
           },
         },
         "dsh-tree-task-flow: tree",
       );
 
+      // 插件管理里本插件那一页用的接口：**跟会话无关**，只回两个开关的当前值与总开关
+      // 状态。那一页不是某个会话的界面，没有"当前会话"这个概念，所以它不能走 `/tree`。
+      host.webServer.register(
+        {
+          kind: "exact",
+          path: "/dsh-tree-task-flow/settings",
+          handler: async (request, response) => {
+            if (request.method !== "GET") return sendJson(response, 405, { ok: false, error: "只支持 GET" });
+            sendJson(response, 200, {
+              ok: true,
+              enabled: cfg?.enabled === true,
+              settings: settingsSnapshot(cfg),
+            });
+          },
+        },
+        "dsh-tree-task-flow: settings",
+      );
+
       // 面板上的按钮都走这一个端点。
       host.webServer.register(
         {
@@ -161,6 +247,92 @@ export function registerHttp(ctx, { store, autoContinue, pause = null }) {
               });
             }
 
+            // 面板上的开关。跟会话无关，所以不读 sessionId。
+            //
+            // 两件事一起做：**写盘**（重启后还在）与**就地改活配置**（这一刻就生效）。
+            // 各模块都是"事件来了现读 cfg"，所以改完不用重启，下一次事件就是新值。
+            if (action === "setting") {
+              const key = String(body.key ?? "");
+              if (!SETTING_KEYS.includes(key)) {
+                return sendJson(response, 400, { ok: false, error: `不认识的开关：${key}` });
+              }
+              if (typeof body.value !== "boolean") {
+                return sendJson(response, 400, { ok: false, error: "开关的值只能是 true 或 false" });
+              }
+              store.patchSettings({ [key]: body.value });
+              if (cfg !== null && typeof cfg === "object") cfg[key] = body.value;
+              return sendJson(response, 200, { ok: true, settings: settingsSnapshot(cfg) });
+            }
+
+            // 面板上新建需求：**只产出草稿**，等 AI 沟通确认之后才算真需求。
+            if (action === "draft") {
+              const plan = store.readPlan(sessionId) ?? {
+                version: 3,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+                goals: [],
+              };
+              const requirement = addDraft(plan, {
+                title: body.title,
+                intro: body.intro,
+                detail: body.detail,
+              });
+              store.writePlan(sessionId, plan);
+              return sendJson(response, 200, { ok: true, id: requirement.id, ...afterWrite(plan) });
+            }
+
+            // 用户改需求正文：**只落暂定版本**，不动正在生效的正文（`docs/09` §3.3）。
+            // 点这个按钮**不叫醒 AI**——它下次被唤起时会先看到这条待确认。
+            if (action === "pending") {
+              const plan = store.readPlan(sessionId);
+              if (plan === null) return sendJson(response, 404, { ok: false, error: "这个会话还没有需求" });
+              const outcome = updateByUser(plan, String(body.id ?? ""), {
+                title: body.title,
+                intro: body.intro,
+                detail: body.detail,
+                change: body.change,
+              });
+              if (!outcome.ok) return sendJson(response, 200, { ok: false, error: outcome.reason });
+              store.writePlan(sessionId, plan);
+              return sendJson(response, 200, {
+                ok: true,
+                cancelled: outcome.cancelled === true,
+                message: outcome.cancelled === true ? "改回和当前版本一样了，暂定版本已撤掉。" : "已提交这个版本的改动，等 AI 确认。",
+                ...afterWrite(plan),
+              });
+            }
+
+            if (action === "archive" || action === "unarchive") {
+              const plan = store.readPlan(sessionId);
+              if (plan === null) return sendJson(response, 404, { ok: false, error: "这个会话还没有需求" });
+              const outcome = setArchived(plan, String(body.id ?? ""), action === "archive");
+              if (!outcome.ok) return sendJson(response, 200, { ok: false, error: outcome.reason });
+              store.writePlan(sessionId, plan);
+              return sendJson(response, 200, { ok: true, ...afterWrite(plan) });
+            }
+
+            // 点某条需求的「开始」：这是**能叫醒 AI 的三种动作之一**。
+            if (action === "start") {
+              const plan = store.readPlan(sessionId);
+              const requirement = plan === null ? null : requirementOf(plan, String(body.id ?? ""));
+              if (requirement === null) {
+                return sendJson(response, 200, { ok: false, error: "找不到这条需求" });
+              }
+              const outcome = pause?.nudge?.(
+                sessionId,
+                `开始做需求 ${requirement.id}「${requirement.title}」。` +
+                  "先用 tree_task_start 开始它（会折叠上一次折叠之后的过程，并给出这条需求的详情），再按计划往下推。",
+                "开始需求",
+              ) ?? { woke: false, reason: "unavailable", text: "插件没在运行，叫不醒会话。" };
+              return sendJson(response, 200, {
+                ok: true,
+                woke: outcome.woke === true,
+                message: outcome.text,
+                paused: pause?.isPaused?.(sessionId) === true,
+                stopped: autoContinue?.isStopped?.(sessionId) === true,
+              });
+            }
+
             if (action === "reset") {
               store.writePlan(sessionId, null);
               // 计划没了，游标也必须跟着清：游标里记的是"这一层总结到哪儿了"，
@@ -175,17 +347,26 @@ export function registerHttp(ctx, { store, autoContinue, pause = null }) {
               return sendJson(response, 200, { ok: true, active: null, checkpoint: null, results: null });
             }
 
-            if (action === "done" || action === "drop") {
+            if (action === "done" || action === "drop" || action === "delete") {
               const plan = store.readPlan(sessionId);
               if (plan === null) return sendJson(response, 404, { ok: false, error: "这个会话没有计划" });
               const id = String(body.id ?? "");
+              const found = requirementOf(plan, id) !== null;
               // 完成必须带结果：插件要用它替换掉这个节点的执行过程。
-              const outcome = action === "done" ? complete(plan, id, body.result) : dropNode(plan, id);
+              const outcome = found
+                ? action === "drop"
+                  ? dropRequirement(plan, id)
+                  : deleteRequirement(plan, id)
+                : action === "done"
+                  ? complete(plan, id, body.result)
+                  : action === "drop"
+                    ? dropNode(plan, id)
+                    : deleteNode(plan, id);
               if (!outcome.ok) return sendJson(response, 200, { ok: false, error: outcome.reason });
               store.writePlan(sessionId, plan);
               return sendJson(response, 200, {
                 ok: true,
-                events: outcome.events ?? outcome.dropped ?? [],
+                events: outcome.events ?? outcome.dropped ?? outcome.removed ?? [],
                 ...afterWrite(plan),
               });
             }
@@ -196,7 +377,7 @@ export function registerHttp(ctx, { store, autoContinue, pause = null }) {
         "dsh-tree-task-flow: action",
       );
 
-      ctx.logger?.info?.("dsh-tree-task-flow: 设置面板接口已挂载");
+      ctx.logger?.info?.("dsh-tree-task-flow: 插件配置页接口已挂载");
     }, "dsh-tree-task-flow: http");
   });
 }