dsh-session-conductor 1.3.10 → 1.3.13

package/lib/features/rename/value.js

@@ -21,42 +21,54 @@ const VALUE_LLM_MAX_TOKENS = 120;
  * @param {Function} [onError] 日志回调
  * @returns {Promise<object>} 会话 id → {value:"high"|"medium"|"low", reason}
  */
+/** 价值判定用的系统提示词（长常量提到模块级，函数体只留编排）。 */
+const VALUE_SYSTEM_PROMPT = "你是 DSH（DeepSeek Harness）会话价值分析师。给定一个会话的标题与最后回复片段，判断它在长期保留意义上的价值。高价值=含独有信息/未完成任务/学习成果/资产/待继续工作；低价值=灰尘/重复/过时空壳/可安全丢弃。输出严格 JSON，无 Markdown：{\"value\":\"high\"|\"medium\"|\"low\",\"reason\":\"一句话中文理由\"}";
+
+/**
+ * 单个会话的 LLM 价值判定。
+ * 无模型路由 / 输出解析失败都返回 null（由调用方的规则评分兜底）。
+ * @returns {Promise<{value:string, reason?:string}|null>}
+ */
+async function judgeSessionValue(llm, session, texts) {
+  const route = resolveRoute(session, llm);
+  if (!route?.provider || !route.model) return null; // 无模型路由 → 跳过
+  const title = session.title || session.cwd || session.id || "（无标题）";
+  const lastText = (texts?.[session.id] || "").slice(0, VALUE_PROMPT_TEXT_MAX_CHARS);
+  const text = [`会话标题：${title}`, "最后回复片段：", lastText].join("\n");
+  const assembler = new BlockAssembler();
+  for await (const chunk of llm.stream({
+    provider: route.provider,
+    model: route.model,
+    messages: [createUserMessage({ content: [{ type: "text", text }], source: { kind: "plugin:dsh-session-conductor", plugin: "dsh-session-conductor" } })],
+    system: VALUE_SYSTEM_PROMPT,
+    maxTokens: VALUE_LLM_MAX_TOKENS,
+    sessionId: session.id,
+    purpose: "session-conductor-value-analysis",
+    signal: AbortSignal.timeout(AUTO_RENAME_TIMEOUT_MS),
+  })) assembler.push(chunk);
+  const raw = assembler.blocks().filter((b) => b.type === "text").map((b) => b.text).join(" ").trim();
+  return parseValueJson(raw);
+}
+
 export async function analyzeValueWithLlm(ctx, sessions, texts, onError) {
   const out = {};
-  let llm;
+  let llm = null;
   try {
     llm = ctx.get("llm");
-  } catch { llm = null; }
+  } catch {
+    llm = null;
+  }
   if (!llm) {
     if (typeof onError === "function") onError("会话价值 LLM 判断跳过：llm 服务不可用");
     return out;
   }
-  for (const s of sessions ?? []) {
+  for (const session of sessions ?? []) {
     try {
-      const route = resolveRoute(s, llm);
-      if (!route?.provider || !route.model) continue; // 无模型路由 → 跳过，规则兜底
-      const title = s.title || s.cwd || s.id || "（无标题）";
-      const last = (texts?.[s.id] || "").slice(0, VALUE_PROMPT_TEXT_MAX_CHARS);
-      const system = "你是 DSH（DeepSeek Harness）会话价值分析师。给定一个会话的标题与最后回复片段，判断它在长期保留意义上的价值。高价值=含独有信息/未完成任务/学习成果/资产/待继续工作；低价值=灰尘/重复/过时空壳/可安全丢弃。输出严格 JSON，无 Markdown：{\"value\":\"high\"|\"medium\"|\"low\",\"reason\":\"一句话中文理由\"}";
-      const text = [`会话标题：${title}`, "最后回复片段：", last].join("\n");
-      const assembler = new BlockAssembler();
-      for await (const chunk of llm.stream({
-        provider: route.provider,
-        model: route.model,
-        messages: [createUserMessage({ content: [{ type: "text", text }], source: { kind: "plugin:dsh-session-conductor", plugin: "dsh-session-conductor" } })],
-        system,
-        maxTokens: VALUE_LLM_MAX_TOKENS,
-        sessionId: s.id,
-        purpose: "session-conductor-value-analysis",
-        signal: AbortSignal.timeout(AUTO_RENAME_TIMEOUT_MS),
-      })) assembler.push(chunk);
-      const blocks = assembler.blocks();
-      const raw = blocks.filter((b) => b.type === "text").map((b) => b.text).join(" ").trim();
-      const parsed = parseValueJson(raw);
-      if (parsed) out[s.id] = { value: parsed.value, reason: parsed.reason || "" };
+      const parsed = await judgeSessionValue(llm, session, texts);
+      if (parsed) out[session.id] = { value: parsed.value, reason: parsed.reason || "" };
     } catch (error) {
-      if (typeof onError === "function") onError(`会话价值 LLM 判断失败 ${s.id}: ${String(error?.message ?? error)}`);
-      /* 单个会话失败跳过，规则兜底 */
+      if (typeof onError === "function") onError(`会话价值 LLM 判断失败 ${session.id}: ${String(error?.message ?? error)}`);
+      // 单个会话失败跳过，规则兜底
     }
   }
   return out;

package/lib/features/session-messaging/logic.js

@@ -12,6 +12,7 @@
 //   —— 自己写日志等于拿对方会话的完整性冒险。因此本域**不碰任何日志文件**。
 
 import { log } from "../../shared/log.js";
+import { sessionMetaOf } from "../../sessions/lookup.js";
 
 /** 单条消息长度上限（字符）：够写交接要点，不够塞长文档（长内容应落共享文件）。 */
 export const TEXT_LIMIT = 8 * 1024;
@@ -143,7 +144,7 @@ export function currentSessionId(agent) {
 /**
  * 调用方会话的工作目录。
  * 用途：`create_session` 不传 cwd/workspaceId 时的缺省值 —— 新会话落在**发起它的那个会话**
- * 的工作目录里，而不是本体的默认 cwd（实测是 DSH 安装目录 `/volume1/@appstore/DeepSeekHarness-NAS`，
+ * 的工作目录里，而不是本体的默认 cwd（实测是 DSH 安装目录（即本机程序目录），
  * 对干活毫无意义）。
  */
 export function callerCwd(agent) {
@@ -173,19 +174,11 @@ export async function listSessions(ctx) {
  */
 export async function describeTarget(ctx, sessionId) {
   try {
-    const live = ctx.get?.("sessions")?.get?.(sessionId);
-    if (live) {
-      const cwd = String(live.header?.cwd ?? "(无工作区)");
-      return `（进行中 ｜ ${cwd}）`;
-    }
-    const { loadListDiskCache } = await import("../../sessions/list-cache.js");
-    const entry = loadListDiskCache(ctx)?.entries?.[sessionId];
-    if (entry) {
-      const cwd = String(entry.cwd ?? "(无工作区)");
-      const updated = typeof entry.updatedAt === "number" ? new Date(entry.updatedAt).toISOString() : "未知";
-      return `（已落盘 ｜ ${cwd} ｜ 最后活动 ${updated}）`;
-    }
-    return "（⚠️ 内存与落盘索引里都没有这个 id —— 可能写错了，或它是刚建、尚未落盘的会话）";
+    const meta = await sessionMetaOf(ctx, sessionId);
+    if (!meta) return "（⚠️ 内存与落盘索引里都没有这个 id —— 可能写错了，或它是刚建、尚未落盘的会话）";
+    if (meta.live) return `（进行中 ｜ ${String(meta.cwd ?? "(无工作区)")}）`;
+    const updated = meta.updatedAt ? new Date(meta.updatedAt).toISOString() : "未知";
+    return `（已落盘 ｜ ${String(meta.cwd ?? "(无工作区)")} ｜ 最后活动 ${updated}）`;
   } catch (error) {
     return `（目标存在性无法核对：${shortError(error)}）`;
   }

package/lib/features/session-ops-routes.js

@@ -41,194 +41,141 @@ export function shouldInvalidateListCache(method, body) {
  * @param {Function} deps.invalidateSessionListCache 会话列表缓存失效
  */
 export function registerSessionOpsRoutes({ webServer, ctx, send, readJson, invalidateSessionListCache }) {
-    /**
-     * 写请求才失效列表缓存（只读预览跳过）；判定见 shouldInvalidateListCache。
-     * 调用点必须在 readJson 之后 —— 要看到 body.dryRun 才能判定。
-     */
-    const invalidateUnlessDryRun = (req, body) => {
-      if (shouldInvalidateListCache(req.method, body)) invalidateSessionListCache();
-    };
+  /**
+   * 写请求才失效列表缓存（只读预览跳过）；判定见 shouldInvalidateListCache。
+   * 必须在 readJson 之后调用 —— 要看到 body.dryRun 才能判定。
+   */
+  const invalidateUnlessDryRun = (req, body) => {
+    if (shouldInvalidateListCache(req.method, body)) invalidateSessionListCache();
+  };
 
-    // ---------- POST /api/session-conductor/archive ----------
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/archive",
-      handler: async (req, res) => {
-        try {
-          // 失效列表缓存改到读取 body 之后：dryRun 预览是只读请求，不该打掉缓存（见 invalidateUnlessDryRun）。
-          const body = await readJson(req);
-          invalidateUnlessDryRun(req, body);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const registry = ctx.get("workspaceRegistry");
-          if (!registry) throw new Error("workspaceRegistry 服务不可用");
-          // 归档时给标题加「[工作区名] 」前缀（数据层带前缀，面板显示剥离，已归档视图按前缀分组）。
-          // 读会话 → 取原标题 → 加前缀 → rename（幂等：已带前缀不叠加）。失败不阻断归档。
-          try {
-            const sessions = ctx.get("sessions");
-            const titleService = ctx.get("sessionTitle");
-            const session = sessions?.get(body.sessionId);
-            const cwd = session?.header?.cwd ?? null;
-            const ws = workspaceNameOf(ctx, cwd);
-            const currentTitle = titleString(titleService?.get(session)) ?? (session ? foldTitle(session.events) : null) ?? "";
-            if (titleService && ws !== "" && currentTitle !== "") {
-              const { title: newTitle } = archiveTitleWithWs(currentTitle, ws);
-              if (newTitle !== currentTitle) {
-                titleService.rename(session, newTitle);
-                // 归档改的是标题（加工作区前缀）与归档态 —— 两者都在列表里可见，必须作废缓存
-                try {
-                  const { markSessionListStale } = await import("../sessions/list-cache.js");
-                  markSessionListStale(ctx, body.sessionId);
-                } catch { /* 作废失败不影响归档 */ }
-                log(ctx, `归档加工作区前缀 ${body.sessionId}: "${currentTitle}" → "${newTitle}"`);
-              }
-            }
-          } catch (titleError) {
-            log(ctx, `归档标题加前缀失败（不阻断归档）: ${String(titleError?.message ?? titleError)}`);
-          }
-          await registry.archiveSession(body.sessionId);
-          send(res, 200, { ok: true });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "archive-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
+  /** 读 body + 按需失效列表缓存：各路由共用的前置步骤。 */
+  const prepareBody = async (req) => {
+    const body = await readJson(req);
+    invalidateUnlessDryRun(req, body);
+    return body;
+  };
 
-    // ---------- POST /api/session-conductor/unarchive ----------
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/unarchive",
-      handler: async (req, res) => {
-        try {
-          // 失效列表缓存改到读取 body 之后：dryRun 预览是只读请求，不该打掉缓存（见 invalidateUnlessDryRun）。
-          const body = await readJson(req);
-          invalidateUnlessDryRun(req, body);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          // 取消归档时去掉「[工作区名] 」前缀还原原标题（数据层带前缀，取消归档即还原）。
-          try {
-            const sessions = ctx.get("sessions");
-            const titleService = ctx.get("sessionTitle");
-            const session = sessions?.get(body.sessionId);
-            const currentTitle = titleString(titleService?.get(session)) ?? (session ? foldTitle(session.events) : null) ?? "";
-            if (titleService && currentTitle !== "") {
-              const { title: stripped } = stripArchiveWsPrefix(currentTitle);
-              if (stripped !== currentTitle) {
-                titleService.rename(session, stripped);
-                try {
-                  const { markSessionListStale } = await import("../sessions/list-cache.js");
-                  markSessionListStale(ctx, body.sessionId);
-                } catch { /* 作废失败不影响取消归档 */ }
-                log(ctx, `取消归档还原标题 ${body.sessionId}: "${currentTitle}" → "${stripped}"`);
-              }
-            }
-          } catch (titleError) {
-            log(ctx, `取消归档还原标题失败（不阻断）: ${String(titleError?.message ?? titleError)}`);
-          }
-          await unarchiveSession(ctx, body.sessionId);
-          send(res, 200, { ok: true });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "unarchive-failed", message: String(error?.message ?? error) } });
+  /**
+   * 注册一条路由：统一 try/catch + 读 body + 失效缓存（可选校验 sessionId）。
+   * 原先 6 条路由各抄一遍这段样板，既重复又让业务代码多两层缩进。
+   * @param {string} path 路由路径
+   * @param {string} failCode 失败时的错误码
+   * @param {(body: object, res: object) => Promise<void>} run 业务体
+   * @param {{requireSessionId?: boolean}} [opts] requireSessionId=false 用于批量/按规则接口
+   */
+  const route = (path, failCode, run, { requireSessionId = true } = {}) => webServer.register({
+    kind: "exact",
+    path,
+    handler: async (req, res) => {
+      try {
+        const body = await prepareBody(req);
+        if (requireSessionId && (typeof body?.sessionId !== "string" || body.sessionId === "")) {
+          return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
         }
-      },
-    });
+        await run(body, res);
+      } catch (error) {
+        send(res, 400, { ok: false, error: { code: failCode, message: String(error?.message ?? error) } });
+      }
+    },
+  });
 
-    // ---------- POST /api/session-conductor/delete ----------
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/delete",
-      handler: async (req, res) => {
-        try {
-          // 失效列表缓存改到读取 body 之后：dryRun 预览是只读请求，不该打掉缓存（见 invalidateUnlessDryRun）。
-          const body = await readJson(req);
-          invalidateUnlessDryRun(req, body);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const deleteResult = await deleteSession(ctx, body.sessionId);
-          if (!deleteResult.ok) return send(res, 409, deleteResult);
-          send(res, 200, { ok: true });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "delete-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
+  /**
+   * 归档 / 取消归档共用的标题改写：读原标题 → 变换 → rename → 作废列表缓存。
+   * 失败只记日志、不阻断主流程（归档状态本身仍要落库）。
+   * @param {(currentTitle: string, workspaceName: string) => string|null} transform 返回 null 表示不改
+   */
+  const rewriteTitleForArchive = async (sessionId, transform, label) => {
+    try {
+      const sessions = ctx.get("sessions");
+      const titleService = ctx.get("sessionTitle");
+      const session = sessions?.get(sessionId);
+      const cwd = session?.header?.cwd ?? null;
+      const currentTitle = titleString(titleService?.get(session)) ?? (session ? foldTitle(session.events) : null) ?? "";
+      if (!titleService || currentTitle === "") return;
+      const nextTitle = transform(currentTitle, workspaceNameOf(ctx, cwd));
+      if (nextTitle === null || nextTitle === currentTitle) return;
+      titleService.rename(session, nextTitle);
+      // 标题是列表里可见的属性：改完必须让内存缓存与落盘索引一起作废
+      try {
+        const { markSessionListStale } = await import("../sessions/list-cache.js");
+        markSessionListStale(ctx, sessionId);
+      } catch { /* 作废失败不影响归档 */ }
+      log(ctx, `${label} ${sessionId}: "${currentTitle}" → "${nextTitle}"`);
+    } catch (titleError) {
+      log(ctx, `${label}失败（不阻断）: ${String(titleError?.message ?? titleError)}`);
+    }
+  };
 
-    // ---------- POST /api/session-conductor/undo-message ----------
-    // 撤回最后一条用户消息：直接操作会话日志文件，删除最后一条 user/message
-    // 及其后的整轮回复；dryRun=true 只返回预览（消息文本/将删事件数）不执行；二次确认由前端做。
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/undo-message",
-      handler: async (req, res) => {
-        try {
-          // 失效列表缓存改到读取 body 之后：dryRun 预览是只读请求，不该打掉缓存（见 invalidateUnlessDryRun）。
-          const body = await readJson(req);
-          invalidateUnlessDryRun(req, body);
-          if (typeof body?.sessionId !== "string" || body.sessionId === "") {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: MSG_NEED_SESSION_ID } });
-          }
-          const undoResult = await undoLastMessage(ctx, body.sessionId, { dryRun: body?.dryRun === true });
-          if (!undoResult.ok) return send(res, 409, undoResult);
-          send(res, 200, undoResult);
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "undo-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
+  // ---------- POST /api/session-conductor/archive ----------
+  // 归档时给标题加「[工作区名] 」前缀（数据层带前缀，面板显示剥离，已归档视图按前缀分组）。
+  route("/api/session-conductor/archive", "archive-failed", async (body, res) => {
+    const registry = ctx.get("workspaceRegistry");
+    if (!registry) throw new Error("workspaceRegistry 服务不可用");
+    await rewriteTitleForArchive(
+      body.sessionId,
+      (currentTitle, workspaceName) => (workspaceName === "" ? null : archiveTitleWithWs(currentTitle, workspaceName).title),
+      "归档加工作区前缀",
+    );
+    await registry.archiveSession(body.sessionId);
+    send(res, 200, { ok: true });
+  });
 
-    // ---------- POST /api/session-conductor/delete-batch ----------
-    // 批量删除：逐条复用删除链路（per-session 串行锁/幂等），运行中跳过不整体失败
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/delete-batch",
-      handler: async (req, res) => {
-        try {
-          // 失效列表缓存改到读取 body 之后：dryRun 预览是只读请求，不该打掉缓存（见 invalidateUnlessDryRun）。
-          const body = await readJson(req);
-          invalidateUnlessDryRun(req, body);
-          // 空数组（[]）是合法幂等请求，应返回空结果而非报错；仅「未传/非数组」才视为参数缺失
-          if (body?.sessionIds !== void 0 && !Array.isArray(body.sessionIds)) {
-            return send(res, 400, { ok: false, error: { code: "bad-request", message: "sessionIds 必须是数组" } });
-          }
-          const batchResult = await deleteBatchSessions(ctx, body?.sessionIds ?? []);
-          send(res, 200, { ok: true, ...batchResult });
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "delete-batch-failed", message: String(error?.message ?? error) } });
-        }
-      },
-    });
+  // ---------- POST /api/session-conductor/unarchive ----------
+  // 取消归档时去掉「[工作区名] 」前缀还原原标题（数据层带前缀，取消归档即还原）。
+  route("/api/session-conductor/unarchive", "unarchive-failed", async (body, res) => {
+    await rewriteTitleForArchive(
+      body.sessionId,
+      (currentTitle) => stripArchiveWsPrefix(currentTitle).title,
+      "取消归档还原标题",
+    );
+    await unarchiveSession(ctx, body.sessionId);
+    send(res, 200, { ok: true });
+  });
 
-    // ---------- POST /api/session-conductor/delete-by-rule ----------
-    // 按条件删除：归档状态/超期未活跃/cwd 前缀；dryRun=true 预览不执行
-    webServer.register({
-      kind: "exact",
-      path: "/api/session-conductor/delete-by-rule",
-      handler: async (req, res) => {
-        try {
-          // 失效列表缓存改到读取 body 之后：dryRun 预览是只读请求，不该打掉缓存（见 invalidateUnlessDryRun）。
-          const body = await readJson(req);
-          invalidateUnlessDryRun(req, body);
-          const ruleDeleteResult = await deleteByRule(ctx, {
-            archivedOnly: body?.archivedOnly === true,
-            inactiveDays: typeof body?.inactiveDays === "number" && Number.isFinite(body.inactiveDays)
-              ? Math.min(MAX_INACTIVE_DAYS, Math.max(0, Math.round(body.inactiveDays)))
-              : 0,
-            cwdPrefix: typeof body?.cwdPrefix === "string" ? body.cwdPrefix : "",
-            // 低价值条件必须**透传**：面板一直有「仅低价值会话」勾选框并把它放进请求体，
-            // 但路由原先没往下传 ⇒ deleteByRule 里 lowValue 恒为 false，这个条件等于没写，
-            // 勾了也和没勾一样（四个条件里唯一失效的一个）。
-            lowValue: body?.lowValue === true,
-            dryRun: body?.dryRun === true,
-          });
-          send(res, 200, ruleDeleteResult);
-        } catch (error) {
-          send(res, 400, { ok: false, error: { code: "delete-by-rule-failed", message: String(error?.message ?? error) } });
-        }
-      },
+  // ---------- POST /api/session-conductor/delete ----------
+  // 删除 = 打回收站标记（文件不动），真删由回收站到期/清空执行
+  route("/api/session-conductor/delete", "delete-failed", async (body, res) => {
+    const deleteResult = await deleteSession(ctx, body.sessionId);
+    if (!deleteResult.ok) return send(res, 409, deleteResult);
+    send(res, 200, { ok: true });
+  });
+
+  // ---------- POST /api/session-conductor/undo-message ----------
+  // 撤回最后一条用户消息：直接操作会话日志文件，删除最后一条 user/message 及其后的整轮回复；
+  // dryRun=true 只返回预览（消息文本/将删事件数）不执行；二次确认由前端做。
+  route("/api/session-conductor/undo-message", "undo-failed", async (body, res) => {
+    const undoResult = await undoLastMessage(ctx, body.sessionId, { dryRun: body?.dryRun === true });
+    if (!undoResult.ok) return send(res, 409, undoResult);
+    send(res, 200, undoResult);
+  });
+
+  // ---------- POST /api/session-conductor/delete-batch ----------
+  // 批量删除：一次操作 = 一个批次（回收站里可整批撤销），运行中的跳过不整体失败
+  route("/api/session-conductor/delete-batch", "delete-batch-failed", async (body, res) => {
+    // 空数组（[]）是合法幂等请求，应返回空结果而非报错；仅「未传/非数组」才视为参数缺失
+    if (body?.sessionIds !== void 0 && !Array.isArray(body.sessionIds)) {
+      return send(res, 400, { ok: false, error: { code: "bad-request", message: "sessionIds 必须是数组" } });
+    }
+    const batchResult = await deleteBatchSessions(ctx, body?.sessionIds ?? []);
+    send(res, 200, { ok: true, ...batchResult });
+  }, { requireSessionId: false });
+
+  // ---------- POST /api/session-conductor/delete-by-rule ----------
+  // 按条件筛选：归档状态 / 超期未活跃 / cwd 前缀 / 低价值；dryRun=true 只回命中不删
+  route("/api/session-conductor/delete-by-rule", "delete-by-rule-failed", async (body, res) => {
+    const ruleDeleteResult = await deleteByRule(ctx, {
+      archivedOnly: body?.archivedOnly === true,
+      inactiveDays: typeof body?.inactiveDays === "number" && Number.isFinite(body.inactiveDays)
+        ? Math.min(MAX_INACTIVE_DAYS, Math.max(0, Math.round(body.inactiveDays)))
+        : 0,
+      cwdPrefix: typeof body?.cwdPrefix === "string" ? body.cwdPrefix : "",
+      // 低价值条件必须**透传**：面板会发 lowValue，路由漏传过一次 ⇒ 该条件恒 false、勾了等于没勾
+      lowValue: body?.lowValue === true,
+      dryRun: body?.dryRun === true,
     });
+    send(res, 200, ruleDeleteResult);
+  }, { requireSessionId: false });
 }
 
 /**
@@ -248,7 +195,29 @@ export function registerTrashRoutes({ webServer, ctx, send, readJson, invalidate
     try { invalidateSessionListCache?.(); } catch { /* 失效失败不影响回收站操作 */ }
   };
 
+  /**
+   * 注册一条回收站路由：统一 try/catch + 读 body。
+   * 与 session-ops 那组同款收敛——原先每条各抄一遍，重复且多一层缩进。
+   * @param {string} path 路由路径
+   * @param {string} failCode 失败错误码
+   * @param {number} failStatus 失败 HTTP 状态码
+   * @param {(body: object, res: object) => Promise<void>|void} run 业务体
+   */
+  const route = (path, failCode, failStatus, run) => webServer.register({
+    kind: "exact",
+    path,
+    handler: async (req, res) => {
+      try {
+        const body = await readJson(req);
+        await run(body, res);
+      } catch (error) {
+        send(res, failStatus, { ok: false, error: { code: failCode, message: String(error?.message ?? error) } });
+      }
+    },
+  });
+
   // ---------- GET /api/session-conductor/trash ----------
+  // 回收站列表 + 当前保留天数 + 最近批次（撤销用）
   webServer.register({
     kind: "exact",
     path: "/api/session-conductor/trash",
@@ -269,94 +238,50 @@ export function registerTrashRoutes({ webServer, ctx, send, readJson, invalidate
 
   // ---------- POST /api/session-conductor/trash/restore ----------
   // body: { sessionIds: string[] } → 还原指定会话（删标记，文件本来就在）
-  webServer.register({
-    kind: "exact",
-    path: "/api/session-conductor/trash/restore",
-    handler: async (req, res) => {
-      try {
-        const body = await readJson(req);
-        const ids = Array.isArray(body?.sessionIds) ? body.sessionIds : [];
-        if (ids.length === 0) return send(res, 400, { ok: false, error: { code: "bad-request", message: "sessionIds 不能为空" } });
-        const result = restoreSessions(ctx, ids);
-        if (result.restored.length > 0) touchList();
-        send(res, 200, { ok: true, ...result });
-      } catch (error) {
-        send(res, 400, { ok: false, error: { code: "restore-failed", message: String(error?.message ?? error) } });
-      }
-    },
+  route("/api/session-conductor/trash/restore", "restore-failed", 400, (body, res) => {
+    const ids = Array.isArray(body?.sessionIds) ? body.sessionIds : [];
+    if (ids.length === 0) return send(res, 400, { ok: false, error: { code: "bad-request", message: "sessionIds 不能为空" } });
+    const restoreResult = restoreSessions(ctx, ids);
+    if (restoreResult.restored.length > 0) touchList();
+    send(res, 200, { ok: true, ...restoreResult });
   });
 
   // ---------- POST /api/session-conductor/trash/restore-last-batch ----------
   // 撤销：还原最近一个批次的全部删除（一次删除操作 = 一个 batchId）
-  webServer.register({
-    kind: "exact",
-    path: "/api/session-conductor/trash/restore-last-batch",
-    handler: async (req, res) => {
-      try {
-        const batch = latestBatch(ctx);
-        if (!batch) return send(res, 200, { ok: true, batchId: null, restored: [], message: "回收站是空的" });
-        const result = restoreSessions(ctx, batch.ids);
-        if (result.restored.length > 0) touchList();
-        send(res, 200, { ok: true, batchId: batch.batchId, restored: result.restored });
-      } catch (error) {
-        send(res, 400, { ok: false, error: { code: "restore-batch-failed", message: String(error?.message ?? error) } });
-      }
-    },
+  route("/api/session-conductor/trash/restore-last-batch", "restore-batch-failed", 400, (_body, res) => {
+    const batch = latestBatch(ctx);
+    if (!batch) return send(res, 200, { ok: true, batchId: null, restored: [], message: "回收站是空的" });
+    const restoreResult = restoreSessions(ctx, batch.ids);
+    if (restoreResult.restored.length > 0) touchList();
+    send(res, 200, { ok: true, batchId: batch.batchId, restored: restoreResult.restored });
   });
 
   // ---------- POST /api/session-conductor/trash/empty ----------
   // 一键清空：立即真删（不可恢复），要求 body.confirm === true
-  webServer.register({
-    kind: "exact",
-    path: "/api/session-conductor/trash/empty",
-    handler: async (req, res) => {
-      try {
-        const body = await readJson(req);
-        if (body?.confirm !== true) {
-          return send(res, 400, { ok: false, error: { code: "need-confirm", message: "清空回收站不可恢复，需传 confirm=true" } });
-        }
-        const result = await emptyTrash(ctx);
-        touchList();
-        send(res, 200, { ok: true, ...result });
-      } catch (error) {
-        send(res, 400, { ok: false, error: { code: "empty-failed", message: String(error?.message ?? error) } });
-      }
-    },
+  route("/api/session-conductor/trash/empty", "empty-failed", 400, async (body, res) => {
+    if (body?.confirm !== true) {
+      return send(res, 400, { ok: false, error: { code: "need-confirm", message: "清空回收站不可恢复，需传 confirm=true" } });
+    }
+    const emptyResult = await emptyTrash(ctx);
+    touchList();
+    send(res, 200, { ok: true, ...emptyResult });
   });
 
   // ---------- POST /api/session-conductor/trash/retention ----------
   // body: { days: number } → 设置保留天数（1~365）
-  webServer.register({
-    kind: "exact",
-    path: "/api/session-conductor/trash/retention",
-    handler: async (req, res) => {
-      try {
-        const body = await readJson(req);
-        const days = Number(body?.days);
-        if (!Number.isFinite(days) || days < 1) {
-          return send(res, 400, { ok: false, error: { code: "bad-request", message: "days 必须是 ≥1 的数字" } });
-        }
-        const value = setRetentionDays(ctx, days);
-        send(res, 200, { ok: true, retentionDays: value });
-      } catch (error) {
-        send(res, 400, { ok: false, error: { code: "retention-failed", message: String(error?.message ?? error) } });
-      }
-    },
+  route("/api/session-conductor/trash/retention", "retention-failed", 400, (body, res) => {
+    const days = Number(body?.days);
+    if (!Number.isFinite(days) || days < 1) {
+      return send(res, 400, { ok: false, error: { code: "bad-request", message: "days 必须是 ≥1 的数字" } });
+    }
+    send(res, 200, { ok: true, retentionDays: setRetentionDays(ctx, days) });
   });
 
   // ---------- POST /api/session-conductor/trash/purge ----------
   // 手动触发到期清理（面板打开时也会自动触发一次；这里供脚本/排查用）
-  webServer.register({
-    kind: "exact",
-    path: "/api/session-conductor/trash/purge",
-    handler: async (req, res) => {
-      try {
-        const result = await purgeExpiredTrash(ctx);
-        if (result.deleted.length > 0) touchList();
-        send(res, 200, { ok: true, ...result });
-      } catch (error) {
-        send(res, 400, { ok: false, error: { code: "purge-failed", message: String(error?.message ?? error) } });
-      }
-    },
+  route("/api/session-conductor/trash/purge", "purge-failed", 400, async (_body, res) => {
+    const purgeResult = await purgeExpiredTrash(ctx);
+    if (purgeResult.deleted.length > 0) touchList();
+    send(res, 200, { ok: true, ...purgeResult });
   });
 }