dsh-tree-task-flow 0.3.9 → 0.3.11

package/README.md

@@ -132,7 +132,7 @@ tree_task消息：接下来需要进行步骤：「步骤二」(s-4)。
 
 **从 npm 安装**：
 
-```powershell
+```bash
 dsh plugin --profile web add dsh-tree-task-flow
 ```
 
@@ -311,6 +311,12 @@ dsh --profile web --dump-config          # 输出里应出现 task-tree 这一
    之类的提示；继续之后也不会有"继续"消息进上下文。想让模型知道中间发生过什么，
    得自己发消息说。
 
+7. **内置压缩之后会有一条提醒。** DSH 自己的压缩把一大段历史收成一条检查点之后，
+   如果这个会话里有计划树，插件会注入一条
+   `tree_task消息：上下文刚被压缩过，计划树没有被压缩。用 tree_task_status 取回当前进度…`。
+   计划树本身不在压缩范围内——它存在磁盘上；但模型会忘掉它，所以补这一句。
+   同一个压缩点只提醒一次，之后再被压缩会再提醒一次。
+
 ## 不做的事
 
 | 不做 | 原因 |

package/client.js

@@ -61,10 +61,27 @@ window.__ModuleLoader__.load({
 			primitives = {};
 		}
 
+		/**
+		 * 内置图标名有两套写法，这里两套都认。
+		 *
+		 * 旧外壳把尺寸写进名字：`IconCheckOutline16`、`IconChevronDownOutline14`；
+		 * 升级后的外壳把名字里的尺寸换成笔画粗细：`IconCheckOutlineRegular`、
+		 * `IconCheckOutlineMedium`，尺寸改由 `size` 属性给。按「尺寸后缀 → 粗细后缀
+		 * → 裸名」的顺序找，两套外壳都取得回图标，不会平白降级成文字。
+		 */
+		function findIcon(base, size) {
+			const candidates = [base + size, base + "14", base + "16", base + "Regular", base + "Medium", base];
+			for (const candidate of candidates) {
+				const component = primitives[candidate];
+				if (typeof component === "function") return component;
+			}
+			return null;
+		}
+
 		/** 取一个内置图标；这版外壳没有就返回 null，由调用方决定怎么退。 */
-		function icon(iconName, size) {
-			const component = primitives[iconName];
-			if (typeof component !== "function") return null;
+		function icon(base, size) {
+			const component = findIcon(base, size);
+			if (component === null) return null;
 			return h(component, { size });
 		}
 
@@ -75,16 +92,21 @@ window.__ModuleLoader__.load({
 			return h(Tooltip, { label, side: "bottom", delayMs: 500 }, node);
 		}
 
-		/** 图标按钮：有图标用图标，没图标退回短文字，保证永远点得到。 */
-		function IconButton({ iconName, label, disabled, onClick }) {
-			const glyph = icon(iconName, 16);
+		/**
+		 * 图标按钮：有图标用图标，没图标退回短文字，保证永远点得到。
+		 *
+		 * 退回文字时换成 `dsh-ttf-iconBtnText`：按钮按文字宽度自己撑开、文字长了
+		 * 用省略号收住，所以并排的几个按钮不会挤成一团互相压。
+		 */
+		function IconButton({ iconBase, label, size, disabled, onClick }) {
+			const glyph = icon(iconBase, typeof size === "number" ? size : 16);
 			return withTooltip(
 				label,
 				h(
 					"button",
 					{
 						type: "button",
-						className: "dsh-ttf-iconBtn",
+						className: glyph === null ? "dsh-ttf-iconBtn dsh-ttf-iconBtnText" : "dsh-ttf-iconBtn",
 						disabled: disabled === true,
 						"aria-label": label,
 						onClick,
@@ -307,16 +329,21 @@ window.__ModuleLoader__.load({
 			'.dsh-ttf-panel:after{border:.5px solid var(--dsw-alias-border-l1);border-radius:inherit;content:"";pointer-events:none;position:absolute;inset:0}',
 			".dsh-ttf-bar{box-sizing:border-box;width:100%;height:36px;display:flex;align-items:center;gap:10px;padding:4px 5px 4px 12px}",
 			".dsh-ttf-glyph{color:var(--dsw-alias-label-tertiary);flex:none;display:inline-flex;align-items:center}",
+			".dsh-ttf-glyphFallback{font-size:13px;line-height:16px}",
 			".dsh-ttf-label{color:var(--dsw-alias-label-primary);flex:none;font-size:13px;font-weight:500;line-height:24px;white-space:nowrap}",
 			".dsh-ttf-labelHeld{color:var(--dsw-alias-state-warning-primary,#a06800)}",
 			".dsh-ttf-title{min-width:0;flex:1;color:var(--dsw-alias-label-primary-dimmed);font-size:13px;line-height:20px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
 			".dsh-ttf-progress{flex:none;max-width:45%;min-width:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:20px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
 			".dsh-ttf-actions{flex:none;display:flex;align-items:center;gap:2px}",
-			".dsh-ttf-iconBtn{corner-shape:round;width:28px;height:28px;border:none;background:0 0;border-radius:999px;color:var(--dsw-alias-label-tertiary);cursor:pointer;display:inline-flex;align-items:center;justify-content:center;padding:0;font:inherit}",
+			".dsh-ttf-iconBtn{corner-shape:round;width:28px;height:28px;border:none;background:0 0;border-radius:999px;color:var(--dsw-alias-label-tertiary);cursor:pointer;display:inline-flex;align-items:center;justify-content:center;padding:0;font:inherit;flex:none}",
 			".dsh-ttf-iconBtn:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}",
 			".dsh-ttf-iconBtn:disabled{opacity:.4;cursor:default}",
 			".dsh-ttf-iconBtn:disabled:hover{background:0 0;color:var(--dsw-alias-label-tertiary)}",
-			".dsh-ttf-iconText{font-size:12px;line-height:16px;padding:0 4px;white-space:nowrap}",
+			// 取不到内置图标时退回文字：固定 28px 宽装不下几个字，文字会溢出到相邻
+			// 按钮上，看着就是几个按钮叠在一起。这里按文字宽度撑开、留出边距，
+			// 并给一个上限，长了用省略号收住——几个按钮始终各占各的位置。
+			".dsh-ttf-iconBtnText{width:auto;min-width:28px;max-width:112px;height:24px;padding:0 8px}",
+			".dsh-ttf-iconText{min-width:0;max-width:100%;overflow:hidden;text-overflow:ellipsis;font-size:12px;line-height:16px;white-space:nowrap}",
 			// 展开体：限高滚动——这是输入框旁边的位置，不能让它把会话挤没了。
 			".dsh-ttf-body{max-height:264px;overflow-y:auto;padding:2px 8px 8px}",
 			".dsh-ttf-note{margin:4px 4px 6px;padding:6px 8px;border-radius:8px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-bg-module-platform)}",
@@ -388,11 +415,11 @@ window.__ModuleLoader__.load({
 		 */
 		function StatusMark({ node, isCurrent }) {
 			if (node.status === "done") {
-				const check = icon("IconCheckOutline14", 14);
+				const check = icon("IconCheckOutline", 14);
 				return h("span", { className: "dsh-ttf-markDone" }, check === null ? "✓" : check);
 			}
 			if (node.status === "dropped") {
-				const close = icon("IconCloseOutline16", 14);
+				const close = icon("IconCloseOutline", 14);
 				return h("span", { className: "dsh-ttf-markMuted" }, close === null ? "×" : close);
 			}
 			const circle = { cx: 7, cy: 7, r: 5.2, stroke: "currentColor", strokeWidth: 1.2 };
@@ -536,7 +563,7 @@ window.__ModuleLoader__.load({
 						{ className: "dsh-ttf-rowActions" },
 						canAct
 							? h(IconButton, {
-									iconName: "IconCheckOutline16",
+									iconBase: "IconCheckOutline",
 									label: t("action.done"),
 									disabled: busy,
 									onClick: () => {
@@ -547,7 +574,7 @@ window.__ModuleLoader__.load({
 							: null,
 						canAct && canDrop
 							? h(IconButton, {
-									iconName: "IconTrashOutline16",
+									iconBase: "IconTrashOutline",
 									label: t("action.drop"),
 									disabled: busy,
 									onClick: () => {
@@ -559,7 +586,7 @@ window.__ModuleLoader__.load({
 							: null,
 						expandable
 							? h(IconButton, {
-									iconName: open ? "IconChevronDownOutline14" : "IconChevronRightOutline14",
+									iconBase: open ? "IconChevronDownOutline" : "IconChevronRightOutline",
 									label: open ? t("action.collapse") : t("action.expand"),
 									onClick: () => setOpen(!open),
 								})
@@ -718,6 +745,10 @@ window.__ModuleLoader__.load({
 					: data.active === null
 						? t("state.done")
 						: t("state.running");
+			// 条首的清单图标；外壳连这个图标都没有时退回一个同类字符，别留空白。
+			const listIcon = icon("IconChecklistOutline", 14);
+			const listGlyph =
+				listIcon === null ? h("span", { className: "dsh-ttf-glyphFallback" }, "☰") : listIcon;
 
 			return h(
 				"div",
@@ -728,7 +759,7 @@ window.__ModuleLoader__.load({
 					h(
 						"div",
 						{ className: "dsh-ttf-bar" },
-						h("span", { className: "dsh-ttf-glyph", "aria-hidden": true }, icon("IconChecklistOutline14", 14)),
+						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(
@@ -740,13 +771,13 @@ window.__ModuleLoader__.load({
 							"div",
 							{ className: "dsh-ttf-actions" },
 							h(IconButton, {
-								iconName: held ? "IconPlayOutline16" : "IconPauseOutline16",
+								iconBase: held ? "IconPlayOutline" : "IconPauseOutline",
 								label: held ? t("action.resume") : t("action.pause"),
 								disabled: busy,
 								onClick: () => act({ action: held ? "resume" : "pause" }),
 							}),
 							h(IconButton, {
-								iconName: "IconTrashOutline16",
+								iconBase: "IconTrashOutline",
 								label: t("action.reset"),
 								disabled: busy,
 								onClick: () => {
@@ -754,7 +785,7 @@ window.__ModuleLoader__.load({
 								},
 							}),
 							h(IconButton, {
-								iconName: open ? "IconChevronDownOutline14" : "IconChevronUpOutline14",
+								iconBase: open ? "IconChevronDownOutline" : "IconChevronUpOutline",
 								label: open ? t("action.collapse") : t("action.expand"),
 								onClick: () => setOpen(!open),
 							}),

package/lib/compaction.js

@@ -0,0 +1,137 @@
+/**
+ * 压缩后提示：内置压缩把一大段历史收成一条检查点之后，提醒模型
+ * 计划树没有被压缩，可以用 `tree_task_status` 取回来。
+ *
+ * 为什么需要它：内置压缩（`@deepseek-ai/dsh-compaction-basic`）在上下文用到
+ * 窗口 `thresholdRatio`（默认 0.8）时触发，只保留最近 `retainRatio`
+ * （默认 0.16）的原文，其余整段换成一条结构化的检查点消息。计划树的三层结构、
+ * 各节点已提交的 result、当前推进到哪一步，只能指望摘要恰好把它们写进了
+ * Pending Jobs / Current Work / Next Step——不保证写全。而压缩的摘要指令
+ * 又明确要求"不要提及这次压缩"，模型不会自己想到去查。
+ *
+ * 怎么认：压缩留下的表层节点是一条 `user/message`，它的 `source` 由
+ * `compactCheckpointSource()` 构造，标记固定为 `plugin: "compact"`
+ * （见 `@deepseek-ai/dsh-compaction` 的 `isCompactCheckpointSource`）。
+ *
+ * **不要认 `compaction/summary` 事件**：那是压缩自己的记录，不带 `surfaceOp`，
+ * 因此根本不在表层里；真正替代被收走那段的是紧随其后那条带
+ * `surfaceOp: { op: "replace", … }` 的消息。
+ *
+ * 时机与顺序：本模块在 `lib/index.js` 里比 `region` **先**注册，因此它是外层
+ * 监听器——注入放在 `await next()` **之后**，那时暂停闸门与折叠都已经做完：
+ * 被按住的会话收不到提示，这条提示自己也不会被同一轮折叠收走。
+ *
+ * 检出则**两头都看**，因为本行相对压缩实现坐在链的哪一层不是本插件能决定的：
+ *
+ *   - 坐在压缩外层：前置那次还没有新检查点，只有后置能看到；
+ *   - 坐在压缩内层：前置那次就看到了，而后置时它可能已被这一轮折叠收走
+ *     （实机复测里真出现过：三次压缩只提示了两次）。
+ *
+ * 取后置看到的优先——那是更新的一次压缩。
+ *
+ * @module dsh-tree-task-flow/compaction
+ */
+
+import { summaryMessage } from "./region.js";
+
+/**
+ * 压缩检查点的插件标记。
+ *
+ * 与 `@deepseek-ai/dsh-compaction` 的 `COMPACT_CHECKPOINT_MARKER` 保持一致的
+ * 字面量。这里按形状判断而不是 import 那个包：插件不该为了认一个标记，
+ * 就把一个 DSH 内部包写进自己的依赖里。
+ */
+const COMPACTION_PLUGIN = "compact";
+
+/**
+ * 提示正文。
+ *
+ * 与折叠通告同形：`tree_task消息：` 开头，走 plugin/notice 形态落进表层，
+ * 界面上显示成一条可展开的通知，而不是冒充用户说的话。
+ */
+const NOTICE_TEXT =
+  "tree_task消息：上下文刚被压缩过，计划树没有被压缩。用 tree_task_status 取回当前进度、" +
+  "各节点已提交的 result，以及下一步该推进哪个节点。";
+
+/** 界面上的一行摘要。 */
+const NOTICE_LINE = "树形任务流 · 上下文被压缩，计划树仍在";
+
+/** 提示消息的编号，保证同一毫秒内连发两条也不撞 id。 */
+let noticeSeq = 0;
+
+function noticeId() {
+  noticeSeq += 1;
+  return `tt-compaction-${Date.now().toString(36)}-${noticeSeq.toString(36)}`;
+}
+
+/** 这条表层节点是不是压缩落下的检查点。 */
+function isCompactionCheckpoint(event) {
+  if (event?.type !== "user/message") return false;
+  const source = event.data?.source;
+  return source?.kind === "plugin" && source.plugin === COMPACTION_PLUGIN;
+}
+
+/**
+ * 表层上最后一个压缩检查点的 seq；这个会话还没被压缩过就返回 null。
+ *
+ * @param session - 当前会话。
+ * @returns 检查点节点的 seq，或 null。
+ */
+export function latestCompactionSeq(session) {
+  const nodes = session?.surface?.nodes ?? [];
+  if (typeof session?.eventAt !== "function") return null;
+  for (let index = nodes.length - 1; index >= 0; index -= 1) {
+    if (isCompactionCheckpoint(session.eventAt(nodes[index]))) return nodes[index];
+  }
+  return null;
+}
+
+/**
+ * 注册压缩后提示。
+ *
+ * @param ctx - 挂载本行的 Cordis 上下文。
+ * @param options - `{ store }`。
+ */
+export function registerCompactionNotice(ctx, { store }) {
+  ctx.on("agent/pre-step", async (payload, next) => {
+    const session = payload?.agent?.session;
+    // 前置那次先记下来：如果本行坐在压缩内层，这就是唯一能看到新检查点的时机。
+    const seqBefore = session === undefined ? null : latestCompactionSeq(session);
+
+    // 注入在后：暂停闸门与折叠都已经做完。
+    const decision = await next();
+    if (decision?.kind === "reject" || payload?.signal?.aborted) return decision;
+    if (session === undefined) return decision;
+
+    // 后置看到的优先（那是更新的一次压缩），看不到再退回前置那次。
+    const seq = latestCompactionSeq(session) ?? seqBefore;
+    if (seq === null) return decision;
+
+    const sessionId = session.id;
+    // 没有计划树就没有可查的状态，一条都不注入。
+    if (store.readPlan(sessionId) === null) return decision;
+
+    const cursors = store.readSurfaces(sessionId);
+    // 同一个检查点只提示一次；之后再被压缩，才会再提示一次。
+    if (cursors.compactionNoticeAt === seq) return decision;
+
+    try {
+      // surface 事件必须显式声明 surfaceOp，否则 append 会直接抛错。
+      session.append("user/message", summaryMessage(noticeId(), NOTICE_TEXT, NOTICE_LINE), {
+        surfaceOp: "append",
+      });
+    } catch (error) {
+      // 注入失败不改去重位置，下一轮还有机会。
+      ctx.logger?.warn?.(
+        `dsh-tree-task-flow: 压缩提示注入失败，下一轮再试：${String(error?.message ?? error)}`,
+      );
+      return decision;
+    }
+
+    cursors.compactionNoticeAt = seq;
+    cursors.sessionId = sessionId;
+    cursors.updatedAt = Date.now();
+    store.writeSurfaces(sessionId, cursors);
+    return decision;
+  });
+}

package/lib/index.js

@@ -19,6 +19,7 @@
 
 import { registerAutoContinue } from "./auto-continue.js";
 import { registerCommands } from "./commands.js";
+import { registerCompactionNotice } from "./compaction.js";
 import { registerHttp } from "./http.js";
 import { registerPause } from "./pause.js";
 import { DEFAULT_ORDER, registerPromptSection } from "./prompt.js";
@@ -97,6 +98,12 @@ export function apply(ctx, config) {
   // 六个工具。tools 已在 inject 里声明，这里必定就绪。
   registerTools(ctx, { store, cfg });
 
+  // 内置压缩之后提醒模型去看计划树。
+  //
+  // ★ **必须在 registerRegion 之前注册**：先注册的是外层，它的后置代码才会
+  // 排在折叠之后——否则这条提示会被同一轮折叠顺手收走。
+  registerCompactionNotice(ctx, { store });
+
   // 节点完成时把它的执行过程折叠成一条携带结果的汇总消息。
   registerRegion(ctx, { store });
 

package/lib/store.js

@@ -149,8 +149,12 @@ export function createStore(root) {
      * 它**不参与折叠**：折叠区间由 `region.foldRange()` 在表层上现算（边界调用之间那
      * 一段过程）。这里记的只是"这一层走到哪儿了"，给界面和排查用。
      *
+     * 另有一个与游标同住一处的去重位置：`compactionNoticeAt`，记着"压缩提示
+     * 已经提示到哪个 `compaction/summary` 节点了"（见 `lib/compaction.js`）。
+     * 它同样不参与折叠，只是让同一段压缩不会被反复提示。
+     *
      * @param sessionId - 会话 id。
-     * @returns `{ sessionId, goal, task, step, updatedAt }`。
+     * @returns `{ sessionId, goal, task, step, compactionNoticeAt, updatedAt }`。
      */
     readSurfaces(sessionId) {
       return readJson(file("surfaces", `${sessionId}.json`), {
@@ -158,6 +162,7 @@ export function createStore(root) {
         goal: null,
         task: null,
         step: null,
+        compactionNoticeAt: null,
         updatedAt: null,
       });
     },

package/package.json

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