dsh-tree-task-flow 0.3.2 → 0.3.4

package/README.md

@@ -135,7 +135,10 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
   阶段标签四种：进行中 / 已暂停 / 检查点 / 已全部完成。
 - **展开后**是待办清单那样的卡片：三级树之间有竖线与拐角连线，层级一眼看得出来；
   同一层的节点之间、节点内部的各个内容块之间，各有一条分界线。
-  当前节点用虚线圈标出，已完成打勾、丢弃的划掉。
+  **默认只摊开正在走的那条路径**——目标一路展开到当前子任务，其余节点收起，
+  一打开就能看见正在跑的那一个，不用在一堆已经收尾的节点里翻；检查点所在的节点
+  也一样默认摊开。想细看哪个就点它行尾的箭头，逐层摊开或收起。
+  当前节点的虚线圈会匀速转，已完成打勾、丢弃的划掉。
 - 节点标题**不缩略**：有多长写多长，多了自动换行。
 - 提交的结果**默认只占一行**，点一下摊开看全文。
 - 节点上可以直接完成、丢弃，不用敲命令。
@@ -192,18 +195,17 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
 暂停期间人按界面上的停止（中断本轮）也不会卡住：闸门盯着本轮的取消信号，
 信号一 abort 就立刻放行。
 
-## 自动续行的四道闸门
+## 自动续行的三道闸门
 
 `autoContinue` 默认关闭，开着也只是**兜底**：`tree_task_done` 的返回文本里已经带了
 "请继续执行下一个子任务"，模型通常会在同一轮里接着做。这里兜的是模型仍然停下来的情况。
 
-开启后仍有四道闸门，缺一不可：
+开启后仍有三道闸门，缺一不可：
 
 1. **默认关**——`autoContinue: false` 时不注册续行逻辑。
 2. **中断即停**——用户按下停止（`agent/turn-stopping` 且 `signal.aborted`），
    这个会话就被标记为不再自动续行，直到真人再发一条消息。
-3. **内置 goal 活跃时不插手**——`goals` 服务里有活跃 goal 就完全让路。
-4. **轮次上限**——连续续行达到 `maxAutoRounds` 就停；只有真人发的消息才重置配额。
+3. **轮次上限**——连续续行达到 `maxAutoRounds` 就停；只有真人发的消息才重置配额。
 
 队列里还有排队输入时也不抢，让用户先说话。
 

package/client.js

@@ -187,6 +187,23 @@ window.__ModuleLoader__.load({
 			);
 		}
 
+		/**
+		 * 面板一打开该摊开哪些节点：活动路径上的三层，加上检查点节点以及它的祖先。
+		 *
+		 * 其余节点一律收起——正在走的那条路径本来就窄，摊平整棵树只会让人翻半天。
+		 * 检查点落在某个任务上时，目标也得一起摊开，否则连那一行都看不见。
+		 */
+		function defaultOpenIds(data) {
+			const ids = currentIds(data);
+			const checkpoint = data.checkpoint;
+			if (checkpoint !== null && checkpoint !== undefined && typeof checkpoint.id === "string") {
+				ids.add(checkpoint.id);
+				const goalId = data.plan?.goal?.id;
+				if (checkpoint.level !== "goal" && typeof goalId === "string") ids.add(goalId);
+			}
+			return ids;
+		}
+
 		// ---------------------------------------------------------------- 文案
 
 		const zh = {
@@ -297,6 +314,10 @@ window.__ModuleLoader__.load({
 			".dsh-ttf-markCell{flex:none;display:inline-flex;align-items:center;margin-top:3px;color:var(--dsw-alias-label-tertiary)}",
 			".dsh-ttf-markDone{flex:none;display:inline-flex;align-items:center;margin-top:3px;color:var(--dsw-alias-state-success-primary,#1a7f37)}",
 			".dsh-ttf-markMuted{flex:none;display:inline-flex;align-items:center;margin-top:3px;color:var(--dsw-alias-label-caption,#00000066)}",
+			// 正在运行的标记：就是原来那个虚线圆，让它匀速转起来。1s 一圈、线性、
+			// 无限，与内置待办面板 in_progress 的节奏一致。
+			"@keyframes dsh-ttf-spin{to{transform:rotate(360deg)}}",
+			".dsh-ttf-markSpin{animation:dsh-ttf-spin 1s linear infinite;transform-origin:50% 50%}",
 			".dsh-ttf-done{color:var(--dsw-alias-label-tertiary);text-decoration:line-through}",
 			// 三层缩进。
 			// 子节点：一条竖线 + 每个子节点一个拐角，把三层画成看得见的树。
@@ -340,7 +361,11 @@ window.__ModuleLoader__.load({
 
 		// ---------------------------------------------------------------- 零件
 
-		/** 节点状态标记：完成打勾、丢弃划掉、未完成画圈（当前节点用虚线圈，和内置待办一致）。 */
+		/**
+		 * 节点状态标记：完成打勾、丢弃划掉、未完成画圈（当前节点用虚线圈，和内置待办一致）。
+		 *
+		 * 正在运行的那个圈还会匀速转起来——虚线一转就能看出这条路径还在推进。
+		 */
 		function StatusMark({ node, isCurrent }) {
 			if (node.status === "done") {
 				const check = icon("IconCheckOutline14", 14);
@@ -357,7 +382,14 @@ window.__ModuleLoader__.load({
 				{ className: "dsh-ttf-markCell" },
 				h(
 					"svg",
-					{ width: 14, height: 14, viewBox: "0 0 14 14", fill: "none", "aria-hidden": true },
+					{
+						width: 14,
+						height: 14,
+						viewBox: "0 0 14 14",
+						fill: "none",
+						"aria-hidden": true,
+						className: isCurrent ? "dsh-ttf-markSpin" : undefined,
+					},
 					h("circle", circle),
 				),
 			);
@@ -428,12 +460,26 @@ window.__ModuleLoader__.load({
 		 * 三层共用同一个组件——它们的字段与动作本来就一样，差别只有缩进和
 		 * 「能不能丢弃」（整个目标不能丢，plan.js 会拒绝）。
 		 */
-		function NodeRow({ node, depth, activeIds, checkpointId, canDrop, sessionId, reload, t, defaultOpen }) {
-			const [open, setOpen] = useState(defaultOpen === true);
+		function NodeRow({ node, depth, activeIds, openIds, checkpointId, canDrop, sessionId, reload, t }) {
+			const children = node.tasks || node.steps || [];
+			const canAct = node.status === "pending";
+			const isCurrent = activeIds.has(node.id);
+			const isCheckpoint = checkpointId === node.id;
+			const shouldOpen = openIds.has(node.id);
+			const expandable = children.length > 0 || node.detail !== undefined || node.result !== undefined;
+
+			// 默认只摊开"正在走的那条路径"（见 defaultOpenIds）：目标一路展开到当前子任务，
+			// 其余节点收起。否则一打开面板就是一整棵摊平的树，想找正在跑的那个得翻半天。
+			const [open, setOpen] = useState(shouldOpen);
 			const [composing, setComposing] = useState(false);
 			const [busy, setBusy] = useState(false);
 			const [error, setError] = useState(null);
 
+			// 活动节点在会话里往前走了，就把它摊开：当前任务不该埋在收起里。
+			useEffect(() => {
+				if (shouldOpen) setOpen(true);
+			}, [shouldOpen]);
+
 			const act = useCallback(
 				async (body) => {
 					setBusy(true);
@@ -451,12 +497,6 @@ window.__ModuleLoader__.load({
 				[sessionId, reload],
 			);
 
-			const children = node.tasks || node.steps || [];
-			const canAct = node.status === "pending";
-			const isCurrent = activeIds.has(node.id);
-			const isCheckpoint = checkpointId === node.id;
-			const expandable = children.length > 0 || node.detail !== undefined || node.result !== undefined;
-
 			return h(
 				"div",
 				{ className: "dsh-ttf-node dsh-ttf-depth" + depth },
@@ -545,14 +585,12 @@ window.__ModuleLoader__.load({
 									node: child,
 									depth: depth + 1,
 									activeIds,
+									openIds,
 									checkpointId,
 									canDrop: true,
 									sessionId,
 									reload,
 									t,
-									// 条目一展开就该看见整棵树，所以每一层都摊开；
-									// 嫌长的用上面的「收起」逐层折。
-									defaultOpen: true,
 								}),
 							),
 							children.length === 0 && depth < 2
@@ -701,14 +739,13 @@ window.__ModuleLoader__.load({
 									node: goal,
 									depth: 0,
 									activeIds: currentIds(data),
+									openIds: defaultOpenIds(data),
 									checkpointId: data.checkpoint ? data.checkpoint.id : null,
 									// 整个目标不能丢弃：plan.js 会拒绝，这里也不给按钮。
 									canDrop: false,
 									sessionId,
 									reload,
 									t,
-									// 展开条目就是为了看树，所以第一层默认摊开。
-									defaultOpen: true,
 								}),
 							)
 						: null,

package/lib/auto-continue.js

@@ -7,12 +7,10 @@
  * 这里兜的是"模型仍然停下来"的情况：本轮结束、agent 回到 `idle` 时，
  * 如果计划还在进行中，就推一条续行消息把下一轮唤醒。
  *
- * 三条安全阀缺一不可（方案 §7.1）：
+ * 两条安全阀缺一不可（方案 §7.1）：
  *
- * 1. **有活跃的内置 goal 时完全不插手**——内置 goal 由 `dsh-goal-round-driver`
- *    自己推进轮次，插件再续一次就成了两套机制同时推同一个会话。
- * 2. **队列里还有人在等的时候绝不抢**：`inbox.nextTurn` / `nextStep` 非空就退出。
- * 3. **连续续行轮次有上限**，达到就停，避免把 token 烧在一个卡住的任务上。
+ * 1. **队列里还有人在等的时候绝不抢**：`inbox.nextTurn` / `nextStep` 非空就退出。
+ * 2. **连续续行轮次有上限**，达到就停，避免把 token 烧在一个卡住的任务上。
  *
  * @module dsh-tree-task-flow/auto-continue
  */
@@ -79,15 +77,11 @@ export function registerAutoContinue(ctx, { store, cfg }) {
     // ★ 安全阀 0：这一轮是被用户**中止**的 → 绝不能把它拉起来。
     if (stopped.has(sessionId)) return;
 
-    // 安全阀 1：内置 goal 活跃时完全不插手。
-    const goal = ctx.get?.("goals")?.get?.(agent);
-    if (goal !== undefined && goal !== null && goal.phase === "active") return;
-
-    // 安全阀 2：已经有排队输入，别抢在用户前面。
+    // 安全阀 1：已经有排队输入，别抢在用户前面。
     const inbox = agent.inbox;
     if ((inbox?.nextTurn?.length ?? 0) > 0 || (inbox?.nextStep?.length ?? 0) > 0) return;
 
-    // 安全阀 3：轮次上限。
+    // 安全阀 2：轮次上限。
     const used = rounds.get(sessionId) ?? 0;
     if (used >= cfg.maxAutoRounds) return;
 

package/package.json

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