dsh-tree-task-flow 0.3.12 → 0.3.13

package/lib/plan.js

@@ -7,8 +7,10 @@
  * **谁是"当前节点"是推导出来的，不是存的**（`activePath`）——
  * 少一个需要同步的状态，就少一类 bug。
  *
- * 一个节点完成时必须提交 `result`（这个节点产出了什么）。插件据此把
- * 它的执行过程从上下文里折叠掉，换成一条携带该结果的汇总消息。
+ * 一个节点完成时必须提交 `result`（这个节点产出了什么）。它提交在这次
+ * `tree_task_done` 调用的参数里，而那次调用是折叠边界、不会被收走，所以
+ * 结果**留得住**；插件收走的是它前面那段执行过程。树渲染里也会把结果原样
+ * 列出来（**不截断**），让 `tree_task_status` 随时能把交付内容重新摆到眼前。
  *
  * **子节点全部结束时，父节点不自动完成。** 那一刻转入**检查点**：
  * 模型要么继续给父节点拆新的子节点，要么提交父节点的结果并完成它。
@@ -460,54 +462,118 @@ function checkpointNote(checkpoint) {
   );
 }
 
-/** 节点状态的中文短标记。 */
+/**
+ * 节点状态的短标记。
+ *
+ * 写成 `[ ]` / `[x]` 是**故意的**：整棵树用 Markdown 的嵌套任务清单渲染，
+ * 这两个标记在界面上会render成可以勾选的方框。`[-]` 不是标准任务清单标记，
+ * 会原样显示成 `[-]`——丢弃的节点本来就该看着"不是个正常的框"。
+ */
 function mark(node) {
   if (node.status === STATUS.DONE) return "[x]";
   if (node.status === STATUS.DROPPED) return "[-]";
   return "[ ]";
 }
 
-/** 结果取首行，超长截断——树上只报"产出了什么"，全文在上下文里的汇总消息里。 */
-function firstLine(text, limit = 120) {
-  const line = String(text ?? "").split("\n")[0].trim();
-  return line.length > limit ? `${line.slice(0, limit)}…` : line;
+/** 每一层的缩进宽度：两个空格，Markdown 嵌套列表的常规写法。 */
+const INDENT = "  ";
+
+/**
+ * 一个节点的「说明 / 结果」字段，作为该列表项的下一层条目挂进去。
+ *
+ * **全文输出，一个字都不截。** `result` 是这个节点交付的全部文字，截掉半句
+ * 就等于没交付。多行文本逐行输出；空行也要带上缩进，否则 Markdown 会认为
+ * 列表项到此为止，后面的内容会被甩出列表。
+ *
+ * @param lines - 输出行数组，就地追加。
+ * @param ownerIndent - 所属节点那一行的缩进层数。
+ * @param label - 「说明」或「结果」。
+ * @param text - 正文；空值不输出。
+ */
+function pushField(lines, ownerIndent, label, text) {
+  const rows = String(text ?? "")
+    .replace(/\r\n?/gu, "\n")
+    .split("\n");
+  while (rows.length > 0 && rows[rows.length - 1].trim() === "") rows.pop();
+  if (rows.length === 0) return;
+
+  const pad = INDENT.repeat(ownerIndent + 1);
+  lines.push(`${pad}- **${label}**：${rows[0]}`);
+  for (const row of rows.slice(1)) {
+    lines.push(row === "" ? pad : `${pad}${INDENT}${row}`);
+  }
 }
 
 /**
- * 把整棵树渲染成给模型看的文本。
+ * 渲染一个目标。
  *
- * @param plan - 计划树；null 表示还没有计划。
- * @returns 多行文本。
+ * 输出是**规范的 Markdown 嵌套任务清单**（`- [ ]` 一层两个空格），复制出去
+ * 就能正常预览——之前的写法靠纯空格缩进，四空格起就被 Markdown 当成代码块。
+ *
+ * @param goal - 目标节点。
+ * @param plan - 整棵计划树，用来标出"当前"落在哪。
+ * @param expand - `false` 时只渲染目标自己这一级（不含它下面的任务与子任务）。
+ * @returns 多行 Markdown 文本。
  */
-export function renderTree(plan) {
-  const goals = goalsOf(plan);
-  if (goals.length === 0) return "（还没有计划。先用 tree_task_create 建立目标与任务。）";
+export function renderGoal(goal, plan, expand = true) {
   const active = activePath(plan);
   const checkpoint = checkpointOf(plan);
   const lines = [];
 
-  for (const goal of goals) {
-    lines.push(`${mark(goal)} 目标  ${goal.id}  ${goal.title}`);
-    if (goal.detail) lines.push(`       ${goal.detail}`);
-    if (goal.result) lines.push(`       结果: ${firstLine(goal.result.text)}`);
-
-    for (const task of goal.tasks ?? []) {
-      const taskHere = active?.task?.id === task.id || checkpoint?.node?.id === task.id;
-      lines.push(`  ${mark(task)} 任务  ${task.id}  ${task.title}${taskHere ? " ← 当前" : ""}`);
-      if (task.result) lines.push(`        结果: ${firstLine(task.result.text)}`);
-      const steps = task.steps ?? [];
-      if (steps.length === 0 && isOpen(task)) {
-        lines.push("        （还没有子节点 → 调用 tree_task_plan）");
-      }
-      for (const step of steps) {
-        lines.push(`    ${mark(step)} 子任务  ${step.id}  ${step.title}${active?.step?.id === step.id ? " ← 当前" : ""}`);
-        if (step.result) lines.push(`          结果: ${firstLine(step.result.text)}`);
-      }
+  const goalHere = active?.goal?.id === goal.id;
+  lines.push(`- ${mark(goal)} **目标** \`${goal.id}\` ${goal.title}${goalHere ? " ← 当前" : ""}`);
+  pushField(lines, 0, "说明", goal.detail);
+  pushField(lines, 0, "结果", goal.result?.text);
+  if (expand !== true) return lines.join("\n");
+
+  for (const task of goal.tasks ?? []) {
+    const taskHere = active?.task?.id === task.id || checkpoint?.node?.id === task.id;
+    lines.push(
+      `${INDENT}- ${mark(task)} **任务** \`${task.id}\` ${task.title}${taskHere ? " ← 当前" : ""}`,
+    );
+    pushField(lines, 1, "结果", task.result?.text);
+
+    const steps = task.steps ?? [];
+    if (steps.length === 0 && isOpen(task)) {
+      lines.push(`${INDENT.repeat(2)}- 还没有子节点，用 tree_task_plan 补上`);
+    }
+    for (const step of steps) {
+      const stepHere = active?.step?.id === step.id;
+      lines.push(
+        `${INDENT.repeat(2)}- ${mark(step)} **子任务** \`${step.id}\` ${step.title}${stepHere ? " ← 当前" : ""}`,
+      );
+      pushField(lines, 2, "结果", step.result?.text);
     }
   }
   return lines.join("\n");
 }
 
+/**
+ * 渲染计划树。
+ *
+ * 默认把**已经结束的目标**收成目标那一级：一个会话跑久了会有好几个做完的目标，
+ * 每个都摊开会把树变成一大坨没人看的文字。要某个目标的完整树就指名它。
+ *
+ * @param plan - 计划树；null 表示还没有计划。
+ * @param only - 只渲染这个 id 所在的目标，并展开到底；不传就是全部目标。
+ * @returns 多行 Markdown 文本。
+ */
+export function renderTree(plan, only = null) {
+  const goals = goalsOf(plan);
+  if (goals.length === 0) return "（还没有计划。用 tree_task_create 建立目标与任务。）";
+
+  const wanted = typeof only === "string" && only.trim() !== "" ? only.trim() : null;
+  if (wanted !== null) {
+    const found = findNode(plan, wanted);
+    if (found === null) {
+      return `找不到节点 ${wanted}。不带 id 调用可以看到本会话的全部目标。`;
+    }
+    return renderGoal(found.goal, plan, true);
+  }
+
+  return goals.map((goal) => renderGoal(goal, plan, isOpen(goal))).join("\n");
+}
+
 /**
  * 注入消息里的收尾提示。它接在完成通告后面，所以自带前置标点（`lead`）。
  *

package/lib/region.js

@@ -3,16 +3,21 @@
  *
  * 规则只有一条，**只看表层，与计划树无关**：
  *
- *     从「上一次 `tree_task_done` 之后的第一个 `tree_task_create`」之后，
+ *     从「上一次 `tree_task_done` 之后的第一条 `tree_task_create` 调用」之后，
  *     到本次 `tree_task_done` 之前，中间那一段过程收走。
  *
- * 更早没有 `tree_task_done` 时，起点取表层第一个 `tree_task_create`；区间里一次
+ * 更早没有 `tree_task_done` 时，起点取表层第一条 `tree_task_create`；区间里一次
  * `create` 都没有时，回退到上一次 `tree_task_done` 之后（更早没有 `done` 则是
  * 表层开头）。起点那次调用、以及本次 `done` 的调用与返回，都留在表层上——
  * 那是模型看"计划是什么、下一步干什么"的地方。
  *
- * 边界只有 `create` 与 `done` 两个：**`tree_task_plan` 不是边界**，它的调用与返回
- * 跟普通过程一样，落在区间里就被收走。
+ * 边界只有 `create` 与 `done` 两个：写树的 `tree_task_plan` **不是边界**，
+ * 它跟普通过程一样落在区间里就被收走。
+ *
+ * **为什么不能把 `create` 并进 `plan`**：起点取的是"上一次 done 之后最早的
+ * 那一次开工调用"，而 `plan` 每补一次步骤就调一次；并成一个工具之后，
+ * 每一次补步骤都会把起点往后推，`done` 与它之间那段过程就永远收不走。
+ * 靠"实参里有没有 `parentId`"去区分，也只是把认错起点的机会交给模型。
  *
  * 判定表见 `docs/06-折叠范围规则.md`。
  *
@@ -25,7 +30,7 @@
  *
  *     [节点 0] 系统提示词
  *     [用户消息]
- *     [tree_task_create 调用]  [返回：计划已建立 + 整棵树]
+ *     [tree_task_create 调用]  [返回：计划已建立 + 这个目标的树]
  *     [tree_task消息：隐藏了 12 条过程上下文。读取：… 写入：…]
  *     [tree_task_done 调用]    [返回：接下来需要进行步骤：「二」(s-4)。]
  *     [当前这一段执行过程]     ← 下一次折叠的对象
@@ -62,17 +67,52 @@ export const PLUGIN = "dsh-tree-task-flow";
  */
 export const PLUGIN_SOURCE_KIND = `plugin:${PLUGIN}`;
 
+/**
+ * 界面上那一行摘要的统一前缀。
+ *
+ * 折叠、压缩、恢复续行、计划续行、中断拉起、中断重试——本插件往会话里放的通知不止一种，
+ * 界面上都是一行摘要。**前缀只在这里加一次**：调用点写自己的裸标签
+ * （「恢复续行」「中断拉起」），谁都别再手写它，否则迟早有一条漏掉或者写成两遍。
+ */
+export const SUMMARY_PREFIX = "树形任务流 · ";
+
+/**
+ * 给一个裸标签配上统一前缀，得到界面上真正显示的那一行。
+ *
+ * @param label - 裸标签，例如「恢复续行」。
+ * @returns 带前缀的摘要文本。
+ */
+export function noticeSummary(label) {
+  return `${SUMMARY_PREFIX}${label}`;
+}
+
+/**
+ * 这条 source 的摘要是不是某个标签。
+ *
+ * **带不带前缀都认**：升级之前落在会话里的那几条摘要没有前缀，
+ * 而按摘要做匹配的地方（收走失败尝试时找那条拉起消息）得能认出它们。
+ *
+ * @param source - 消息的 source。
+ * @param label - 裸标签。
+ * @returns 命中为 true。
+ */
+export function hasSummary(source, label) {
+  if (typeof source?.summary !== "string") return false;
+  return source.summary === label || source.summary === noticeSummary(label);
+}
+
 /**
  * 本插件一条 notice 消息的 source。
  *
  * 字段与老写法保持一致：`form: "notice"` 让界面渲染成可展开的一行说明，
- * `summary` 是那一行的文字。
+ * `summary` 是那一行的文字。**摘要一律走 {@link noticeSummary} 加前缀**——
+ * 界面上那一行必须自己说清是哪个插件发的，不能只写「恢复续行」。
  *
- * @param summary - 界面上显示的一行摘要。
+ * @param label - 界面上显示的那一行（不含前缀）。
  * @returns 消息 source。
  */
-export function pluginSource(summary) {
-  return { kind: PLUGIN_SOURCE_KIND, form: "notice", summary };
+export function pluginSource(label) {
+  return { kind: PLUGIN_SOURCE_KIND, form: "notice", summary: noticeSummary(label) };
 }
 
 /**
@@ -96,7 +136,7 @@ export function isPluginSource(source) {
 const LEVELS = ["goal", "task", "step"];
 
 /**
- * 边界调用：只有 `tree_task_create` 与 `tree_task_done`。它们的调用与返回不进替换区间，
+ * 边界调用：`tree_task_create` 与 `tree_task_done`。它们的调用与返回不进替换区间，
  * 是折叠的起止点。**`tree_task_plan` 不在其中**——它跟别的过程一样，落在区间里就被收走。
  */
 const BOUNDARY_TOOLS = new Set(["tree_task_create", "tree_task_done"]);
@@ -228,7 +268,7 @@ function renderSummary(count, files) {
 }
 
 /**
- * 汇总消息的一行摘要，给界面折叠标题用。
+ * 汇总消息的一行摘要（**不含统一前缀**——前缀由 `pluginSource` 加）。
  *
  * @param count - 被这次替换收走的节点条数。
  * @param files - `touchedFiles()` 的结果。
@@ -236,11 +276,22 @@ function renderSummary(count, files) {
  */
 function summaryLine(count, files) {
   const touched = files.read.length + files.write.length;
-  const base = `树形任务流 · 隐藏了${count}条过程上下文`;
+  const base = `隐藏了${count}条过程上下文`;
   return touched === 0 ? base : `${base} · 涉及 ${touched} 个文件`;
 }
 
-/** 这条 assistant 消息里有没有 `tree_task_create`。 */
+/**
+ * 这条 assistant 消息里有没有**新建目标**的那次 `tree_task_create`。
+ *
+ * 折叠起点只认这一种调用。**不能拿 `tree_task_plan` 顶替**：`plan` 在任务中途
+ * 反复调用（每补一次步骤就调一次），而起点取的是"上一次 done 之后最早的那次"，
+ * 于是每一次补步骤都会把起点往后推，`done` 与它之间那段过程永远收不走。
+ * 靠实参里有没有 `parentId` 去区分也只是把"认错起点"的机会交给了模型——
+ * 专门一个工具、按名字认，才是可靠的。
+ *
+ * @param event - 表层上的事件。
+ * @returns 是否新建了目标。
+ */
 function isCreateCall(event) {
   return toolNamesOf(event).includes("tree_task_create");
 }
@@ -250,8 +301,7 @@ function isCreateCall(event) {
  *
  * 从末尾往前找最近的一次边界调用，**它必须是 `tree_task_done`**（它就是这次完成的
  * 那一下）；再往前找上一次 `tree_task_done`，起点就是**它之后最早的那次
- * `tree_task_create`**——更早没有 `done` 时，起点是表层第一个 `tree_task_create`。
- * `tree_task_plan` 不是边界：它跟过程、工具结果一样落在区间里被收走。
+ * `tree_task_create`**——更早没有 `done` 时，起点是表层第一条 `tree_task_create`。
  *
  * 区间里一次 `create` 都没有时，起点退回上一次 `done` 之后（更早没有 `done`
  * 则是表层第一个节点之后）——那时区间多半会撞上真人消息，于是整段不折，这是安全的那一侧。

package/lib/store.js

@@ -6,6 +6,7 @@
  *   - `plans/<sessionId>.json`     计划树
  *   - `surfaces/<sessionId>.json`  三层的折叠游标（只给界面看，不参与折叠）
  *   - `held/<sessionId>.json`      「被按住」：暂停 / 停止，**要跨重启保留**
+ *   - `revive/<sessionId>.json`    意外中断的拉起重试链，**要跨重启保留**
  *
  * 计划属于建立它的那个会话。放到会话无关的位置，任何一个会话的计划都会被
  * 所有会话的 `agent/pre-step` 读到——那等于把不相干的节点指派塞进别人的上下文，
@@ -85,6 +86,9 @@ export function createStore(root) {
   /** 「被按住」状态的文件路径。 */
   const heldFile = (sessionId) => file("held", `${sessionId}.json`);
 
+  /** 意外中断重试链的文件路径。 */
+  const reviveFile = (sessionId) => file("revive", `${sessionId}.json`);
+
   /** 读「被按住」状态；读不到或文件坏了，一律按"没被按住"处理。 */
   function readHeldState(sessionId) {
     if (!sessionId) return { paused: false, stopped: false, at: null };
@@ -216,5 +220,49 @@ export function createStore(root) {
       });
       return readHeldState(sessionId);
     },
+
+    // ---- 意外中断的拉起重试链：**要跨重启保留** ----
+
+    /**
+     * 读这个会话的重试链状态。
+     *
+     * 为什么不放内存：网络类中断的时刻表横跨 30 分钟，而这台机器上重启 dsh 是常事。
+     * 只留内存的话，重启一次这条链就断了，正好落在最需要它的场景上。
+     *
+     * @param sessionId - 会话 id。
+     * @returns `{ sessionId, turn, class, code, pending, attempts, hidden, updatedAt }`，
+     *   没有链时为 null。`class` 是 `network` / `tool` / `malformed` 之一。
+     */
+    readRevive(sessionId) {
+      if (!sessionId) return null;
+      const value = readJson(reviveFile(sessionId), null);
+      if (value === null || typeof value !== "object") return null;
+      return value;
+    },
+
+    /**
+     * 写重试链状态。
+     *
+     * @param sessionId - 会话 id。
+     * @param value - 完整状态；`null` 等同于 {@link clearRevive}。
+     */
+    writeRevive(sessionId, value) {
+      if (!sessionId) return;
+      if (value === null || typeof value !== "object") {
+        rmSync(reviveFile(sessionId), { force: true });
+        return;
+      }
+      writeJson(reviveFile(sessionId), { sessionId, ...value, updatedAt: Date.now() });
+    },
+
+    /**
+     * 丢掉这个会话的重试链。链正常结束（这一轮跑完了）或该停手时调用。
+     *
+     * @param sessionId - 会话 id。
+     */
+    clearRevive(sessionId) {
+      if (!sessionId) return;
+      rmSync(reviveFile(sessionId), { force: true });
+    },
   };
 }

package/lib/tools.js

@@ -1,6 +1,14 @@
 /**
  * 六个 `tree_task_*` 工具。
  *
+ * **写树分成两个工具，不是可以合并的重复。** `tree_task_create` 与 `tree_task_done`
+ * 是折叠区间的两个边界（见 `lib/region.js`）：`create` 是"开工"那一下，`done` 是
+ * "收工"那一下。`create` 只在新建目标时调用一次，`plan` 却在任务中途反复调用——
+ * 把两者并成一个工具，折叠起点就只能靠实参里有没有 `parentId` 去猜，
+ * 模型一次写漏或多写就会把起点挪走，那段过程就再也收不走了。
+ * 代价是两个工具的实参形状有点像（都是一串 `{title, detail}`），
+ * 所以 `plan` 的说明里专门写了一句"建新目标不归它管"。
+ *
  * 工具本身**只做状态读写**——不注入消息、不动 surface，也不拦任何别的工具。
  * 「完成时把这个节点的执行过程从上下文里折起来、换成一条携带它结果的汇总」
  * 那件事完全由 `agent/pre-step` 监听器负责（它比对游标与 `activePath` 就知道
@@ -24,7 +32,9 @@ import {
   createPlan,
   doneReply,
   dropNode,
+  findNode,
   renderContinue,
+  renderGoal,
   renderTree,
   updateNode,
 } from "./plan.js";
@@ -65,21 +75,35 @@ export function registerTools(ctx, { store, cfg }) {
   ctx.tools.register({
     name: "tree_task_status",
     description:
-      "查看当前计划树：目标、任务、子任务各自的状态与已提交的结果，以及现在该推进哪个节点。" +
-      "任务开头、上下文被压缩之后、或者不确定下一步做什么时，调用它。",
-    parameters: { type: "object", additionalProperties: false, properties: {} },
+      "查看计划树：目标、任务、子任务各自的状态与已提交的结果，以及现在该推进哪个节点。" +
+      "任务开头、上下文被压缩之后、或者不确定下一步做什么时，调用它。" +
+      "默认只展开还没结束的目标——已经做完的目标只留目标那一行，要看它的完整树就把 id 填上。",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string",
+          description:
+            "可选。填目标 id 就返回那个目标的完整树（已完成的目标默认不展开）；" +
+            "填任务或子任务 id，就按它所在的那个目标展开。",
+        },
+      },
+    },
     output: OUTPUT,
-    async execute(_args, exec) {
+    async execute(args, exec) {
       const plan = store.readPlan(sessionOf(exec));
-      return ok(renderTree(plan));
+      return ok(renderTree(plan, args?.id ?? null));
     },
   });
 
   ctx.tools.register({
     name: "tree_task_create",
     description:
-      "新增一个目标：这个目标 + 它下面的若干任务。一个会话可以有多个目标，" +
-      "按调用顺序排在计划里——已经建过的目标和它们的历史都留着，不会被这次调用替换掉。" +
+      "新建一个目标：这个目标 + 它下面的若干任务。**它是「开工」那一下**——" +
+      "折叠上下文时，插件就认这次调用作为「这一轮从哪儿开始」。" +
+      "一个会话可以有多个目标，按调用顺序排在计划里——已经建过的目标和它们的历史都留着，" +
+      "不会被这次调用替换掉。" +
       "这里的任务是交付节点——一件能独立验收的交付内容，可以是需要完成或验证的某件事，" +
       "也可以是一个检查点，不是步骤本身。" +
       "建完记得用 tree_task_plan 给这个目标下的第一个任务拆子任务。",
@@ -124,8 +148,14 @@ export function registerTools(ctx, { store, cfg }) {
       }
       store.writePlan(sessionId, plan);
       return ok(
-        `${existing === null ? "计划已建立。" : `已新增目标「${goal.title}」。`}\n\n${renderTree(plan)}\n\n` +
-          "下一步：调用 tree_task_plan 给这个目标下的第一个任务拆子任务。",
+        [
+          existing === null ? `计划已建立，目标「${goal.title}」。` : `已新增目标「${goal.title}」。`,
+          "",
+          renderGoal(goal, plan, true),
+          "",
+          "下一步：给这个目标下的第一个任务拆子任务——用 tree_task_plan，" +
+            "parentId 填那个任务的 id。",
+        ].join("\n"),
       );
     },
   });
@@ -135,7 +165,8 @@ export function registerTools(ctx, { store, cfg }) {
     description:
       "给一个节点追加子节点：给目标追加任务，给任务追加子任务。" +
       "给任务追加的是步骤（需要一次性做完的事情）。" +
-      "子任务是最低一级，不能再往下拆。",
+      "子任务是最低一级，不能再往下拆。" +
+      "**建新目标不归它管，那是 tree_task_create**——它只往已有的节点上接子节点。",
     parameters: {
       type: "object",
       additionalProperties: false,
@@ -164,12 +195,13 @@ export function registerTools(ctx, { store, cfg }) {
       const result = addChildren(plan, args?.parentId, args?.children);
       if (!result.ok) return ok(`没有添加：${result.reason}`);
       store.writePlan(sessionOf(exec), plan);
+      const found = findNode(plan, args?.parentId);
       return ok(
         [
           `已添加 ${result.added.length} 个${childLabel(result.level)}：`,
-          ...result.added.map((node) => `  ${node.id}  ${node.title}`),
+          ...result.added.map((node) => `- \`${node.id}\` ${node.title}`),
           "",
-          renderTree(plan),
+          renderGoal(found.goal, plan, true),
         ].join("\n"),
       );
     },
@@ -230,7 +262,8 @@ export function registerTools(ctx, { store, cfg }) {
       const result = updateNode(plan, args?.id, args ?? {});
       if (!result.ok) return ok(`没有修改：${result.reason}`);
       store.writePlan(sessionOf(exec), plan);
-      return ok(`已更新 ${result.changed.join(" / ")}。\n\n${renderTree(plan)}`);
+      const found = findNode(plan, args?.id);
+      return ok(`已更新 ${result.changed.join(" / ")}。\n\n${renderGoal(found.goal, plan, true)}`);
     },
   });
 
@@ -255,10 +288,15 @@ export function registerTools(ctx, { store, cfg }) {
       const result = dropNode(plan, args?.id);
       if (!result.ok) return ok(`没有丢弃：${result.reason}`);
       store.writePlan(sessionOf(exec), plan);
+      const found = findNode(plan, args?.id);
       return ok(
-        [`已丢弃：${result.dropped.join("、")}`, "", renderTree(plan), "", renderContinue(plan)].join(
-          "\n",
-        ),
+        [
+          `已丢弃：${result.dropped.join("、")}`,
+          "",
+          renderGoal(found.goal, plan, true),
+          "",
+          renderContinue(plan),
+        ].join("\n"),
       );
     },
   });

package/package.json

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