dsh-tree-task-flow 0.3.13 → 0.3.14

package/README.md

@@ -105,7 +105,7 @@ tree_task消息：接下来需要进行步骤：「步骤二」(s-4)。
 但插件**不会拦住任何工具**——"这一层到底做完了没有"由模型判断，插件既不替它定死，
 也不靠拒绝别的工具把它逼到墙角。
 
-## 六个工具
+## 七个工具
 
 **写树分两个工具，不是可以合并的重复。** `tree_task_create` 与 `tree_task_done` 是折叠的
 两个边界：`create` 是"开工"那一下，`done` 是"收工"那一下。`create` 只在新建目标时调一次，
@@ -118,7 +118,11 @@ tree_task消息：接下来需要进行步骤：「步骤二」(s-4)。
 | `tree_task_plan` | 给一个节点追加子节点：父节点是目标加的是任务，父节点是任务加的是子任务。**建新目标不归它管** |
 | `tree_task_done` | 完成一个节点并提交它的结果，**`result` 必填**；返回的就是"下一步干什么"，这次调用连同返回留在上下文里，被收走的只是它前面的执行过程 |
 | `tree_task_update` | 修改一个节点的标题或说明 |
-| `tree_task_drop` | 丢弃一个节点；丢弃目标会连同它下面的任务与子任务一起走，丢弃任务带上它的子任务 |
+| `tree_task_drop` | 丢弃一个节点：留个记号说「这件事不做了」，节点**留在树里**可查（划掉）。丢弃目标会连同它下面的任务与子任务一起走，丢弃任务带上它的子任务 |
+| `tree_task_delete` | **删除**一个节点：把它连同下面的任务或子任务从树里**摘掉**、不留痕，**不看状态**（已完成、已丢弃的都删得掉）。清理写错 / 建重 / 结果记错的内容用它 |
+
+**丢与删是两件事**：丢弃回答"这件事还要不要做"（历史留着），删除是"这条内容本身就是错的"
+（凭空摘掉）。一个节点做完之后再想让它消失，只能用删除。
 
 层级固定三级，子任务是最低一级，不能再往下拆。
 
@@ -217,7 +221,9 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
   当前节点的虚线圈会匀速转，已完成打勾、丢弃的划掉。
 - 节点标题**不缩略**：有多长写多长，多了自动换行。
 - 提交的结果**默认只占一行**，点一下摊开看全文。
-- 节点上可以直接完成、丢弃，不用敲命令。
+- 节点上可以直接完成、**丢弃**（划掉，历史留着）、**删除**（垃圾桶，连子节点一起摘掉），
+  不用敲命令。删除对**任何状态**的节点都开着——已完成的那个也在，清理错内容正是它的用途。
+- 进度只数**还在做的事**：被丢弃的节点分子分母都不算，所以丢过几个之后进度照样能满。
 - 数据每 4 秒自动拉一次，模型在后台改计划时界面会自己跟上。
 
 **没有计划的会话一个像素都不占**——读不到计划就返回 `null`，不会平白挤掉内置的
@@ -233,7 +239,8 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 |---|---|
 | `/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` | 清掉本会话的计划树 |
@@ -245,13 +252,34 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 | 字段 | 默认 | 说明 |
 |---|---|---|
 | `enabled` | `true` | 总开关；**装上即启用**，写 `false` 关掉 |
-| `autoContinue` | `true` | 模型停下时是否自动续行（见下节） |
+| `autoContinue` | `false` | 模型停下时是否自动续行（见下节；**在 DSH 设置面板里能改**） |
 | `maxAutoRounds` | `5` | 连续自动续行的轮次上限 |
-| `interruptRecovery` | `true` | 意外中断后是否自动拉起（见下节） |
+| `interruptRecovery` | `true` | 意外中断后是否自动拉起（见下节；**在 DSH 设置面板里能改**） |
 | `interruptDelaysMs` | `null` | 网络类中断的拉起时刻，`null` = 1/5/10/30 分钟 |
 | `promptOrder` | `1800` | 工具说明段落的排序 |
 | `rootDir` | `null` | 状态目录，默认 `$DSH_HOME/dsh-task-tree` |
 
+## 设置
+
+设置**在 DSH 自己的设置面板里**：打开侧边栏的设置，导航里有一页叫「树形任务流」
+（跟「通用」「市场」并排），点开就是这两个开关。**改完立刻生效，不用重启。**
+
+> 它不在任务条上。任务条只干两件事：看进度、按暂停 / 继续；偏好属于设置，就该待在设置里。
+
+| 设置 | 默认 | 做什么 |
+|---|---|---|
+| 自动续行 | **关** | 模型自己停下、计划树还没跑完时，要不要推一条"接下来做 X"把它唤醒 |
+| 工具出错自动拉起 | 开 | 这一轮不是正常结束（网络断了 / 模型输出坏了 / 工具结果没了）时，要不要自动重来 |
+
+两项是**两件事**，别混：前者是"要不要往前推"，后者是"要不要救"。默认这么定是因为
+自动续行会在你没看着的时候自己往下跑，该由人来点；而中断拉起只在"这一轮根本不是正常
+结束"时动手，正常停下它一步都不动。
+
+设置写在状态目录的 `settings.json` 里（**不按会话分**，整个插件一份），重启后还在。
+优先级是 **设置面板里改过的 > profile 里的 config > `DEFAULT_CONFIG`**：在面板里点过就以
+面板为准，免得界面对不上 YAML。`enabled`、`maxAutoRounds`、`interruptDelaysMs` 这类
+"装插件时就该定好"的项不在面板上，仍然只认 profile 配置。
+
 ## 意外中断自动拉起
 
 上一节 `autoContinue` 管的是"模型自己正常停下"。这一节管的是**这一轮没能正常
@@ -287,6 +315,8 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
   自己改道，本来也没中断这一轮。
 - 只在**这个会话的计划树还没走完**时才动手。等待时刻写在状态目录的 `revive/` 下，
   重启 `dsh web` 不会丢。
+- **能在设置面板里关掉。** DSH 设置里的「树形任务流」那一页中，"工具出错自动拉起"就是
+  这个开关，改完立刻生效（关掉之后插件连 `revive/` 都不再写）。
 
 ## 暂停与继续
 
@@ -300,10 +330,23 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 接着请求，同样**零新增消息**。任务树的进度停在哪儿，就从哪儿接着跑。
 
 **重启 `dsh web` 之后暂停依然有效。** "被按住"这件事写在状态目录的 `held/` 下，
-重启后条目仍显示「已暂停」，点「继续」即可接着跑。区别只有一处：进程重启过之后，
-没有挂在岔口上的那一口气可放，插件只能给会话排一条「恢复续行」的消息把它从 `idle`
-推起来——**只有跨过重启的这一次恢复会留下这条消息**。若那个会话还没被打开（DSH 还没把它
-加载成实时 agent），点继续会提示你先打开它，并且**保留暂停状态**，不会白丢。
+重启后条目仍显示「已暂停」，点「继续」即可接着跑。
+
+**点「继续」是无条件的。** 不管此刻闸门有没有挂在岔口上、会话是不是正忙，点一下，
+"被按住"就当场解除——它是一句"接着跑"，不是一次"此刻有没有闸门"的查询。区别只在
+插件接下来能做什么：
+
+- **闸门正挂在岔口上** → 直接放行那一步，**零新增消息**；
+- **没有岔口可放**（进程重启过，或者你点的时候那个工具还在跑）→ 退一步给会话排一条
+  「恢复续行」的消息把它从 `idle` 推起来；会话正忙的话连推都不用推，它自己会在下一个
+  岔口接着跑；
+- **那个会话还没被 DSH 加载成实时 agent** → 提示你先打开它或在其中发一条消息，
+  但"被按住"照样解除。
+
+> 早先不是这样："继续"只在闸门恰好挂着的那一瞬间才算数；没有闸门可放时又要求会话
+> 正好停在 `idle`，忙就**直接拒绝、并且什么都不清**。于是"工具还在跑的时候点的那一下"
+> 被静默吞掉，等闸门真挂上时已经没人在等它——会话就停在原地了。真回归见
+> `verify-pause.mjs` 的场景 s-31。
 
 闸门开在 agent 的 `agent/pre-step` 上——一个 step 走完、工具结果都已落盘、模型还没
 发起下一次请求的那一刻。这是唯一同时满足"不打断工具"和"不留痕迹"的位置：再晚一点
@@ -320,8 +363,8 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 **模型自己停下、计划树却没跑完，插件就推一条"接下来要做 X"把它唤醒。** 这只是**兜底**：
 `tree_task_done` 的返回文本里已经带了"请继续执行下一个子任务"，模型通常会在同一轮里接着做。
 
-`autoContinue` **默认开启**。一条总规矩：**插件还没有配置界面，功能就不能默认关**——
-默认关等于这个功能不存在，没人会去翻 YAML 把它打开。等哪天真做了配置界面，再交给用户去配。
+`autoContinue` **默认关闭**——它会自己往下跑，所以默认由人来点。要开就在 DSH 设置面板的
+「树形任务流」那一页里打开（**改完立刻生效**，不用重启），或者在 profile 里写 `autoContinue: true`。
 
 开着也不会脱缰，有四道闸门：
 
@@ -344,7 +387,7 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 
 ## 状态文件
 
-全部在 `$DSH_HOME/dsh-task-tree/` 下，**以 `sessionId` 为键**：
+全部在 `$DSH_HOME/dsh-task-tree/` 下。除 `settings.json` 外都**以 `sessionId` 为键**：
 
 | 文件 | 内容 |
 |---|---|
@@ -352,6 +395,7 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 | `surfaces/<sessionId>.json` | 三层的进度游标 `{ key, cursor }`（只给界面看，不参与折叠） |
 | `held/<sessionId>.json` | 暂停 / 停止状态（跨重启保留） |
 | `revive/<sessionId>.json` | 意外中断的拉起时刻表（跨重启保留） |
+| `settings.json` | 设置面板里改过的设置（**整个插件一份，不按会话分**） |
 
 > 目录名沿用插件改名前的标识，为的是不让既有的计划文件失联；插件名与它无关。
 
@@ -384,6 +428,7 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 
 5. **改需求用「丢弃 + 追加」，不要重建整棵树。** 丢掉的节点留在树里可查，
    它和完成的节点会一起被那一段折叠收走（通告只报条数，不区分完成还是丢弃）。
+   **内容写错了才用删除**——删除是摘掉，摘掉的东西查不回来，也没有任何通告替它留痕。
 
 6. **暂停不留痕迹。** 暂停后模型看到的是"没有下一条请求"，看不到任何"你被暂停了"
    之类的提示；继续之后也不会有"继续"消息进上下文。想让模型知道中间发生过什么，
@@ -400,7 +445,7 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 | 不做 | 原因 |
 |---|---|
 | 资料 / 文件快照 / 记忆 | 上下文里值得留下的只有结果，其余靠模型自己重读 |
-| 文件回退 / 撤销 | 改需求用「丢弃 + 追加」 |
+| 文件回退 / 撤销 | 改需求用「丢弃 + 追加」；内容本身写错了才用删除摘掉，摘掉就找不回来 |
 | 并行推进多个目标 | 结构上支持一个会话有多个目标（目标层就是兄弟列表），但同一时刻只沿一条活动路径走 |
 | 把计划内容注入提示词 | 计划状态由 `tree_task_status` 现取，提示词里只放不随计划变化的说明 |
 

package/client.js

@@ -173,14 +173,23 @@ window.__ModuleLoader__.load({
 			}
 		}
 
-		/** 三层节点总数与已完成数，给单行条上的进度用。 */
+		/**
+		 * 三层节点总数与已完成数，给单行条上的进度用。
+		 *
+		 * **丢弃的节点两边都不算。** 丢弃是"这件事我不做了"，它不该压着进度——
+		 * 早先 total 无条件 +1、done 只认 `done`，于是丢一个节点进度就永远差一格，
+		 * 满不了。丢弃的证据在树里（划掉那一行），不需要分数再替它记一笔。
+		 */
 		function countNodes(goal) {
+			if (goal.status === "dropped") return { total: 0, done: 0 };
 			let total = 1;
 			let done = goal.status === "done" ? 1 : 0;
 			for (const task of goal.tasks || []) {
+				if (task.status === "dropped") continue;
 				total += 1;
 				if (task.status === "done") done += 1;
 				for (const step of task.steps || []) {
+					if (step.status === "dropped") continue;
 					total += 1;
 					if (step.status === "done") done += 1;
 				}
@@ -261,10 +270,21 @@ window.__ModuleLoader__.load({
 			"action.collapse": "收起",
 			"action.done": "完成…",
 			"action.drop": "丢弃",
+			"action.delete": "删除",
 			"action.submit": "提交结果",
 			"action.expandResult": "展开看全文",
 			"action.collapseResult": "收起",
 			"action.cancel": "取消",
+			"settings.nav": "树形任务流",
+			"settings.loading": "正在读设置…",
+			"settings.unavailable": "读不到设置：宿主那一半没在跑，或者接口不通。",
+			"settings.off": "插件在 profile 配置里被关掉了（enabled: false），这两个开关现在不起作用。",
+			"setting.note": "改完立刻生效，也会写进状态目录，重启 dsh web 之后还在。",
+			"setting.autoContinue": "任务没做完、模型自己停下时，自动把它叫起来接着跑",
+			"setting.autoContinueNote": "会往会话里推一条消息。默认关。",
+			"setting.interruptRecovery": "工具出错或网络断了，自动重试把会话拉起来",
+			"setting.interruptRecoveryNote":
+				"按 1 / 5 / 10 / 30 分钟各拉一次，一直拉不起来就停手。你按过停止的绝不拉起。",
 			"label.result": "结果",
 			"label.noResult": "（还没提交结果）",
 			"label.current": "当前",
@@ -274,7 +294,9 @@ window.__ModuleLoader__.load({
 				"写清这个节点产出了什么。它整段执行过程会被这条结果顶替，所以要能独立看懂。",
 			"hint.noChildren": "（还没有子节点 → 让模型调用 tree_task_plan）",
 			"confirm.reset": "确定要清空这个会话的计划树吗？",
-			"confirm.drop": "确定要丢弃「{title}」吗？",
+			"confirm.drop": "确定要丢弃「{title}」吗？丢弃会把它标成「不做了」，节点留在树里可查。",
+			"confirm.delete":
+				"确定要删除「{title}」吗？它会连同下面的任务或子任务一起从树里消失，找不回来；已经提交的结果也会一起没掉。如果只是「这件事不做了」，请改用丢弃。",
 		};
 
 		const en = {
@@ -294,10 +316,21 @@ window.__ModuleLoader__.load({
 			"action.collapse": "Collapse",
 			"action.done": "Complete…",
 			"action.drop": "Drop",
+			"action.delete": "Delete",
 			"action.submit": "Submit result",
 			"action.expandResult": "Show the full result",
 			"action.collapseResult": "Collapse",
 			"action.cancel": "Cancel",
+			"settings.nav": "Task tree",
+			"settings.loading": "Reading settings…",
+			"settings.unavailable": "Settings are unreachable: the host half is not running, or the endpoint is blocked.",
+			"settings.off": "The plugin is switched off in the profile config (enabled: false), so these switches do nothing right now.",
+			"setting.note": "Takes effect right away and is written to the state directory, so it survives a restart.",
+			"setting.autoContinue": "When the plan is unfinished and the model stops, wake it up to carry on",
+			"setting.autoContinueNote": "This pushes a message into the session. Off by default.",
+			"setting.interruptRecovery": "After a tool error or a dropped connection, retry to get the session going",
+			"setting.interruptRecoveryNote":
+				"Retries at 1 / 5 / 10 / 30 minutes, then gives up. A session you stopped is never revived.",
 			"label.result": "Result",
 			"label.noResult": "(no result submitted yet)",
 			"label.current": "current",
@@ -307,7 +340,9 @@ window.__ModuleLoader__.load({
 				"State what this node produced. Its whole execution range is replaced by this result, so it must stand on its own.",
 			"hint.noChildren": "(no children yet → ask the model to call tree_task_plan)",
 			"confirm.reset": "Clear this session's plan tree?",
-			"confirm.drop": "Drop “{title}”?",
+			"confirm.drop": "Drop “{title}”? It is marked as not-to-do and stays in the tree.",
+			"confirm.delete":
+				"Delete “{title}”? It disappears from the tree together with its tasks or steps, and any submitted result goes with it. If you only mean “not doing this”, use Drop instead.",
 		};
 
 		// ---------------------------------------------------------------- 样式
@@ -393,6 +428,18 @@ window.__ModuleLoader__.load({
 			".dsh-ttf-btn:disabled:hover{background:var(--dsw-alias-bg-base)}",
 			".dsh-ttf-error{color:var(--dsw-alias-state-error-primary,#c00);font-size:12px;line-height:18px;white-space:pre-wrap}",
 			".dsh-ttf-hint{padding:4px 4px 6px 24px;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}",
+			// 设置：两行开关，跟树共用同一张卡片。
+			".dsh-ttf-settingsPage{display:flex;flex-direction:column;gap:10px;padding:4px 2px;max-width:640px}",
+			".dsh-ttf-settings{display:flex;flex-direction:column;gap:8px;padding:4px 4px 8px}",
+			".dsh-ttf-setting{display:flex;align-items:flex-start;gap:8px}",
+			".dsh-ttf-switch{box-sizing:border-box;flex:none;position:relative;width:32px;height:18px;margin-top:1px;padding:0;border:.5px solid var(--dsw-alias-border-l4);border-radius:999px;background:var(--dsw-alias-bg-module-platform);cursor:pointer}",
+			".dsh-ttf-switch:disabled{opacity:.4;cursor:default}",
+			".dsh-ttf-switchOn{border-color:var(--dsw-alias-state-business-primary,#4d6bfe);background:var(--dsw-alias-state-business-primary,#4d6bfe)}",
+			".dsh-ttf-switchKnob{position:absolute;top:1px;left:1px;width:14px;height:14px;border-radius:999px;background:#fff;transition:left .12s}",
+			".dsh-ttf-switchOn .dsh-ttf-switchKnob{left:15px}",
+			".dsh-ttf-settingText{display:flex;flex-direction:column;gap:2px;min-width:0}",
+			".dsh-ttf-settingName{color:var(--dsw-alias-label-primary);font-size:12px;line-height:18px}",
+			".dsh-ttf-settingNote{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}",
 		].join("");
 
 		if (
@@ -505,7 +552,7 @@ window.__ModuleLoader__.load({
 		 * 一个节点：一行标题 + 可展开的详情。
 		 *
 		 * 三层共用同一个组件——它们的字段与动作本来就一样，差别只有缩进，
-		 * 以及"这一层要不要给丢弃按钮"（目标、任务、子任务都能丢）。
+		 * 以及"这一层要不要给丢弃与删除按钮"（目标、任务、子任务都能丢、都能删）。
 		 */
 		function NodeRow({ node, depth, activeIds, openIds, checkpointId, canDrop, sessionId, reload, t }) {
 			const children = node.tasks || node.steps || [];
@@ -574,7 +621,9 @@ window.__ModuleLoader__.load({
 							: null,
 						canAct && canDrop
 							? h(IconButton, {
-									iconBase: "IconTrashOutline",
+									// 划掉 = 留个记号说"这件事不做了"，和树里已丢弃节点的 × 标记是同一个意思。
+									// 垃圾桶留给真正的删除（见下一个按钮）。
+									iconBase: "IconCloseOutline",
 									label: t("action.drop"),
 									disabled: busy,
 									onClick: () => {
@@ -584,6 +633,20 @@ window.__ModuleLoader__.load({
 									},
 								})
 							: null,
+						// 删除对**任何状态**都开着：它就是用来清理写错/建重的内容的，
+						// 已完成的节点恰恰是最需要清掉的那种（结果记错了）。
+						canDrop
+							? h(IconButton, {
+									iconBase: "IconTrashOutline",
+									label: t("action.delete"),
+									disabled: busy,
+									onClick: () => {
+										if (window.confirm(t("confirm.delete", { title: node.title }))) {
+											act({ action: "delete", id: node.id });
+										}
+									},
+								})
+							: null,
 						expandable
 							? h(IconButton, {
 									iconBase: open ? "IconChevronDownOutline" : "IconChevronRightOutline",
@@ -650,6 +713,121 @@ window.__ModuleLoader__.load({
 
 		// ---------------------------------------------------------------- 条目
 
+		/**
+		 * 设置里能改的开关。
+		 *
+		 * 键必须与 `lib/settings.js` 的 `SETTING_KEYS` **一模一样**：对不上时接口会
+		 * 400 拒掉，而界面只会安静地什么都没发生，最难查。自检里有一条断言把两份
+		 * 名单对起来（`verify-settings.mjs`）。
+		 *
+		 * 文案名就按 `setting.<键>` 拼，另配一条 `setting.<键>Note` 讲清楚它到底会做什么。
+		 */
+		const SETTING_ROWS = [
+			{ key: "autoContinue", note: "setting.autoContinueNote" },
+			{ key: "interruptRecovery", note: "setting.interruptRecoveryNote" },
+		];
+
+		/**
+		 * 设置面板里的那一页：两个开关。
+		 *
+		 * ★ 这一页挂在 **DSH 自己的设置面板**里（`settings.section` 槽），不在插件的
+		 * 任务条上。任务条是"看进度、按暂停"的地方；偏好属于设置，就该待在设置里。
+		 *
+		 * 数据走宿主那两个**与会话无关**的接口：读 `/dsh-tree-task-flow/settings`，
+		 * 写 `action: "setting"`。跟任务条不同，这里没有要盯的东西，所以不轮询：
+		 * 挂载时读一次，改完拿返回值就地更新。
+		 */
+		function TaskTreeSettings() {
+			const t = useT();
+			const [state, setState] = useState({ loading: true, data: null });
+			const [busy, setBusy] = useState(false);
+			const [note, setNote] = useState("");
+
+			useEffect(() => {
+				let alive = true;
+				(async () => {
+					try {
+						const data = await api("/dsh-tree-task-flow/settings");
+						if (alive) setState({ loading: false, data });
+					} catch {
+						// 读不到就说读不到，别画一排骗人的开关。
+						if (alive) setState({ loading: false, data: null });
+					}
+				})();
+				return () => {
+					alive = false;
+				};
+			}, []);
+
+			if (state.loading) {
+				return h("div", { className: "dsh-ttf-settingsPage" }, h("div", { className: "dsh-ttf-settingNote" }, t("settings.loading")));
+			}
+			if (!state.data) {
+				return h(
+					"div",
+					{ className: "dsh-ttf-settingsPage" },
+					h("div", { className: "dsh-ttf-settingNote" }, t("settings.unavailable")),
+				);
+			}
+
+			const settings = state.data.settings ?? {};
+
+			async function toggle(key, value) {
+				setBusy(true);
+				setNote("");
+				try {
+					const result = await post({ action: "setting", key, value });
+					if (result && result.settings) {
+						setState({ loading: false, data: Object.assign({}, state.data, { settings: result.settings }) });
+					}
+				} catch (failure) {
+					setNote(String((failure && failure.message) || failure));
+				} finally {
+					setBusy(false);
+				}
+			}
+
+			return h(
+				"div",
+				{ className: "dsh-ttf-settingsPage" },
+				h("div", { className: "dsh-ttf-settingNote" }, t("setting.note")),
+				state.data.enabled === false
+					? h("div", { className: "dsh-ttf-note" }, t("settings.off"))
+					: null,
+				h(
+					"div",
+					{ className: "dsh-ttf-settings" },
+					SETTING_ROWS.map((row) => {
+						const on = settings[row.key] === true;
+						return h(
+							"div",
+							{ className: "dsh-ttf-setting", key: row.key },
+							h(
+								"button",
+								{
+									type: "button",
+									role: "switch",
+									"aria-checked": on,
+									"aria-label": t("setting." + row.key),
+									className: "dsh-ttf-switch" + (on ? " dsh-ttf-switchOn" : ""),
+									disabled: busy,
+									onClick: () => toggle(row.key, !on),
+								},
+								h("span", { className: "dsh-ttf-switchKnob" }),
+							),
+							h(
+								"div",
+								{ className: "dsh-ttf-settingText" },
+								h("span", { className: "dsh-ttf-settingName" }, t("setting." + row.key)),
+								h("span", { className: "dsh-ttf-settingNote" }, t(row.note)),
+							),
+						);
+					}),
+				),
+				note ? h("div", { className: "dsh-ttf-note" }, note) : null,
+			);
+		}
+
 		/**
 		 * 输入框上方的全宽条目。
 		 *
@@ -762,11 +940,15 @@ window.__ModuleLoader__.load({
 						h("span", { className: "dsh-ttf-glyph", "aria-hidden": true }, listGlyph),
 						h("span", { className: "dsh-ttf-label" + (held ? " dsh-ttf-labelHeld" : "") }, stateLabel),
 						h("span", { className: "dsh-ttf-title", title: heading }, heading),
-						h(
-							"span",
-							{ className: "dsh-ttf-progress" },
-							stats.done + "/" + stats.total + (current ? " · " + current : ""),
-						),
+						// 一个都算不上（整棵树都被丢弃了）就不报分数：0/0 比不显示更让人费解。
+						// 有 open 节点时 total 一定 ≥ 1，所以这里不会把"当前节点"那截弄丢。
+						stats.total > 0
+							? h(
+									"span",
+									{ className: "dsh-ttf-progress" },
+									stats.done + "/" + stats.total + (current ? " · " + current : ""),
+								)
+							: null,
 						h(
 							"div",
 							{ className: "dsh-ttf-actions" },
@@ -855,6 +1037,26 @@ window.__ModuleLoader__.load({
 					),
 				"dsh-tree-task-flow: conversation dock",
 			);
+
+			// 设置面板里的那一页。用 `settings.section` 这个**列表槽**，所以它会作为
+			// 一行出现在 DSH 设置面板的导航里（跟「通用」「市场」并排），点开就是
+			// 那两个开关。槽没被组合出来时（比如没有设置面板的宿主）这里什么都不发生。
+			ctx.effect(
+				() =>
+					ctx.slots.inject("settings.section", () =>
+						ctx.slots.register(
+							{
+								name: "settings.section",
+								id: ENTRY_ID,
+								order: 60,
+								label: () => translate("settings.nav"),
+								locale: NS,
+							},
+							TaskTreeSettings,
+						),
+					),
+				"dsh-tree-task-flow: settings section",
+			);
 		}
 
 		exports.name = name;

package/config.example.yml

@@ -1,6 +1,11 @@
 # 这个文件只是示例，插件不需要它——**安装即启用**，装完就能用。
 #
-# **默认值一律是"开"。** 插件还没有配置界面，功能默认关等于这个功能不存在。
+# **两个开关平时不用改这里。** 打开 DSH 的设置面板，导航里「树形任务流」那一页点一下
+# 就行——那是活的，改完立刻生效，而且**盖过这里写的值**。优先级是：
+#
+#     设置面板里改过的  >  profile 里的 config  >  DEFAULT_CONFIG
+#
+# 这里留给"连设置面板也不想点"的场合（比如要一次性写进 profile 发给别人）。
 # 想改成默认以外的东西时，把下面这段抄进 profile 自己的 cordis.patch.yml
 # （通常是 $DSH_HOME/profiles/<名字>/cordis.patch.yml）：
 #
@@ -16,14 +21,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 设置面板**的导航里有一页叫「树形任务流」，点一下就行——**改完立刻生效、
+# 并且盖过这里写的值**（设置面板 > profile config > DEFAULT_CONFIG）。
 - insert:
     - id: task-tree
       name: 'dsh-tree-task-flow'

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}` };
       }

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

@@ -25,6 +25,7 @@ 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";
 
@@ -55,17 +56,16 @@ export const DEFAULT_CONFIG = {
   /**
    * 是否允许在模型停下时自动续行。
    *
-   * ★ **默认开启**。一条总规矩：**插件还没有配置界面，功能就不能默认关**——
-   * 默认关等于这个功能不存在，没人会去翻 YAML 把它打开。等哪天真做了配置界面，
-   * 再交给用户去配。
+   * ★ **默认关闭。** 它会趁你没说话的时候**往会话里推一条消息**、把模型再叫起来跑一轮，
+   * 是最需要人知情的一项。
    *
-   * 曾经担心"开着就停不下来"（用户按下停止、agent 回到 idle，插件立刻又把它拉起来）。
-   * **那个担心已经有闸门挡住了**：按停止会写 `held/<sessionId>.json` 的
-   * `stopped: true`（见 `auto-continue.js` 的 `agent/turn-stopping`），
-   * `agent/status` 一回 idle 就先看这个标记，是就一步都不动；真人再发一条消息才解除。
-   * 再加上 `maxAutoRounds` 的轮次上限，兜底不会变成脱缰。
+   * 这里曾经写死过一条规矩："插件还没有配置界面，功能就不能默认关"——默认关等于这个
+   * 功能不存在，没人会去翻 YAML 把它打开。**那条规矩随着设置界面一起作废**：现在面板上
+   * 就能点开，默认值该按"会不会打扰人"来定，而不是按"能不能被发现"。
+   *
+   * 想打开：面板上的设置里点一下，或在 profile 里写 `autoContinue: true`。
    */
-  autoContinue: true,
+  autoContinue: false,
   /** 连续自动续行的轮次上限，达到就停。 */
   maxAutoRounds: 5,
   /**
@@ -102,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) {
@@ -109,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。",
     );
@@ -142,15 +149,16 @@ export function apply(ctx, config) {
   // 意外中断的拉起：网络类按 1/5/10/30 分钟各一次，工具类（结果未知的合成错误）
   // 立刻一次，再失败就收走那一次尝试再来一次。它与 autoContinue 并存：
   // 那边管"模型正常收尾但计划没做完"，这边管"模型没机会说完就断了"。
-  if (cfg.interruptRecovery === true) {
-    registerInterruptRecovery(ctx, { store, cfg, pause });
-  }
+  //
+  // ★ **无条件注册**：开关（`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}）`);
 }

package/lib/interrupt.js

@@ -198,6 +198,20 @@ export function registerInterruptRecovery(ctx, { store, cfg, pause = null }) {
     return active !== null && active.step !== null;
   }
 
+  /**
+   * 开关关着时整个模块都不动。
+   *
+   * 它是**面板上随时可改**的，所以每次事件现读 `cfg`，不能开机读一次就定死；
+   * 注册与否也不该取决于它（见 `lib/index.js` 里那句"无条件注册"）。
+   *
+   * 判据写成"**显式 false 才算关**"：这一项的默认值是开，缺字段的意思是"没配，
+   * 按默认走"，不该被当成关掉——直接构造这个模块的调用方（自检、以后别的入口）
+   * 往往只给一个 `{}`。
+   */
+  function off() {
+    return cfg?.interruptRecovery === false;
+  }
+
   /** 现在能不能拉：暂停 / 停止 / 没计划 / 没加载 / 不空闲，一条不满足就不拉。 */
   function blockedBy(sessionId) {
     if (pause?.isPaused?.(sessionId) === true) return "paused";
@@ -220,6 +234,7 @@ export function registerInterruptRecovery(ctx, { store, cfg, pause = null }) {
    * @returns `{ ok, reason?, text? }`。
    */
   function revive(sessionId, kind, code) {
+    if (off()) return { ok: false, reason: "disabled" };
     const blocked = blockedBy(sessionId);
     if (blocked !== null) return { ok: false, reason: blocked };
 
@@ -253,6 +268,7 @@ export function registerInterruptRecovery(ctx, { store, cfg, pause = null }) {
    * 一个不剩就把这条链标成用完。
    */
   function scheduleNext(sessionId) {
+    if (off()) return;
     clearTimer(sessionId);
     const state = store.readRevive(sessionId);
     if (state === null || state.class !== "network") return;
@@ -447,6 +463,7 @@ export function registerInterruptRecovery(ctx, { store, cfg, pause = null }) {
   // ---------------------------------------------------------------- 会话事件
 
   ctx.on("session/event", (session, event) => {
+    if (off()) return;
     const sessionId = session?.id;
     if (sessionId === undefined || event === undefined) return;
 
@@ -495,6 +512,7 @@ export function registerInterruptRecovery(ctx, { store, cfg, pause = null }) {
   // ---------------------------------------------------------------- agent 状态
 
   ctx.on("agent/status", (payload) => {
+    if (off()) return;
     const sessionId = payload?.agent?.session?.id;
     if (sessionId === undefined || payload?.status !== "idle") return;
 

package/lib/pause.js

@@ -35,6 +35,20 @@
  * 唤醒要求该会话已被 DSH 加载成实时 agent（Web 界面打开这个会话就会触发按需
  * resume）。拿不到 agent 时不做任何事，只回一句"先打开它，或在其中发一条消息"。
  *
+ * ★ **点「继续」是无条件的。** "接着跑"是人的意思表示，不是"此刻有没有闸门挂着"
+ * 的一次查询。所以 `resume()` 的第一件事永远是**解除「被按住」**，然后才谈要不要
+ * 主动唤醒。
+ *
+ * 旧实现把这层意思押在了"此刻 `waiters` 里正好挂着一个"上：没有 waiter 就退到
+ * `wakeIdle()`，而它要求 agent 恰好 `idle`——会话正忙（工具还在跑、这一轮还没走到
+ * 岔口）时直接拒绝，并且**一个标记都不清**。于是那一次点击被静默吞掉：闸门在下一个
+ * 岔口照旧挂上，会话停住，人却以为自己已经点过了。实机就卡在这儿：
+ * session-c516e2cc 23:05:59 点了暂停，那个工具 23:07:03 才跑完，中间点的那次
+ * 「继续」白点了——等到闸门真挂上时，已经没人在等那一下点击。
+ *
+ * 唤醒失败也不再反过来把状态留下：留着只会让"我点过了它却还按着我"再来一次。
+ * 推不起来的原因照样如实回报（没加载 / 唤醒抛错 / 计划已收尾），人能据它决定下一步。
+ *
  * @module dsh-tree-task-flow/pause
  */
 
@@ -71,6 +85,18 @@ export function registerPause(ctx, { store = null, autoContinue = null } = {}) {
     store?.patchHeld?.(sessionId, { paused: false });
   }
 
+  /**
+   * 真解除"被按住"：暂停与停止两半一起清，内存、磁盘、自动续行压住的那一份都放开。
+   * 「继续」走的就是这一条，而且**无条件**（见模块头的 ★）。
+   *
+   * @param sessionId - 要放开的会话。
+   */
+  function clearHeld(sessionId) {
+    paused.delete(sessionId);
+    store?.patchHeld?.(sessionId, { paused: false, stopped: false });
+    autoContinue?.resume?.(sessionId);
+  }
+
   /**
    * 取这个会话的实时 agent。
    *
@@ -138,7 +164,13 @@ export function registerPause(ctx, { store = null, autoContinue = null } = {}) {
       };
     }
     if (agent.status !== "idle") {
-      return { woke: false, reason: "busy", text: "这个会话正在跑，不需要唤醒。" };
+      // 正忙不是失败：它自己会在下一个岔口接着跑，本来就不需要谁推它一把。
+      // 「被按住」已经由 `resume()` 无条件解除，所以这里什么都不用做。
+      return {
+        woke: false,
+        reason: "busy",
+        text: "这个会话正在跑，不用唤醒：被按住的状态已经解除，它会在下一个岔口接着往下跑。",
+      };
     }
     const plan = store?.readPlan?.(sessionId) ?? null;
     const active = activePath(plan);
@@ -215,28 +247,21 @@ export function registerPause(ctx, { store = null, autoContinue = null } = {}) {
         return { released: false, woke: false, reason: "no-session", text: "拿不到当前会话。" };
       }
 
-      /** 真解除"被按住"：暂停与停止两半一起清，连自动续行的压住也放开。 */
-      const clearHeld = () => {
-        paused.delete(sessionId);
-        store?.patchHeld?.(sessionId, { paused: false, stopped: false });
-        autoContinue?.resume?.(sessionId);
-      };
+      // ★ 先无条件解除"被按住"，再谈唤醒。理由见模块头那段 ★：点「继续」是一个
+      // 意思表示，不该有条件；有条件就会制造"点过了却还按着"的静默卡死。
+      clearHeld(sessionId);
 
-      // 本进程里真挂着：放行那一步——这是常规路径，**零新增消息**。
+      // 本进程里真挂着闸门：放行那一步——常规路径，**零新增消息**。
       const pending = waiters.get(sessionId);
       if (pending !== undefined && pending.size > 0) {
-        clearHeld();
         for (const release of [...pending]) release();
         return { released: true, woke: false, reason: "released", text: "停在岔口上的那一步已经放行。" };
       }
 
-      // 没有挂着的 waiter（进程重启过）：退一步唤醒 idle 的会话。
-      //
-      // **只有真把它推起来、或计划确实已经收尾，才解除"被按住"。** 没成功时
-      // （会话没加载 / 正在跑 / 唤醒抛错）必须把状态留着：否则用户既没有「继续」
-      // 可再点一次，也看不到为什么没动，只剩一个停在原地的会话。
+      // 没有挂着的 waiter：本进程里没有东西可放行（进程重启过，或者这次暂停赶在
+      // 闸门挂上之前——那时候点的那一下，旧实现会被吞掉）。退一步，尽最大努力把
+      // idle 的会话推起来；推不起来也不改变"已经解除被按住"这个事实。
       const outcome = wakeIdle(sessionId);
-      if (outcome.woke === true || outcome.reason === "finished") clearHeld();
       return { released: false, ...outcome };
     },
     /**

package/lib/plan.js

@@ -355,6 +355,54 @@ export function dropNode(plan, id, now = Date.now()) {
   };
 }
 
+/**
+ * 删掉一个节点。**删除和丢弃是两件事，别混着用：**
+ *
+ * - **丢弃**回答"这件事还要不要做"：节点留在树里划掉，将来还查得到"曾经有这么一件事，
+ *   后来决定不做了"。它不改写历史。
+ * - **删除**是**清理**：内容本身就是错的（建重了、写歪了、结果记在了错的地方），
+ *   留着只会误导后面的人。所以它把这个节点连同它的全部子孙从树里凭空摘掉，
+ *   **不看状态**——已完成的照样删得掉，那正是"这条记录不该留在这儿"的情形。
+ *
+ * 摘完树可能是空的（最后一个目标被删掉）：那时 `plan.goals` 是**空数组**，而不是
+ * 没有计划——计划文件照旧在盘上，渲染会给出"还没有计划"的样子。
+ *
+ * 活动路径与检查点在删完**重新算**，调用方不要拿删除前的那一份去用。
+ *
+ * @param plan - 计划树。
+ * @param id - 节点 id。
+ * @param now - 时间戳。
+ * @returns `{ ok, reason?, removed?, active?, checkpoint? }`。
+ */
+export function deleteNode(plan, id, now = Date.now()) {
+  const found = findNode(plan, id);
+  if (!found) return { ok: false, reason: `找不到节点 ${id}` };
+
+  // 先把要摘掉的那几个记下来——摘掉之后就找不着了。
+  const removed = [`${levelLabel(found.level)}「${found.node.title}」`];
+  if (found.level === "goal") {
+    for (const task of found.node.tasks ?? []) {
+      removed.push(`任务「${task.title}」`);
+      for (const step of task.steps ?? []) removed.push(`子任务「${step.title}」`);
+    }
+    plan.goals = goalsOf(plan).filter((goal) => goal.id !== id);
+  } else if (found.level === "task") {
+    for (const step of found.node.steps ?? []) removed.push(`子任务「${step.title}」`);
+    found.goal.tasks = (found.goal.tasks ?? []).filter((task) => task.id !== id);
+  } else {
+    found.task.steps = (found.task.steps ?? []).filter((step) => step.id !== id);
+  }
+  plan.updatedAt = now;
+
+  const checkpoint = checkpointOf(plan);
+  return {
+    ok: true,
+    removed,
+    active: activePath(plan),
+    checkpoint: checkpoint === null ? null : { id: checkpoint.node.id, level: checkpoint.level },
+  };
+}
+
 /**
  * 改一个节点的标题或说明。
  *

package/lib/settings.js

@@ -0,0 +1,53 @@
+/**
+ * 界面上的开关：**哪些键可以改**，以及怎么把它们并进配置。
+ *
+ * 单独成文件是为了让"可改的键"只有一份定义：`lib/index.js` 开机时用它把落盘的
+ * 选择并进配置，`lib/http.js` 收到面板的请求时用它校验键名。两处各写一份，
+ * 迟早会出现"界面能点、开机不认"或者反过来的错位。
+ *
+ * 优先级：**界面改过的（落盘）> profile 里的 config > DEFAULT_CONFIG**。
+ * 界面上改完还被 profile 顶回去，人会以为开关坏了。
+ *
+ * @module dsh-tree-task-flow/settings
+ */
+
+/**
+ * 面板可以改的键。
+ *
+ * 只收布尔开关：它们都是"要不要让插件自己动起来"这类事，改了立刻能看出效果，
+ * 也不需要额外解释。`maxAutoRounds` / `interruptDelaysMs` 这类带数值的旋钮
+ * 留在 profile 里——界面上给一个数字要配输入框与校验，不值当。
+ */
+export const SETTING_KEYS = ["autoContinue", "interruptRecovery"];
+
+/**
+ * 从一个对象里挑出认识的开关，且值必须是布尔。
+ *
+ * 落盘的 `settings.json` 可能被人手改坏、也可能是旧版本留下的键，
+ * 所以这里**只认名单上的键**，其余一概忽略；值不是布尔的也忽略，
+ * 免得一个 `"false"` 字符串把 `cfg.autoContinue !== true` 那种判断带偏。
+ *
+ * @param value - 待挑选的对象，通常是落盘的设置。
+ * @returns 只含合法键值的新对象；没有合法的就是 `{}`。
+ */
+export function pickSettings(value) {
+  const picked = {};
+  if (value === null || typeof value !== "object") return picked;
+  for (const key of SETTING_KEYS) {
+    if (typeof value[key] === "boolean") picked[key] = value[key];
+  }
+  return picked;
+}
+
+/**
+ * 把当前生效的开关压成面板要的形状。
+ *
+ * @param cfg - 合并后的配置。
+ * @returns `{ autoContinue, interruptRecovery }`，缺的按 false 报。
+ */
+export function settingsSnapshot(cfg) {
+  return {
+    autoContinue: cfg?.autoContinue === true,
+    interruptRecovery: cfg?.interruptRecovery === true,
+  };
+}

package/lib/store.js

@@ -7,6 +7,7 @@
  *   - `surfaces/<sessionId>.json`  三层的折叠游标（只给界面看，不参与折叠）
  *   - `held/<sessionId>.json`      「被按住」：暂停 / 停止，**要跨重启保留**
  *   - `revive/<sessionId>.json`    意外中断的拉起重试链，**要跨重启保留**
+ *   - `settings.json`              界面上的开关，**跟会话无关**，整个状态根一份
  *
  * 计划属于建立它的那个会话。放到会话无关的位置，任何一个会话的计划都会被
  * 所有会话的 `agent/pre-step` 读到——那等于把不相干的节点指派塞进别人的上下文，
@@ -89,6 +90,9 @@ export function createStore(root) {
   /** 意外中断重试链的文件路径。 */
   const reviveFile = (sessionId) => file("revive", `${sessionId}.json`);
 
+  /** 设置文件的路径（与会话无关，整个状态根一份）。 */
+  const settingsFile = () => file("settings.json");
+
   /** 读「被按住」状态；读不到或文件坏了，一律按"没被按住"处理。 */
   function readHeldState(sessionId) {
     if (!sessionId) return { paused: false, stopped: false, at: null };
@@ -176,6 +180,43 @@ export function createStore(root) {
       writeJson(file("surfaces", `${sessionId}.json`), value);
     },
 
+    // ---- 设置：**与会话无关**，整个状态根一份 ----
+
+    /**
+     * 读界面上的开关。
+     *
+     * 为什么落盘：开关是"这台机器上的偏好"，重启一次就忘掉等于没有这个开关。
+     * 它在 `apply()` 里盖在 profile 的 config 之上——**人在界面上的选择优先**，
+     * 否则界面改完、profile 一改又被顶回去，人会以为开关坏了。
+     *
+     * 只认自己认识的键：文件里多出别的字段一律忽略，坏文件当空。
+     *
+     * @returns `{ autoContinue?, interruptRecovery?, at? }`；没改过就是 `{}`。
+     */
+    readSettings() {
+      const value = readJson(settingsFile(), null);
+      if (value === null || typeof value !== "object") return {};
+      return value;
+    },
+
+    /**
+     * 改几个开关，其余保持磁盘上的原样（读改写，与 `patchHeld` 同一个道理：
+     * 两个开关分属两条路径，谁都不能整份覆盖）。
+     *
+     * @param patch - `{ autoContinue?, interruptRecovery? }`；没给的键不动。
+     * @returns 写入后的完整设置对象。
+     */
+    patchSettings(patch) {
+      const current = readJson(settingsFile(), null);
+      const next = current !== null && typeof current === "object" ? { ...current } : {};
+      for (const [key, value] of Object.entries(patch ?? {})) {
+        if (typeof value === "boolean") next[key] = value;
+      }
+      next.at = Date.now();
+      writeJson(settingsFile(), next);
+      return next;
+    },
+
     // ---- 「被按住」：暂停 / 停止。**要跨重启保留**，所以落盘 ----
 
     /**

package/lib/tools.js

@@ -1,5 +1,5 @@
 /**
- * 六个 `tree_task_*` 工具。
+ * 七个 `tree_task_*` 工具。
  *
  * **写树分成两个工具，不是可以合并的重复。** `tree_task_create` 与 `tree_task_done`
  * 是折叠区间的两个边界（见 `lib/region.js`）：`create` 是"开工"那一下，`done` 是
@@ -30,9 +30,11 @@ import {
   addGoal,
   complete,
   createPlan,
+  deleteNode,
   doneReply,
   dropNode,
   findNode,
+  goalsOf,
   renderContinue,
   renderGoal,
   renderTree,
@@ -301,5 +303,50 @@ export function registerTools(ctx, { store, cfg }) {
     },
   });
 
+  ctx.tools.register({
+    name: "tree_task_delete",
+    description:
+      "从树里删掉一个节点——**清理**用的，不是「这件事不做了」。" +
+      "丢弃（tree_task_drop）是留个记号：这件事我不做，但树里还查得到它曾经有过；" +
+      "删除是把内容凭空摘掉，连同它下面的任务或子任务一起，" +
+      "**不看状态**（已完成、已丢弃的都删得掉）。" +
+      "内容写错了、建重了、结果记在了错的地方，就用这个。",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: { type: "string", description: "要删除的节点 id" },
+      },
+      required: ["id"],
+    },
+    output: OUTPUT,
+    async execute(args, exec) {
+      const plan = store.readPlan(sessionOf(exec));
+      if (!plan) return ok("还没有计划。");
+      // 删掉之后就查不到"这次动的是哪个目标"了，先记一份。
+      const touched = findNode(plan, args?.id);
+      const result = deleteNode(plan, args?.id);
+      if (!result.ok) return ok(`没有删除：${result.reason}`);
+      store.writePlan(sessionOf(exec), plan);
+
+      const lines = [`已删除：${result.removed.join("、")}`, ""];
+      if (touched !== null && touched.level !== "goal") {
+        // 删的是任务或子任务：它所在的那个目标还在，照旧只给它一个目标的树。
+        lines.push(renderGoal(touched.goal, plan, true));
+      } else {
+        // 删的是目标：那个目标已经不存在了，没有"它所在的树"可给。
+        // 剩下的目标数说一句就够——要看细节再调 tree_task_status。
+        const rest = goalsOf(plan).length;
+        lines.push(
+          rest === 0
+            ? "计划树现在空了。（要用就用 tree_task_create 建新目标。）"
+            : `这个会话还剩 ${rest} 个目标，要看细节用 tree_task_status。`,
+        );
+      }
+      lines.push("", renderContinue(plan));
+      return ok(lines.join("\n"));
+    },
+  });
+
   void cfg;
 }

package/package.json

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