dsh-tree-task-flow 0.3.7 → 0.3.9

package/README.md

@@ -27,15 +27,16 @@
 规则只有一条，**只看表层，与计划树无关**：
 
 ```
-从「上一次 tree_task_done 之后的第一个 create / plan」之后
+从「上一次 tree_task_done 之后的第一个 tree_task_create」之后
     →  到本次 tree_task_done 之前，这一段收走
 ```
 
-起点是上一次 `tree_task_done` 之后的**第一个** `tree_task_create` / `tree_task_plan`；
-会话里还没有过 `tree_task_done` 时，就是表层第一个 `create` / `plan`。
-**中间的 `create` / `plan` 不再是切点**——它们连同过程一起收走。
-起点那次调用自己的调用**与返回**留在上下文里，本次 `tree_task_done` 的调用与返回
-同样留着（模型靠它们看"这一步做什么、下一步干什么"）。
+起点是上一次 `tree_task_done` 之后的**第一个** `tree_task_create`；
+会话里还没有过 `tree_task_done` 时，就是表层第一个 `tree_task_create`；
+区间里一次 `tree_task_create` 都没有时，回退到上一次 `tree_task_done` 之后。
+**`tree_task_plan` 不是边界**——它的调用与返回跟普通过程一样，随这一段一起收走。
+起点那次 `create` 的调用与返回留在上下文里，本次 `tree_task_done` 的调用与返回
+同样留着（模型靠它们看"计划是什么、下一步干什么"）。
 折叠只收它们**之间**的过程，换成一条计数通告：
 
 ```
@@ -89,7 +90,7 @@ tree_task消息：接下来需要进行步骤：「步骤二」(s-4)。
 
 两样都**不重复提交内容**（`result` 就在这次调用的参数里）。折叠时，**这次
 `tree_task_done` 的调用连同它的返回原样留在上下文里**，被收走的只是它**前面**那段过程
-——那一段里若夹着别的 `create` / `plan` 调用，它们也一并收走。
+——那一段里若夹着 `tree_task_plan` 调用，它也跟着一起收走。
 
 **子任务全部结束，不会让父节点自动完成。** 那一刻树进入**检查点**，
 也就是上表第二种返回。
@@ -116,7 +117,7 @@ tree_task消息：接下来需要进行步骤：「步骤二」(s-4)。
 | 层 | 是什么 | 怎么算分对了 |
 |---|---|---|
 | **L1 目标** | 最终要交付的东西 | 一个会话可以有多个，按创建顺序排；每个都写清要交付什么 |
-| **L2 任务** | **交付节点** | 一件能独立验收的交付物（一个文件、一条能跑的命令、一份结论）；下面覆盖多个步骤，别拆到只剩一两个 |
+| **L2 任务** | **交付节点** | 一件能独立验收的交付内容——一个文件、一条能跑的命令、一份结论，也可以是件需要完成或验证的事、一个检查点；下面覆盖多个步骤，别拆到只剩一两个 |
 | **L3 子任务** | **步骤** | 任务内部一两次工具调用能做完的事 |
 
 **折叠次数跟着 `tree_task_done` 的次数走**：每完成一个节点就折一次，界面也会因此多一张
@@ -288,8 +289,8 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
    空 `result` 会被拒绝。所以要写清"产出了什么"，写成能独立看懂的样子——
    过程会丢，别把过程写进去。
 
-2. **折叠只看表层。** 起点是上一次 `done` 之后的第一个 `create` / `plan`，
-   中间的 `create` / `plan` 不再是切点，会连同过程一起收走；区间里没有过程时
+2. **折叠只看表层。** 起点是上一次 `done` 之后的第一个 `create`；
+   `tree_task_plan` 不是边界，它的调用与返回跟过程一样会被收走；区间里没有过程时
    什么都不注入，夹着你的消息时整段不折——那一段原样留着（往前折丢需求、
    往后折丢回应），代价是上下文不收缩。
 

package/lib/prompt.js

@@ -23,7 +23,7 @@ export const SECTION_NAME = "dsh-tree-task-flow";
 export const DEFAULT_ORDER = 1800;
 
 /** 段落正文。 */
-export const SECTION_TEXT = "`tree_task_*` 工具适用长线任务，当目标和资料分析完成后，如果用户要求或判断任务较为复杂，可以将任务执行计划分为目标、任务交付节点、任务执行步骤三级写入任务树，借助工具来推进项目；完成步骤或任务时提交后续步骤需要的 result，内容可以是：产物/结论/问题/有哪些需要注意的坑。";
+export const SECTION_TEXT = "`tree_task_*` 工具适用长线任务，当目标和资料分析完成后，如果用户要求或判断任务较为复杂，可以将任务执行计划分为目标、任务、任务执行步骤三级写入任务树，借助工具来推进项目；将目标按照可独立交付的节点分为多个任务，任务节点需要准确表述清楚需求；将任务按照“需一次性处理并交付产物”分为多个步骤；完成步骤或任务时提交后续步骤需要的 result，提交内容可以是：产物/结论/问题/有哪些需要注意的坑；执行过程上下文将会在完成时被隐藏。";
 
 /**
  * 注册段落。调用方必须包在 `ctx.effect()` 里，否则热更新后会重复注册而抛错。

package/lib/region.js

@@ -3,14 +3,16 @@
  *
  * 规则只有一条，**只看表层，与计划树无关**：
  *
- *     从「上一次 `tree_task_done` 之后的第一个 `create` / `plan`」之后，
+ *     从「上一次 `tree_task_done` 之后的第一个 `tree_task_create`」之后，
  *     到本次 `tree_task_done` 之前，中间那一段过程收走。
  *
- * 更早没有 `tree_task_done` 时，起点取表层第一个 `create` / `plan`；区间里一次
- * `create` / `plan` 都没有时，回退到上一次 `tree_task_done` 之后（更早没有 `done`
- * 则是表层开头）。起点那次调用、以及本次 `done` 的调用与返回，都留在表层上——
- * 那是模型看"计划是什么、下一步干什么"的地方；被跨过的其它 `create` / `plan`
- * 连同过程一起收走。
+ * 更早没有 `tree_task_done` 时，起点取表层第一个 `tree_task_create`；区间里一次
+ * `create` 都没有时，回退到上一次 `tree_task_done` 之后（更早没有 `done` 则是
+ * 表层开头）。起点那次调用、以及本次 `done` 的调用与返回，都留在表层上——
+ * 那是模型看"计划是什么、下一步干什么"的地方。
+ *
+ * 边界只有 `create` 与 `done` 两个：**`tree_task_plan` 不是边界**，它的调用与返回
+ * 跟普通过程一样，落在区间里就被收走。
  *
  * 判定表见 `docs/06-折叠范围规则.md`。
  *
@@ -28,8 +30,8 @@
  *     [tree_task_done 调用]    [返回：接下来需要进行步骤：「二」(s-4)。]
  *     [当前这一段执行过程]     ← 下一次折叠的对象
  *
- * 这一段过程里原本还有一次 `tree_task_plan` 的调用与返回——它夹在 create 与 done 之间，
- * 不是起点，于是随这一条通告一起收走了。
+ * 这一段过程里还夹着一次 `tree_task_plan` 的调用与返回——它不是边界，
+ * 于是随这一条通告一起收走了。
  *
  * 时机是 `agent/pre-step`：上一轮已结束、下一个请求还没构造。工具执行中途不能折叠
  * ——那一刻 surface 还在增长，替换会把自己卷进去。
@@ -45,8 +47,11 @@ const PLUGIN = "dsh-tree-task-flow";
 /** 三层固定的名字。只给界面用的游标同步按这个顺序走。 */
 const LEVELS = ["goal", "task", "step"];
 
-/** 边界调用：这三个工具的调用与返回都不进替换区间，它们是折叠的起止点。 */
-const BOUNDARY_TOOLS = new Set(["tree_task_create", "tree_task_plan", "tree_task_done"]);
+/**
+ * 边界调用：只有 `tree_task_create` 与 `tree_task_done`。它们的调用与返回不进替换区间，
+ * 是折叠的起止点。**`tree_task_plan` 不在其中**——它跟别的过程一样，落在区间里就被收走。
+ */
+const BOUNDARY_TOOLS = new Set(["tree_task_create", "tree_task_done"]);
 
 /** 注入消息的抬头。 */
 const NOTICE_PREFIX = "tree_task消息：";
@@ -189,10 +194,9 @@ function summaryLine(count, files) {
   return touched === 0 ? base : `${base} · 涉及 ${touched} 个文件`;
 }
 
-/** 这条 assistant 消息里有没有 `tree_task_create` / `tree_task_plan`。 */
-function isPlanCall(event) {
-  const names = toolNamesOf(event);
-  return names.includes("tree_task_create") || names.includes("tree_task_plan");
+/** 这条 assistant 消息里有没有 `tree_task_create`。 */
+function isCreateCall(event) {
+  return toolNamesOf(event).includes("tree_task_create");
 }
 
 /**
@@ -200,10 +204,10 @@ function isPlanCall(event) {
  *
  * 从末尾往前找最近的一次边界调用，**它必须是 `tree_task_done`**（它就是这次完成的
  * 那一下）；再往前找上一次 `tree_task_done`，起点就是**它之后最早的那次
- * `create` / `plan`**——更早没有 `done` 时，起点是表层第一个 `create` / `plan`。
- * 中间的 `create` / `plan` 不是切点：它们连同过程一起被收走。
+ * `tree_task_create`**——更早没有 `done` 时，起点是表层第一个 `tree_task_create`。
+ * `tree_task_plan` 不是边界：它跟过程、工具结果一样落在区间里被收走。
  *
- * 区间里一次 `create` / `plan` 都没有时，起点退回上一次 `done` 之后（更早没有 `done`
+ * 区间里一次 `create` 都没有时，起点退回上一次 `done` 之后（更早没有 `done`
  * 则是表层第一个节点之后）——那时区间多半会撞上真人消息，于是整段不折，这是安全的那一侧。
  *
  * @param session - 当前会话。
@@ -233,15 +237,15 @@ export function foldRange(session) {
     }
   }
 
-  // 起点：上一次 done 之后最早的那次 create / plan。
+  // 起点：上一次 done 之后最早的那次 create。
   let startIdx = -1;
   for (let index = prevDoneIdx + 1; index < endIdx; index += 1) {
-    if (isPlanCall(session.eventAt(nodes[index]))) {
+    if (isCreateCall(session.eventAt(nodes[index]))) {
       startIdx = index;
       break;
     }
   }
-  // 区间里没有 create / plan：退回上一次 done 之后（更早没有 done 就是表层开头）。
+  // 区间里没有 create：退回上一次 done 之后（更早没有 done 就是表层开头）。
   if (startIdx === -1) startIdx = prevDoneIdx;
 
   // 区间从起点调用的 `tool/result` 之后开始；找不到起点（-1）就退回表层第一个节点之后

package/lib/tools.js

@@ -78,9 +78,10 @@ export function registerTools(ctx, { store, cfg }) {
   ctx.tools.register({
     name: "tree_task_create",
     description:
-      "新增一个目标：这个目标 + 它下面的若干任务。目标是要交付的东西，一个会话可以有多个目标，" +
+      "新增一个目标：这个目标 + 它下面的若干任务。一个会话可以有多个目标，" +
       "按调用顺序排在计划里——已经建过的目标和它们的历史都留着，不会被这次调用替换掉。" +
-      "这里的任务是交付节点——一件能独立验收的交付物，不是步骤本身。" +
+      "这里的任务是交付节点——一件能独立验收的交付内容，可以是需要完成或验证的某件事，" +
+      "也可以是一个检查点，不是步骤本身。" +
       "建完记得用 tree_task_plan 给这个目标下的第一个任务拆子任务。",
     parameters: {
       type: "object",
@@ -133,10 +134,8 @@ export function registerTools(ctx, { store, cfg }) {
     name: "tree_task_plan",
     description:
       "给一个节点追加子节点：给目标追加任务，给任务追加子任务。" +
-      "给任务追加的是步骤（一两次工具调用能做完的事），别把任务拆到只剩一两个步骤。" +
-      "子任务是最低一级，不能再往下拆。" +
-      "子任务全部结束后父节点不会自动完成：插件会接着告诉你这一层的结果够不够，" +
-      "够了就用 tree_task_done 提交，不够再补步骤。",
+      "给任务追加的是步骤（需要一次性做完的事情）。" +
+      "子任务是最低一级，不能再往下拆。",
     parameters: {
       type: "object",
       additionalProperties: false,
@@ -182,10 +181,8 @@ export function registerTools(ctx, { store, cfg }) {
       "完成一个节点并提交它的结果（目标 / 任务 / 子任务都给它的 id）。**必须写 result**：" +
       "插件会把这个节点从开始到现在的执行过程从上下文里折叠掉，换成一条只携带这段结果的汇总消息。" +
       "任务的 result 写交付物与验收方式（文件在哪、怎么跑、验出什么、已知限制）；" +
-      "子任务的 result 一句话说清这步做了什么就够。" +
-      "子任务全部结束后父节点不会自动完成：插件会在返回里告诉你这一层的结果够不够，" +
-      "够就用它自己的 id 再调一次。" +
-      "返回内容就是下一步该干什么；这次调用与它的返回都留在上下文里，被收起的只是它前面的执行过程。",
+      "子任务的 result 一句话说清这步做了什么、结果如何就够。" +
+      "这次调用与它的返回都会留在上下文里，被收起的只是它前面的执行过程。",
     parameters: {
       type: "object",
       additionalProperties: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tree-task-flow",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "树形任务流：把多步任务组织成目标→任务→子任务三级树，节点完成时由 AI 提交结果，插件随即把该节点的执行过程从上下文里折叠掉，只留下结果。",
   "type": "module",
   "main": "lib/index.js",