dsh-tree-task-flow 0.3.12 → 0.3.14

package/cordis.patch.yml

@@ -11,11 +11,17 @@
 # ⚠️ 同 id 的 config 是**整体替换**，不是逐字段深合并——覆盖时要把需要的
 #    字段一次写全。可覆盖的字段见 DEFAULT_CONFIG：
 #
-#   enabled            总开关                          默认 true（写 false 关掉）
-#   autoContinue       是否允许自动续行                默认 false（开着会让人停不下来）
-#   maxAutoRounds      连续自动续行轮次上限            默认 5
-#   promptOrder        工具说明段顺序                  默认 1800
-#   rootDir            插件状态目录                    默认 $DSH_HOME/dsh-task-tree
+#   enabled             总开关                  默认 true（写 false 关掉）
+#   autoContinue        是否允许自动续行        默认 false（设置面板里能改）
+#   maxAutoRounds       连续自动续行轮次上限    默认 5
+#   interruptRecovery   意外中断是否自动拉起    默认 true（设置面板里能改）
+#   interruptDelaysMs   网络类中断拉起时刻      默认 null（= 1/5/10/30 分钟）
+#   promptOrder         工具说明段顺序          默认 1800
+#   rootDir             插件状态目录            默认 $DSH_HOME/dsh-task-tree
+#
+# 两个布尔开关（autoContinue / interruptRecovery）平时不用在这里改：
+# **DSH 设置面板**的导航里有一页叫「树形任务流」，点一下就行——**改完立刻生效、
+# 并且盖过这里写的值**（设置面板 > profile config > DEFAULT_CONFIG）。
 - insert:
     - id: task-tree
       name: 'dsh-tree-task-flow'

package/lib/auto-continue.js

@@ -43,12 +43,43 @@ export function registerAutoContinue(ctx, { store, cfg }) {
     return stopped.has(sessionId) || store?.readHeld?.(sessionId)?.stopped === true;
   }
 
+  /**
+   * 用户按下停止：**从落盘的 `turn/end` 认，不能从 `agent/turn-stopping` 认。**
+   *
+   * `agent/turn-stopping` 只在"这一轮本来就要正常收尾"时才发——`dsh-agent-loop` 里
+   * 唯一一处 dispatch 在 `turn()` 的 try 里，紧挨着前面那句 `signal.throwIfAborted()`。
+   * 用户按停止会让信号 abort、从别处抛出，catch 里直接记下
+   * `turn/end reason.kind = "aborted"` 并重新抛出，那条 dispatch 根本走不到。
+   * 也就是说 `payload.signal.aborted` 在那里几乎永远是 `false`——拿它当闸门等于没闸门：
+   * 会话被停掉之后 `agent/status` 一转 `idle`，续行立刻又把它拉起来。
+   *
+   * 可靠的事实是**落盘的 `turn/end`**：中止一定会在 `finally` 里被记成
+   * `reason: { kind: "aborted", reason: { kind: "user" } }`（cause 为 `user` 就是人按的，
+   * 另有 `parent` / `hook` / `disposed`）。而且它发生在驱动循环 `setPhase(idle)`
+   * 之前——`agent/status` 是之后才发的，所以这个标记一定赶得上那次判断。
+   *
+   * 中止就是中止：不管是谁按的，插件都不该自作主张把这一轮重新拉起来。
+   */
+  ctx.on("session/event", (session, event) => {
+    if (event?.type !== "turn/end") return;
+    if (event.data?.reason?.kind !== "aborted") return;
+    const sessionId = session?.id;
+    if (sessionId === undefined) return;
+    stopped.add(sessionId);
+    // 落盘：重启后条目上仍看得到「继续」，也仍然压得住自动续行。
+    store?.patchHeld?.(sessionId, { stopped: true });
+  });
+
+  /**
+   * 次要路径，留着兜底：如果中止恰好发生在 `agent/turn-stopping` 的 dispatch 过程中
+   * （信号在那一刻才变 abort），上面那条 `turn/end` 判据同样会兜住它；这里只是让
+   * 标记更早一点落下。**不要把它当成主判据**，原因见上。
+   */
   ctx.on("agent/turn-stopping", (payload) => {
     const sessionId = payload?.agent?.session?.id;
     if (sessionId === undefined) return;
     if (payload?.signal?.aborted === true) {
       stopped.add(sessionId);
-      // 落盘：重启后条目上仍看得到「继续」，也仍然压得住自动续行。
       store?.patchHeld?.(sessionId, { stopped: true });
     }
   });

package/lib/commands.js

@@ -8,13 +8,25 @@
  * @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";
 
 /** 用法说明，status 和 help 都会带上。 */
 const USAGE = [
   "/task-tree                     查看本会话的任务树与检查点状态",
   "/task-tree done <id> <结果>     提交某个节点的结果并完成它",
-  "/task-tree drop <id>           丢弃某个节点",
+  "/task-tree drop <id>           丢弃某个节点：留着可查，标记为不做了",
+  "/task-tree delete <id>         删除某个节点：连子节点一起从树里摘掉，不看状态",
   "/task-tree pause               暂停：当前工具跑完后停住，不再往下推进",
   "/task-tree resume              继续：从停住的地方接着跑，不插消息",
   "/task-tree reset               清掉本会话的计划树",
@@ -59,8 +71,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) {
@@ -151,6 +164,34 @@ export function registerCommands(ctx, { store, cfg, pause = null, enabled = fals
         };
       }
 
+      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 result = 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(renderGoal(touched.goal, plan, true));
+        } else {
+          const restGoal = goalsOf(plan).length;
+          lines.push(
+            restGoal === 0
+              ? "计划树现在空了。"
+              : `这个会话还剩 ${restGoal} 个目标，要看全部用 /task-tree status。`,
+          );
+        }
+        return { kind: "success", text: lines.join("\n") };
+      }
+
       if (verb !== "status") {
         return { kind: "error", text: `不认识的子命令：${verb}\n\n${USAGE}` };
       }
@@ -161,7 +202,7 @@ export function registerCommands(ctx, { store, cfg, pause = null, enabled = fals
       if (enabled !== true) {
         lines.push("", DISABLED_NOTE);
       } else if (plan === null) {
-        lines.push("", "本会话还没有计划。用 tree_task_create 建立目标与任务。");
+        lines.push("", "本会话还没有计划。用 tree_task_plan 建立目标与任务。");
       } else {
         // 检查点优先于"当前节点"：那一刻要推进的不是某个子任务，
         // 而是"这一层到底做完了没有"这个判断。

package/lib/compaction.js

@@ -67,8 +67,8 @@ const NOTICE_TEXT =
   "tree_task消息：上下文刚被压缩过，计划树没有被压缩。用 tree_task_status 取回当前进度、" +
   "各节点已提交的 result，以及下一步该推进哪个节点。";
 
-/** 界面上的一行摘要。 */
-const NOTICE_LINE = "树形任务流 · 上下文被压缩，计划树仍在";
+/** 界面上的一行摘要（**不含统一前缀**——前缀由 `pluginSource` 加）。 */
+const NOTICE_LINE = "上下文被压缩，计划树仍在";
 
 /** 提示消息的编号，保证同一毫秒内连发两条也不撞 id。 */
 let noticeSeq = 0;

package/lib/http.js

@@ -14,6 +14,8 @@
  *   - **暂停状态**：条目上的暂停/继续按钮写的就是这个。暂停挂的是
  *     `agent/pre-step`（见 `pause.js`），不插消息、不改计划，所以它不属于计划树，
  *     单独回传。
+ *   - **设置**：面板上那两个开关（见 `settings.js`）。它跟会话无关，读的时候顺手带上，
+ *     改的时候写盘并**就地改活配置**，所以改完立刻生效，不用重启。
  *
  * 条目上的按钮都写计划树，所以写完要把**新的**活动路径、结果与检查点一并回传，
  * 免得条目还要再发一次请求才知道自己按出了什么效果。
@@ -21,7 +23,8 @@
  * @module dsh-tree-task-flow/http
  */
 
-import { activePath, checkpointOf, complete, dropNode, levelLabel } from "./plan.js";
+import { activePath, checkpointOf, complete, deleteNode, dropNode, levelLabel } from "./plan.js";
+import { SETTING_KEYS, settingsSnapshot } from "./settings.js";
 
 /** 统一的 JSON 响应。 */
 function sendJson(response, status, body) {
@@ -101,9 +104,11 @@ function afterWrite(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(() => {
       // 一棵树的全部信息：结构 + 每层结果 + 检查点 + 当前路径 + 三层折叠游标。
@@ -130,12 +135,31 @@ export function registerHttp(ctx, { store, autoContinue, pause = null }) {
               },
               stopped: autoContinue?.isStopped?.(sessionId) === true,
               paused: pause?.isPaused?.(sessionId) === true,
+              settings: settingsSnapshot(cfg),
             });
           },
         },
         "dsh-tree-task-flow: tree",
       );
 
+      // DSH 设置面板里那一页用的接口：**跟会话无关**，只回两个开关的当前值与总开关
+      // 状态。设置面板没有"当前会话"这个概念，所以它不能走 `/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 +185,23 @@ 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) });
+            }
+
             if (action === "reset") {
               store.writePlan(sessionId, null);
               // 计划没了，游标也必须跟着清：游标里记的是"这一层总结到哪儿了"，
@@ -175,17 +216,22 @@ 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 outcome = action === "done" ? complete(plan, id, body.result) : dropNode(plan, id);
+              const outcome =
+                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),
               });
             }

package/lib/index.js

@@ -21,9 +21,11 @@ import { registerAutoContinue } from "./auto-continue.js";
 import { registerCommands } from "./commands.js";
 import { registerCompactionNotice } from "./compaction.js";
 import { registerHttp } from "./http.js";
+import { registerInterruptRecovery } from "./interrupt.js";
 import { registerPause } from "./pause.js";
 import { DEFAULT_ORDER, registerPromptSection } from "./prompt.js";
 import { registerRegion } from "./region.js";
+import { pickSettings } from "./settings.js";
 import { createStore, defaultRoot } from "./store.js";
 import { registerTools } from "./tools.js";
 
@@ -54,13 +56,35 @@ export const DEFAULT_CONFIG = {
   /**
    * 是否允许在模型停下时自动续行。
    *
-   * ★ **默认关闭**。开着它意味着：用户按下停止、agent 回到 idle，
-   * 插件立刻又把它拉起来——会话就停不下来了。任务自动执行必须是**受控**的，
-   * 要开也得由用户显式打开。
+   * ★ **默认关闭。** 它会趁你没说话的时候**往会话里推一条消息**、把模型再叫起来跑一轮，
+   * 是最需要人知情的一项。
+   *
+   * 这里曾经写死过一条规矩："插件还没有配置界面，功能就不能默认关"——默认关等于这个
+   * 功能不存在，没人会去翻 YAML 把它打开。**那条规矩随着设置界面一起作废**：现在面板上
+   * 就能点开，默认值该按"会不会打扰人"来定，而不是按"能不能被发现"。
+   *
+   * 想打开：面板上的设置里点一下，或在 profile 里写 `autoContinue: true`。
    */
   autoContinue: false,
   /** 连续自动续行的轮次上限，达到就停。 */
   maxAutoRounds: 5,
+  /**
+   * 意外中断的自动拉起。
+   *
+   * ★ **默认开启**。它和 `autoContinue` 管的是两件事：`autoContinue` 是"模型自己
+   * 正常收尾了、但计划没做完"，本项是"模型根本没机会说完就断了"——网络断了、
+   * 模型 API 报错、或者进程在工具执行中途没了。后者不加干预就永远停在那儿。
+   *
+   * 用户按停止（`aborted`）永远不拉起；余额不足（`QUOTA`）也不拉（等再久也不会好）。
+   */
+  interruptRecovery: true,
+  /**
+   * 网络类中断的拉起时刻表，单位毫秒，相对中断那一刻。
+   *
+   * 默认 `[1 分钟, 5 分钟, 10 分钟, 30 分钟]`——四个**累计时刻**，不是递增间隔。
+   * 一条链只跑一遍；跑完还失败就停手，等真人发消息再允许重开。
+   */
+  interruptDelaysMs: null,
   /** 工具说明段落的排序。 */
   promptOrder: DEFAULT_ORDER,
   /** 状态目录；null 表示 $DSH_HOME/dsh-task-tree。 */
@@ -78,6 +102,13 @@ export function apply(ctx, config) {
   const root = cfg.rootDir ?? defaultRoot();
   const store = createStore(root);
 
+  // 面板上改过的开关盖在 profile 的 config 之上：**人在界面上的选择优先**。
+  // 不这么做的话，界面改完、profile 一改又被顶回去，人会以为开关坏了。
+  //
+  // `cfg` 是**活的对象**：面板改开关时就地改它，各模块拿的是同一个引用，
+  // 所以立刻生效，不用重启。这也是为什么各模块要按事件现读 `cfg`，不是开机读一次。
+  Object.assign(cfg, pickSettings(store.readSettings()));
+
   // 被显式关掉时，一个字节都不碰会话：不注册工具、不加提示词段落、不折叠上下文、
   // 不续行——只留一条命令，让人能确认"装了但被关掉了"以及怎么打开。
   if (cfg.enabled !== true) {
@@ -85,7 +116,7 @@ export function apply(ctx, config) {
     // 条目接口照挂：客户端条目与 enabled 无关，照样会来读。读不到计划它就返回
     // null，一个像素都不占；而既有的计划文件仍然能看到。
     // 只读插件自己的状态目录，不碰任何会话。
-    registerHttp(ctx, { store, autoContinue: null, pause: null });
+    registerHttp(ctx, { store, autoContinue: null, pause: null, cfg });
     ctx.logger?.warn?.(
       "dsh-tree-task-flow: 已按配置关闭（enabled=false）。要打开请在 profile 的 cordis.patch.yml 里把它设为 true。",
     );
@@ -115,11 +146,19 @@ export function apply(ctx, config) {
   // 下一次模型请求还没发出"那个岔口。它同时压住上面的自动续行兜底。
   const pause = registerPause(ctx, { store, autoContinue });
 
+  // 意外中断的拉起：网络类按 1/5/10/30 分钟各一次，工具类（结果未知的合成错误）
+  // 立刻一次，再失败就收走那一次尝试再来一次。它与 autoContinue 并存：
+  // 那边管"模型正常收尾但计划没做完"，这边管"模型没机会说完就断了"。
+  //
+  // ★ **无条件注册**：开关（`interruptRecovery`）在面板上随时可改，注册与否取决于
+  // 它就没法在运行中打开。真正的闸门放在模块内部——事件来了先问一句 `cfg`。
+  registerInterruptRecovery(ctx, { store, cfg, pause });
+
   // /task-tree 命令：查看与管理任务树，也是"暂停 / 继续"的开关。
   registerCommands(ctx, { store, cfg, pause, enabled: true });
 
-  // 任务树条目要用的 HTTP 接口。
-  registerHttp(ctx, { store, autoContinue, pause });
+  // 任务树条目要用的 HTTP 接口。`cfg` 传进去是为了让面板能读到并改掉那几个开关。
+  registerHttp(ctx, { store, autoContinue, pause, cfg });
 
   ctx.logger?.info?.(`dsh-tree-task-flow: 已启用（状态目录 ${root}）`);
 }