dsh-tree-task-flow 0.3.14 → 0.3.15

package/config.example.yml

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

package/cordis.patch.yml

@@ -12,16 +12,16 @@
 #    字段一次写全。可覆盖的字段见 DEFAULT_CONFIG：
 #
 #   enabled             总开关                  默认 true（写 false 关掉）
-#   autoContinue        是否允许自动续行        默认 false（设置面板里能改）
+#   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 设置面板**的导航里有一页叫「树形任务流」，点一下就行——**改完立刻生效、
-# 并且盖过这里写的值**（设置面板 > profile config > DEFAULT_CONFIG）。
+# **侧边栏「插件」页**里点开 `dsh-tree-task-flow` 这张卡，页面上就有这两个开关——
+# **改完立刻生效、并且盖过这里写的值**（插件页 > profile config > DEFAULT_CONFIG）。
 - insert:
     - id: task-tree
       name: 'dsh-tree-task-flow'

package/lib/commands.js

@@ -20,16 +20,26 @@ import {
   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 delete <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");
 
 /** 插件被配置关掉时唯一要说的话：现在是关的，以及怎么打开。 */
@@ -37,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` 一致。
  *
@@ -140,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") {
@@ -154,13 +183,14 @@ 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"),
         };
       }
 
@@ -170,23 +200,24 @@ export function registerCommands(ctx, { store, cfg, pause = null, enabled = fals
           return { kind: "error", text: `用法：/task-tree delete <节点 id>\n\n${USAGE}` };
         }
         const plan = store.readPlan(sessionId);
-        if (plan === null) return { kind: "error", text: "本会话还没有计划。" };
-        // 摘掉之后就查不到"这次删的是哪个目标"了，先记一份。
+        if (plan === null) return { kind: "error", text: "本会话还没有需求。" };
+        // 摘掉之后就查不到"这次动的是哪条需求"了，先记一份。
         const touched = findNode(plan, id);
-        const result = deleteNode(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(renderGoal(touched.goal, plan, true));
+          // 删的是任务或步骤：它所在的那条需求还在，只给它那条需求的列表。
+          lines.push(listText(plan));
         } else {
-          const restGoal = goalsOf(plan).length;
+          const left = goalsOf(plan).length;
           lines.push(
-            restGoal === 0
-              ? "计划树现在空了。"
-              : `这个会话还剩 ${restGoal} 个目标，要看全部用 /task-tree status。`,
+            left === 0
+              ? "这个会话现在没有需求了。"
+              : `这个会话还剩 ${left} 条需求，要看全部用 /task-tree status。`,
           );
         }
         return { kind: "success", text: lines.join("\n") };
@@ -197,14 +228,15 @@ export function registerCommands(ctx, { store, cfg, pause = null, enabled = fals
       }
 
       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

@@ -23,8 +23,23 @@
  * @module dsh-tree-task-flow/http
  */
 
-import { activePath, checkpointOf, complete, deleteNode, 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) {
@@ -47,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 {
@@ -81,23 +164,9 @@ 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);
 }
 
 /**
@@ -111,7 +180,7 @@ function afterWrite(plan) {
 export function registerHttp(ctx, { store, autoContinue, pause = null, cfg = null }) {
   ctx.inject(["webServer"], (host) => {
     host.effect(() => {
-      // 一棵树的全部信息：结构 + 每层结果 + 检查点 + 当前路径 + 三层折叠游标。
+      // 面板要的全部数据：需求两个列表 + 草稿区 + 当前进行中的展开 + 按住状态。
       host.webServer.register(
         {
           kind: "exact",
@@ -121,18 +190,11 @@ export function registerHttp(ctx, { store, autoContinue, pause = null, cfg = nul
             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),
@@ -142,8 +204,8 @@ export function registerHttp(ctx, { store, autoContinue, pause = null, cfg = nul
         "dsh-tree-task-flow: tree",
       );
 
-      // DSH 设置面板里那一页用的接口：**跟会话无关**，只回两个开关的当前值与总开关
-      // 状态。设置面板没有"当前会话"这个概念，所以它不能走 `/tree`。
+      // 插件管理里本插件那一页用的接口：**跟会话无关**，只回两个开关的当前值与总开关
+      // 状态。那一页不是某个会话的界面，没有"当前会话"这个概念，所以它不能走 `/tree`。
       host.webServer.register(
         {
           kind: "exact",
@@ -202,6 +264,75 @@ export function registerHttp(ctx, { store, autoContinue, pause = null, cfg = nul
               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);
               // 计划没了，游标也必须跟着清：游标里记的是"这一层总结到哪儿了"，
@@ -220,9 +351,13 @@ export function registerHttp(ctx, { store, autoContinue, pause = null, cfg = nul
               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"
+              const outcome = found
+                ? action === "drop"
+                  ? dropRequirement(plan, id)
+                  : deleteRequirement(plan, id)
+                : action === "done"
                   ? complete(plan, id, body.result)
                   : action === "drop"
                     ? dropNode(plan, id)
@@ -242,7 +377,7 @@ export function registerHttp(ctx, { store, autoContinue, pause = null, cfg = nul
         "dsh-tree-task-flow: action",
       );
 
-      ctx.logger?.info?.("dsh-tree-task-flow: 设置面板接口已挂载");
+      ctx.logger?.info?.("dsh-tree-task-flow: 插件配置页接口已挂载");
     }, "dsh-tree-task-flow: http");
   });
 }

package/lib/index.js

@@ -1,5 +1,5 @@
 /**
- * dsh-tree-task-flow —— 三级任务树：完成时提交结果，同时把执行过程折叠掉。
+ * dsh-tree-task-flow —— 三级任务树：完成[步骤/任务/需求]并折叠过程。
  *
  * 与 DSH 内置任务系统的差别在于**上下文的收放方式**：
  *