dsh-session-conductor 1.3.11 → 1.3.16

package/lib/features/settings-routes.js

@@ -0,0 +1,400 @@
+// dsh-session-conductor — 模板与插件设置类 HTTP 路由
+//
+// 【为什么单独成文件】原先内联在 lib/apply.js 的 `ctx.inject(["webServer"])` 回调里（该回调上千行，
+// 审计 readability/max-function-length 拦截）。这里只搬「注册」与 handler 体，逐字保留、行为不变。
+//
+// 路由：/templates · /templates/dir（模板浏览与读写）、/fts-status（全文索引状态）、
+//       /compaction-model · /auto-rename-model（两条模型设置）、/auto-continue-gate（自动继续闸门）
+import { readJson, send } from '../http.js';
+import { log } from '../shared/log.js';
+import { readSwitch, patchSwitch } from '../core/config.js';
+import { invalidateSessionListCache } from '../sessions/list-cache.js';
+import { pluginDomain } from '../core/domain.js';
+import { resolveBrowseRoot, resolveDshHome } from '../core/config.js';
+import { setTemplateStateCache } from '../shared/test-hooks.js';
+import { saveTemplate, saveTemplateFromUrl, saveTemplateFromPath, listTemplateDir, removeTemplate, readTemplateSync } from '../template-inject.js';
+
+/**
+ * 注册模板与设置类路由。
+ * @param {object} deps
+ * @param {object} deps.webServer 宿主 webServer 服务
+ * @param {object} deps.ctx 插件 ctx
+ * @returns {void}
+ */
+/**
+ * 处理 /templates 的 GET/POST（列模板槽位与内容 / 写入与导入模板）。
+ *
+ * 【为什么单独成函数】handler 体 100 余行，内联在 register 回调里会让单函数超长
+ * （审计 readability/max-function-length 拦截，阈值 50 行）。抽出只换位置，逻辑一字不改；
+ * 缩进保持原样 —— 体内有模板字符串，重排缩进会改变字符串内容。
+ *
+ * @param {object} req 请求
+ * @param {object} res 响应
+ * @param {{ctx: object, tplHome: string, browseRoot: string}} deps 显式依赖
+ * @returns {Promise<void>}
+ */
+async function handleTemplatesRoute(req, res, { ctx, tplHome, browseRoot }) {
+            try {
+              // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+              if (req.method !== "GET") invalidateSessionListCache();
+              const domain = await pluginDomain(ctx);
+              const st = domain.global.get();
+              const meta = st.sessionTemplates ?? structuredClone(TEMPLATE_DEFAULTS);
+              // 缓存写入口必须是归属模块的 setter（import 绑定对导入方只读，直接赋值会 TypeError）
+              setTemplateStateCache(meta);
+              // 构造带 content 的 slots（GET/POST 统一：导入/编辑后前端编辑框直接读到内容）
+              if (req.method === "GET") {
+                return send(res, 200, { ok: true, slots: buildTemplateSlotsWithContent(meta), maxBytes: TEMPLATE_MAX_BYTES });
+              }
+              return await handleTemplatesPost(req, res, { ctx, tplHome, browseRoot, meta });
+              return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
+            } catch (error) {
+              send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
+            }
+}
+
+/**
+ * 构造「带内容的模板槽位表」（GET 与 POST 共用：导入/编辑后前端要拿到最新内容）。
+ *
+ * 【为什么单独成函数】原先是 handleTemplatesRoute 内的局部箭头函数，抽出来只为把主 handler
+ * 压到函数长度阈值内；逻辑与缩进一字不改（体内有模板字符串，重排缩进会改内容）。
+ *
+ * @param {object} meta2 模板元数据
+ * @param {string} tplHome 模板落盘目录
+ * @returns {object} slot → 槽位元数据 + content
+ */
+function buildTemplateSlotsWithContent(meta2, tplHome) {
+                const out = {};
+                for (const slot of TEMPLATE_SLOTS) {
+                  const slotMeta = meta2[slot] ?? { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 };
+                  let content = "";
+                  if (slotMeta.bytes > 0 || slotMeta.name) {
+                    // readTemplateSync 返回 sanitized 字符串（无文件/不可读返回空串），不是 {ok,text} 对象
+                    try { content = String(readTemplateSync(tplHome, slot) ?? "").slice(0, TEMPLATE_MAX_BYTES); } catch { content = ""; }
+                  }
+                  out[slot] = { ...slotMeta, content };
+                }
+                return out;
+}
+
+/**
+ * 处理 /templates 的 POST（写入 / 导入 / 切换模板槽位）。
+ *
+ * 【为什么单独成函数】该分支 80 行，与主 handler 放一起会超函数长度阈值；
+ * 逻辑与缩进一字不改（体内有模板字符串，重排缩进会改内容）。
+ * 原分支内的 return 语义保持不变：返回值直接透传给外层 handler。
+ *
+ * @param {object} req 请求
+ * @param {object} res 响应
+ * @param {{ctx: object, tplHome: string, browseRoot: string, meta: object}} deps 显式依赖
+ * @returns {Promise<void>}
+ */
+async function handleTemplatesPost(req, res, { ctx, tplHome, browseRoot, meta }) {
+                const body = await readJson(req);
+                // 目录内选用 md 文件（action="pickPath"）——校验用工作区浏览根，落盘用 DSH_HOME
+                 if (body?.action === "pickPath") return await handleTemplatesPickPath(req, res, { browseRoot, tplHome, meta, body });
+                const slot = String(body?.slot ?? "");
+                if (!TEMPLATE_SLOTS.includes(slot)) {
+                  return send(res, 400, { ok: false, error: { code: "bad-slot", message: `模板槽位须为 ${TEMPLATE_SLOTS.join("|")}` } });
+                }
+                const cur = meta[slot] ?? { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 };
+                 if (body?.action === "remove") return await handleTemplatesRemove(req, res, { tplHome, meta, slot, cur });
+                let saved = null;
+                if (typeof body?.url === "string" && body.url.trim()) {
+                  saved = await saveTemplateFromUrl(tplHome, slot, body.url);
+                } else if (typeof body?.content === "string") {
+                  // 编辑保存：可只带 content（name 保留现值）；也可带 name（本地导入）
+                  saved = await saveTemplate(tplHome, slot, { name: (typeof body?.name === "string" && body.name.trim()) ? body.name : cur.name, content: body.content });
+                }
+                if (saved && saved.ok) {
+                  const next = {
+                    ...meta,
+                    [slot]: {
+                      enabled: cur.enabled, // 上传内容不自动开，用户再点开关
+                      enforce: cur.enforce === true,
+                      name: saved.name || cur.name,
+                      url: typeof body?.url === "string" && body.url.trim() ? body.url.trim() : "",
+                      bytes: saved.bytes,
+                      updatedAt: Date.now(),
+                    },
+                  };
+                  setTemplateStateCache(next);
+                  await domain.global.set({ ...st, sessionTemplates: next });
+                  return send(res, 200, { ok: true, slots: buildTemplateSlotsWithContent(next), message: `模板「${slot}」已保存，记得点「开启注入」` });
+                }
+                if (saved && !saved.ok) return send(res, 400, saved);
+                if (typeof body?.enabled === "boolean") {
+                  const next = { ...meta, [slot]: { ...cur, enabled: body.enabled } };
+                  setTemplateStateCache(next);
+                  await domain.global.set({ ...st, sessionTemplates: next });
+                  return send(res, 200, { ok: true, slots: buildTemplateSlotsWithContent(next), message: body.enabled ? `模板「${slot}」已开启注入` : `模板「${slot}」已关闭` });
+                }
+                // 方案模板强制门禁开关（{slot:"plan", enforce:bool}）——即时生效，无需重启
+                if (slot === "plan" && typeof body?.enforce === "boolean") {
+                  const next = { ...meta, plan: { ...cur, enforce: body.enforce } };
+                  setTemplateStateCache(next);
+                  await domain.global.set({ ...st, sessionTemplates: next });
+                  return send(res, 200, { ok: true, slots: buildTemplateSlotsWithContent(next), message: body.enforce
+                    ? `方案模板强制门禁已开启（未出提案并获确认前，代码修改类工具调用被拒绝）`
+                    : `方案模板强制门禁已关闭` });
+                }
+                return send(res, 400, { ok: false, error: { code: "bad-request", message: "需要 {slot, name, content}（本地 md）、{slot, url}（在线 md）、{slot, enabled} 或 {slot:'plan', enforce}" } });
+}
+
+/**
+ * 处理 /templates 的「按路径导入」（action=pickPath）：把工作区内某个 md 文件复制成模板。
+ *
+ * 【为什么单独成函数】主 POST 处理器里这一支 20 余行，抽出来才让上层函数降到长度阈值内；
+ * 逻辑与缩进一字不改。返回值直接透传（内部各分支都是 return send(...)）。
+ *
+ * @param {object} req 请求
+ * @param {object} res 响应
+ * @param {{browseRoot: string, tplHome: string, meta: object, body: object}} deps 显式依赖
+ * @returns {Promise<void>}
+ */
+async function handleTemplatesPickPath(req, res, { browseRoot, tplHome, meta, body }) {
+                  const slot = String(body?.slot ?? "");
+                  if (!TEMPLATE_SLOTS.includes(slot)) {
+                    return send(res, 400, { ok: false, error: { code: "bad-slot", message: `模板槽位须为 ${TEMPLATE_SLOTS.join("|")}` } });
+                  }
+                  const saved = await saveTemplateFromPath(browseRoot, slot, body.path, tplHome);
+                  if (!saved.ok) return send(res, 400, saved);
+                  const cur = meta[slot] ?? { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 };
+                  const next = {
+                    ...meta,
+                    [slot]: {
+                      enabled: cur.enabled,
+                      enforce: cur.enforce === true,
+                      name: saved.name || cur.name,
+                      url: "",
+                      bytes: saved.bytes,
+                      updatedAt: Date.now(),
+                    },
+                  };
+                  setTemplateStateCache(next);
+                  await domain.global.set({ ...st, sessionTemplates: next });
+                  return send(res, 200, { ok: true, slots: buildTemplateSlotsWithContent(next), message: `模板「${slot}」已从目录选用（${saved.name}），记得点「开启注入」` });
+}
+
+/**
+ * 处理 /templates 的「移除」（action=remove）：清空该槽位并返回最新槽位表。
+ *
+ * 【为什么单独成函数】同上：把主 POST 处理器压到长度阈值内，逻辑与缩进一字不改。
+ *
+ * @param {object} req 请求
+ * @param {object} res 响应
+ * @param {{tplHome: string, meta: object, slot: string, cur: object}} deps 显式依赖
+ * @returns {Promise<void>}
+ */
+async function handleTemplatesRemove(req, res, { tplHome, meta, slot, cur }) {
+                  const r = await removeTemplate(tplHome, slot);
+                  if (!r.ok) return send(res, 400, r);
+                  const next = { ...meta, [slot]: { ...cur, enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 } };
+                  setTemplateStateCache(next);
+                  await domain.global.set({ ...st, sessionTemplates: next });
+                  return send(res, 200, { ok: true, slots: buildTemplateSlotsWithContent(next), message: `模板「${slot}」已清空` });
+}
+
+export function registerSettingsRoutes({ webServer, ctx }) {
+    // ---------- GET/POST /api/session-conductor/templates ----------
+    //  会话模板注入（）：plan（方案模板）/ closing（收尾模板）两个固定槽位，
+    // 支持上传本地 md 文件或在线 md 网址（host 下载转存），内容落盘
+    // <DSH_HOME>/template-inject-md/<slot>.md → systemPrompt section「session-templates」注入。
+    // GET → {ok, slots: {plan:{enabled,name,url,bytes,updatedAt}, closing:{...}}, maxBytes}
+    // POST {slot, enabled?} → 只改开关；
+    // POST {slot, name, content} → 上传本地 md；
+    // POST {slot, url} → 在线 md 网址下载转存；
+    // POST {slot, action:"remove"} → 清空槽位。
+    {
+      const tplHome = resolveDshHome(ctx, cfg);
+      // 浏览根与选用校验根唯一来源 = resolveBrowseRoot（工作区目录）。
+      // 同一 browseRoot 变量贯穿本块内两个路由：/templates 的 pickPath 校验、/templates/dir 浏览。
+      // 落盘仍 tplHome（DSH_HOME/template-inject-md/），浏览/校验/落盘三者职责清晰。
+      const browseRoot = resolveBrowseRoot(ctx, cfg);
+      if (tplHome) {
+        webServer.register({
+          kind: "exact",
+          path: "/api/session-conductor/templates",
+          handler: (req, res) => handleTemplatesRoute(req, res, { ctx, tplHome, browseRoot }),
+        });
+
+        // ---------- GET /api/session-conductor/templates/dir ----------
+        //  模板目录浏览（「在工作区目录内找」）：列 DSH 工作区目录树内一层目录。
+        // 浏览根与选用校验根同源（上方 browseRoot）；落盘仍在 DSH_HOME/template-inject-md/。
+        // GET ?path=... → {ok, path, parent, entries:[{name,path,isDir,isMd}]}（缺省从工作区根开始）
+        if (browseRoot) {
+          webServer.register({
+            kind: "exact",
+            path: "/api/session-conductor/templates/dir",
+            handler: async (req, res) => {
+              try {
+                // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+                if (req.method !== "GET") invalidateSessionListCache();
+                if (req.method !== "GET") return send(res, 405, { ok: false, error: { code: "method", message: "仅 GET" } });
+                const url = new URL(req.url, "http://localhost");
+                const path = url.searchParams.get("path") ?? "";
+                const r = await listTemplateDir(browseRoot, path);
+                if (!r.ok) return send(res, 400, r);
+                return send(res, 200, r);
+              } catch (error) {
+                send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
+              }
+            },
+          });
+        }
+      }
+    }
+
+    // ---------- GET /api/session-conductor/fts-status ----------
+    // 全文搜索诊断（ 并入，原独立插件 dsh-session-search 已合并）：
+    // 报告官方 FTS5（sessionQuery）是否挂载 + 内置 zstd 扫描兜底是否可用。
+    webServer.register({
+      kind: "exact",
+      path: "/api/session-conductor/fts-status",
+      handler: async (req, res) => {
+        try {
+          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+          if (req.method !== "GET") invalidateSessionListCache();
+          const sessionQuery = ctx.get("sessionQuery");
+          const sessionEvents = ctx.get("sessionEvents");
+          send(res, 200, {
+            ok: true,
+            plugin: "dsh-session-conductor",
+            sessionQueryMounted: sessionQuery !== void 0,
+            ftsMode: sessionQuery === void 0 ? "unavailable" : "first-search",
+            builtinScanAvailable: typeof searchSessions === "function",
+            note:
+              sessionQuery === void 0
+                ? "官方 FTS5 服务未挂载（检查 session-query-sqlite openAt 配置），使用内置 zstd 扫描兜底"
+                : "官方 FTS5 内容搜索已解锁（openAt: first-search），内置 zstd 扫描为兜底",
+          });
+        } catch (error) {
+          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
+        }
+      },
+    });
+
+    // ---------- GET/POST /api/session-conductor/compaction-model ----------
+    // 压缩模型选择：会话模型旁单独选压缩用模型。
+    // GET → {ok, compactionModel: {provider,model}|null, follow: true(跟随会话模型)}
+    // POST {provider, model} → 设置；POST {follow:true} → 重置为跟随会话模型
+    webServer.register({
+      kind: "exact",
+      path: "/api/session-conductor/compaction-model",
+      handler: async (req, res) => {
+        try {
+          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+          if (req.method !== "GET") invalidateSessionListCache();
+          const domain = await pluginDomain(ctx);
+          const state = domain.global.get();
+          const cur = state.compactionModel ?? null;
+          if (req.method === "GET") {
+            return send(res, 200, { ok: true, compactionModel: cur, follow: cur === null });
+          }
+          if (req.method === "POST") {
+            const body = await readJson(req);
+            if (body?.follow === true) {
+              await domain.global.set({ ...state, compactionModel: null });
+              return send(res, 200, { ok: true, compactionModel: null, follow: true, message: "压缩模型已重置为跟随会话模型" });
+            }
+            const provider = String(body?.provider ?? "").trim();
+            const model = String(body?.model ?? "").trim();
+            if (!provider || !model) return send(res, 400, { ok: false, error: { code: "bad-request", message: "需要 provider 和 model" } });
+            await domain.global.set({ ...state, compactionModel: { provider, model } });
+            return send(res, 200, { ok: true, compactionModel: { provider, model }, follow: false, message: `压缩模型已设为 ${provider}/${model}（重启后生效）` });
+          }
+          return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
+        } catch (error) {
+          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
+        }
+      },
+    });
+
+    // ---------- GET/POST /api/session-conductor/auto-rename-model ----------
+    // 自动重命名模型选择：设置页「DSH 同款解析选择器」选定。
+    // GET → {ok, selection: {provider,model}|null, follow: true(跟随会话模型), catalog}
+    //   catalog = 官方 modelCatalog（provider 分组 + 模型 + 默认），供前端渲染选择器。
+    // POST {provider, model} → 设置；POST {follow:true} → 重置为跟随会话模型。
+    webServer.register({
+      kind: "exact",
+      path: "/api/session-conductor/auto-rename-model",
+      handler: async (req, res) => {
+        try {
+          const domain = await pluginDomain(ctx);
+          const state = domain.global.get();
+          const cur = state.autoRenameModel ?? null;
+          if (req.method === "GET") {
+            // 官方解析选择器的数据源：provider 分组 + 模型列表 + 部署默认
+            let catalog = null;
+            try {
+              const sc = ctx.get("sessionController");
+              catalog = sc?.modelCatalog ? await sc.modelCatalog() : null;
+            } catch (error) {
+              log(ctx, `auto-rename-model: 官方 modelCatalog 获取失败（前端仍可手动输入）: ${String(error?.message ?? error)}`);
+              catalog = null;
+            }
+            return send(res, 200, { ok: true, selection: cur, follow: cur === null, catalog });
+          }
+          if (req.method === "POST") {
+            const body = await readJson(req);
+            if (body?.follow === true) {
+              await domain.global.set({ ...state, autoRenameModel: null });
+              return send(res, 200, { ok: true, selection: null, follow: true, message: "自动重命名模型已重置为跟随会话模型" });
+            }
+            const provider = String(body?.provider ?? "").trim();
+            const model = String(body?.model ?? "").trim();
+            if (!provider || !model) return send(res, 400, { ok: false, error: { code: "bad-request", message: "需要 provider 和 model" } });
+            await domain.global.set({ ...state, autoRenameModel: { provider, model } });
+            return send(res, 200, { ok: true, selection: { provider, model }, follow: false, message: `自动重命名模型已设为 ${provider}/${model}` });
+          }
+          return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
+        } catch (error) {
+          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
+        }
+      },
+    });
+
+    // ---------- GET/POST /api/session-conductor/auto-continue-gate ----------
+    // 自动续跑全局闸门（与 guardian 联动）：
+    //   GET → {ok, gate: "open"|"closed", note}
+    //   POST {gate:"open"|"closed"} → 设置；closed 时一切自动续跑跳过（周期扫描/scan 自动续跑部分）
+    //   guardian 在 DSH 恢复健康时置 closed；用户手动开启或首次手动对话（turn/start user）后自动置 open
+    webServer.register({
+      kind: "exact",
+      path: "/api/session-conductor/auto-continue-gate",
+      handler: async (req, res) => {
+        try {
+          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+          if (req.method !== "GET") invalidateSessionListCache();
+          const domain = await pluginDomain(ctx);
+          const state = domain.global.get();
+          const cur = state.autoContinueGate ?? "open";
+          if (req.method === "GET") {
+            return send(res, 200, {
+              ok: true,
+              gate: cur,
+              note: cur === "closed"
+                ? "自动续跑全局闸门关闭：一切自动续跑跳过（DSH 刚启动/崩溃恢复后），用户手动开启或第一次手动对话后自动放行"
+                : "自动续跑全局闸门开放：按原有判定（单会话开关 → 全局默认）",
+            });
+          }
+          if (req.method === "POST") {
+            const body = await readJson(req);
+            const gate = String(body?.gate ?? "");
+            if (gate !== "open" && gate !== "closed") {
+              return send(res, 400, { ok: false, error: { code: "bad-request", message: 'gate 必须为 "open" 或 "closed"' } });
+            }
+            await domain.global.set({ ...state, autoContinueGate: gate });
+            return send(res, 200, {
+              ok: true,
+              gate,
+              message: gate === "closed" ? "自动续跑闸门已关闭（所有自动续跑暂停）" : "自动续跑闸门已开放",
+            });
+          }
+          return send(res, 405, { ok: false, error: { code: "method", message: MSG_METHOD_ONLY_GET_POST } });
+        } catch (error) {
+          send(res, 500, { ok: false, error: { code: "internal", message: String(error?.message ?? error) } });
+        }
+      },
+    });
+}

package/lib/features/value-report-routes.js

@@ -0,0 +1,211 @@
+// dsh-session-conductor — 会话价值分析与任务完成汇报路由
+//
+// 【为什么单独成文件】原先内联在 lib/apply.js 的 `ctx.inject(["webServer"])` 回调里，
+// 让该回调成为上千行巨型函数（审计 readability/max-function-length 拦截）。
+// 这里只搬「注册」这部分，handler 体逐字保留、行为不变。
+//
+// 路由：
+//   POST /value-analysis      —— 扫描会话并给出价值评分/清理建议
+//   任务完成汇报管道（task-completion-report）
+import { readJson, send } from '../http.js';
+import { log } from '../shared/log.js';
+import { invalidateSessionListCache } from '../sessions/list-cache.js';
+import { lazyValue } from '../core/lazy.js';
+import { analyzeValueWithLlm } from './rename/value.js';
+import { buildSessionListCached } from '../sessions/list.js';
+import { getValueVerdict, putValueVerdict, saveValueIndexNow } from './value-index.js';
+import { renderCompletionBlock } from '../core.js';
+import { sessionEventsOf } from '../sessions/events.js';
+import { MAX_STALE_DAYS } from '../shared/constants.js';
+
+/**
+ * 注册价值分析与任务汇报路由。
+ * @param {object} deps
+ * @param {object} deps.webServer 宿主 webServer 服务
+ * @param {object} deps.ctx 插件 ctx
+ * @returns {void}
+ */
+export function registerValueReportRoutes({ webServer, ctx }) {
+
+    // ---------- POST /api/session-conductor/value-analysis ----------
+    // 会话价值分析（ 规则判定 +  特征/LLM/关键词价值）：
+    //   规则分类 completed/unfinished/stale/active + 最后回复摘要；
+    //   高/低价值 = assessValue 特征评分（活跃/长度/完成/未完成/细节补充）；
+    //   可选 body.keywords=[...] 记录指定关键词 → 标题/最后用户消息命中任一关键词的会话无条件最高价值；
+    //   可选 body.llm=true 额外用 LLM 打分（fail-soft）。
+    webServer.register({
+      kind: "exact",
+      path: "/api/session-conductor/value-analysis",
+      handler: async (req, res) => {
+        try {
+          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+          if (req.method !== "GET") invalidateSessionListCache();
+          const body = await readJson(req);
+          const staleDays = typeof body?.staleDays === "number" && Number.isFinite(body.staleDays)
+            ? Math.min(MAX_STALE_DAYS, Math.max(1, Math.round(body.staleDays)))
+            : 3;
+          const useLlm = body?.llm === true;
+          const sessions = await buildSessionListCached(ctx); // 价值分析走缓存（容忍 5s 陈旧，避免与面板刷新叠加扫描）
+          // 流式（`?stream=1` 或 Accept: application/x-ndjson）：**每分析完一个会话就推一行**。
+          // 前端拿到 value==="low" 立刻勾上（分析出一个勾一个），不必等全量跑完 ——
+          // 全量要逐个读上百份日志，慢的是读取本身，而读取是天然可增量的。
+          // 判定规则与批量路径同源（value.js 的 classifySessionLevel），不在这里另写一套。
+          const wantValueStream = /application\/x-ndjson/i.test(req.headers?.accept ?? "")
+            || String(req.url ?? "").includes("stream=1");
+          if (wantValueStream) {
+            // body.ids：只分析这些会话（面板已先用归档/时间/目录在本地筛过一轮，
+            // 没必要把全量会话都读一遍事件）。不传 = 全量。
+            const wantedIds = Array.isArray(body?.ids)
+              ? new Set(body.ids.filter((id) => typeof id === "string" && id !== ""))
+              : null;
+            const streamTargets = wantedIds ? sessions.filter((s) => wantedIds.has(s.id)) : sessions;
+            res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
+            res.setHeader("Cache-Control", "no-store");
+            if (res.socket?.setNoDelay) res.socket.setNoDelay(true);
+            res.write(JSON.stringify({ ok: true, stream: true, total: streamTargets.length }) + "\n");
+            try {
+              if (typeof res.flushHeaders === "function") res.flushHeaders();
+            } catch { /* 老宿主不支持 flush，不影响主流程 */ }
+            const { classifySessionLevel } = await lazyValue();
+            let done = 0;
+            for (const s of streamTargets) {
+              done += 1;
+              // ① 索引命中（内容没变 + 未超 TTL）→ 零 I/O 直接给结论
+              const cachedVerdict = getValueVerdict(ctx, s.id, s.updatedAt);
+              if (cachedVerdict) {
+                try {
+                  res.write(JSON.stringify({
+                    id: s.id, value: cachedVerdict.value, score: cachedVerdict.score,
+                    reason: cachedVerdict.reason, cached: true, done, total: streamTargets.length,
+                  }) + "\n");
+                } catch { break; }
+                continue;
+              }
+              // ② 没索引 / 会话变过 / 超 TTL → 真读一次日志
+              let events = [];
+              try {
+                const found = await sessionEventsOf(ctx, s.id);
+                events = found?.events ?? [];
+              } catch { /* 读不到就当空事件：会走 artifact-safe 保守判 high，不误删 */ }
+              const verdict = classifySessionLevel(s, events, new Date(), staleDays);
+              putValueVerdict(ctx, s.id, s.updatedAt, verdict);
+              try {
+                res.write(JSON.stringify({ ...verdict, cached: false, done, total: streamTargets.length }) + "\n");
+              } catch { break; }
+            }
+            saveValueIndexNow(ctx); // 本次算出来的结论立刻落盘（下次筛选直接命中索引）
+            try { res.end(); } catch { /* 连接已断 */ }
+            return;
+          }
+          // 一次性读取各会话事件（复用，避免大会话重复解压导致超时/失败）
+          const eventsById = {};
+          // 逐个会话读取最后 assistant 文本 + 最后用户消息（损坏/不可读会话跳过，用空串）
+          const texts = {};
+          const userTexts = {};
+          for (const s of sessions) {
+            try {
+              const found = await sessionEventsOf(ctx, s.id);
+              if (found) {
+                eventsById[s.id] = found.events || [];
+                const { lastAssistantText, lastUserText, filterSessionsByKeywords } = await lazyValue();
+                texts[s.id] = lastAssistantText(found.events);
+                userTexts[s.id] = lastUserText(found.events);
+              }
+            } catch {
+              /* 单会话失败跳过 */
+            }
+          }
+          // 可选 LLM 高/低价值判断
+          let llmById = {};
+          if (useLlm) {
+            llmById = await analyzeValueWithLlm(ctx, sessions, texts, (m) => log(ctx, m));
+          }
+          // 特征评分（活跃/长度/完成/未完成/细节补充）+ 关键词命中→无条件最高
+          const featuresById = {};
+          for (const s of sessions) {
+            try {
+              const { buildValueFeatures } = await lazyValue();
+              featuresById[s.id] = buildValueFeatures(eventsById[s.id] || [], s, new Date());
+            } catch {
+              const { buildValueFeatures: buildValueFeatures2 } = await lazyValue();
+              featuresById[s.id] = buildValueFeatures2([], s, new Date());
+            }
+          }
+          const keywords = Array.isArray(body?.keywords) ? body.keywords : [];
+          const { analyzeValuesWithKeywords } = await lazyValue();
+          const analysisSummary = analyzeValuesWithKeywords(sessions, texts, userTexts, featuresById, keywords, llmById, new Date(), staleDays);
+          const counts = {};
+          for (const key of Object.keys(analysisSummary)) counts[key] = analysisSummary[key].length;
+          send(res, 200, {
+            ok: true,
+            staleDays,
+            llm: !!useLlm,
+            keywords: keywords.length ? keywords : void 0,
+            keywordHits: keywords.length ? filterSessionsByKeywords(sessions, texts, userTexts, keywords, new Date()) : [],
+            generatedAt: Date.now(),
+            counts,
+            completed: analysisSummary.completed,
+            unfinished: analysisSummary.unfinished,
+            stale: analysisSummary.stale,
+            active: analysisSummary.active,
+            high: analysisSummary.high,
+            low: analysisSummary.low,
+          });
+        } catch (error) {
+          send(res, 400, { ok: false, error: { code: "value-analysis-failed", message: String(error?.message ?? error) } });
+        }
+      },
+    });
+
+    // ---------- 任务完成汇报（task-completion-report 管道） ----------
+    // 收尾约定不再由代码写死注入 systemPrompt——改由模板注入「收尾模板」槽位承担
+    // （设置 → 会话管理 → 模板注入 → closing，可自定义内容）。
+    // LLM 侧的 render/check 工具已移除，只剩下面的 HTTP 端点（面板/自检用），故 tools 如实回报空列表。
+    webServer.register({
+      kind: "exact",
+      path: "/api/task-completion/status",
+      handler: async (req, res) => {
+        send(res, 200, {
+          ok: true,
+          name: "dsh-session-conductor",
+          skill: "task-completion-report",
+          conventionSource: "template-inject:closing（不再代码写死，由收尾模板槽位注入）",
+          tools: []
+        });
+      },
+    });
+
+    webServer.register({
+      kind: "exact",
+      path: "/api/task-completion/render",
+      handler: async (req, res) => {
+        try {
+          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+          if (req.method !== "GET") invalidateSessionListCache();
+          const body = await readJson(req);
+          const block = renderCompletionBlock(body);
+          send(res, 200, { ok: true, block });
+        } catch (error) {
+          send(res, 400, { ok: false, error: { code: "render-failed", message: String(error?.message ?? error) } });
+        }
+      },
+    });
+
+    webServer.register({
+      kind: "exact",
+      path: "/api/task-completion/check",
+      handler: async (req, res) => {
+        try {
+          // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
+          if (req.method !== "GET") invalidateSessionListCache();
+          const body = await readJson(req);
+          if (typeof body?.text !== "string") {
+            return send(res, 400, { ok: false, error: { code: "bad-request", message: "缺少 text" } });
+          }
+          send(res, 200, { ok: true, ...checkCompletionText(body.text) });
+        } catch (error) {
+          send(res, 400, { ok: false, error: { code: "check-failed", message: String(error?.message ?? error) } });
+        }
+      },
+    });
+}