dsh-session-conductor 1.3.9 → 1.3.11

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

package/lib/features/session-ops.js

@@ -1,7 +1,7 @@
 /** 会话级操作：归档恢复、删除（单个/批量/按规则）、撤回最后一条消息。 */
 
 import { rm, readdir } from "node:fs/promises";
-import { readFileSync, copyFileSync, writeFileSync, renameSync, mkdirSync, chmodSync, statSync } from "node:fs";
+import { readFileSync, copyFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { hasOpenTurn } from "../sessions/turn.js";
 import { lazyRepair, lazyZstd, lazyValue } from "../core/lazy.js";
@@ -18,6 +18,8 @@ import {
 } from "../core/config.js";
 import { sessionEventsOf } from "../sessions/events.js";
 import { detachSessionAgent } from "../sessions/detach.js";
+import { sessionMetaOf } from "../sessions/lookup.js";
+import { replaceFileSync } from "../shared/atomic-file.js";
 import { markDeleted, forgetTrashed, expiredIds, loadTrash, saveTrashNow } from "./trash.js";
 import { invalidateSessionListCache } from "../sessions/list-cache.js";
 import { buildSessionListCached } from "../sessions/list.js";
@@ -205,17 +207,9 @@ export async function deleteSessionPhysically(ctx, sessionId) {
  * 预检/快照的成本上限是「读一次内存或索引」，不是「扫一遍所有会话日志」。
  */
 async function describeForTrash(ctx, sessionId) {
-  try {
-    const live = ctx.get("sessions")?.get?.(sessionId);
-    if (live) {
-      return { title: live.title ?? null, cwd: live.header?.cwd ?? null, updatedAt: null, archived: false };
-    }
-    const { loadListDiskCache } = await import("../sessions/list-cache.js");
-    const entry = loadListDiskCache(ctx)?.entries?.[sessionId];
-    return { title: entry?.title ?? null, cwd: entry?.cwd ?? null, updatedAt: entry?.updatedAt ?? null, archived: false };
-  } catch {
-    return {};
-  }
+  const meta = await sessionMetaOf(ctx, sessionId);
+  if (!meta) return {};
+  return { title: meta.title, cwd: meta.cwd, updatedAt: meta.updatedAt, archived: meta.archived };
 }
 
 /**
@@ -232,32 +226,44 @@ export async function deleteSession(ctx, sessionId) {
 }
 
 /** 到期真删：把超过保留天数的条目从磁盘上删掉（只由定时器/手动清理调用）。 */
-export async function purgeExpiredTrash(ctx, now = Date.now()) {
-  const ids = expiredIds(ctx, now);
+/**
+ * 逐条真删：到期清理与一键清空共用同一条链路（单条失败只跳过，不影响其余）。
+ * @returns {{deleted: string[], remaining: number}}
+ */
+async function purgeMany(ctx, ids) {
   const deleted = [];
   for (const id of ids) {
     try {
       const result = await deleteSessionPhysically(ctx, id);
-      if (result?.ok) { forgetTrashed(ctx, [id]); deleted.push(id); }
-    } catch { /* 单条失败跳过，下次再试 */ }
+      if (result?.ok) {
+        forgetTrashed(ctx, [id]);
+        deleted.push(id);
+      }
+    } catch {
+      // 单条失败跳过：下一次清理会再试，不阻断其余会话
+    }
   }
-  if (deleted.length > 0) { saveTrashNow(ctx); invalidateSessionListCache(); }
   return { deleted, remaining: ids.length - deleted.length };
 }
 
+/** 到期真删：把超过保留天数的条目从磁盘上删掉（只由定时器/手动清理调用）。 */
+export async function purgeExpiredTrash(ctx, now = Date.now()) {
+  const ids = expiredIds(ctx, now);
+  const result = await purgeMany(ctx, ids);
+  if (result.deleted.length > 0) {
+    saveTrashNow(ctx);
+    invalidateSessionListCache();
+  }
+  return result;
+}
+
 /** 一键清空：立即真删回收站里的全部会话（不可恢复）。 */
 export async function emptyTrash(ctx) {
   const ids = Object.keys(loadTrash(ctx).entries);
-  const deleted = [];
-  for (const id of ids) {
-    try {
-      const result = await deleteSessionPhysically(ctx, id);
-      if (result?.ok) { forgetTrashed(ctx, [id]); deleted.push(id); }
-    } catch { /* 单条失败跳过 */ }
-  }
+  const result = await purgeMany(ctx, ids);
   saveTrashNow(ctx);
   invalidateSessionListCache();
-  return { deleted, remaining: ids.length - deleted.length };
+  return result;
 }
 
 // ---------- 撤回最后一条用户消息 ----------
@@ -376,10 +382,7 @@ export async function undoLastMessage(ctx, sessionId, { dryRun = false } = {}) {
     // 6. 多帧写回（header 一帧 + body 一帧，带 checksum），原子替换
     const { encodeSessionText } = await lazyRepair();
     const newBuf = await encodeSessionText(newText);
-    const undoTmpPath = filePath + ".undotmp";
-    writeFileSync(undoTmpPath, newBuf);
-    try { chmodSync(undoTmpPath, statSync(filePath).mode); } catch { /* CIFS 无 chmod，尽力 */ }
-    renameSync(undoTmpPath, filePath);
+    replaceFileSync(filePath, newBuf, { tmpSuffix: ".undotmp" });
 
     return { ok: true, preview, removedLineCount, removedEventCount, remainingEventCount: check.eventCount, backup: bak };
   });

package/lib/repair.js

@@ -280,7 +280,8 @@ export async function repairCorruptSessions(ctx, { dryRun = false } = {}) {
       report.fixed += 1;
       report.backups.push(backupPath);
       report.sessions.push({ ...entry, fixedBlocks: fixedCount, backup: backupPath });
-      try { ctx.logger?.info?.(`dsh-session-conductor: 已修复会话 ${id}（${fixedCount} 个块）`); } catch {}
+      // 日志失败不影响修复结果本身
+      try { ctx.logger?.info?.(`dsh-session-conductor: 已修复会话 ${id}（${fixedCount} 个块）`); } catch { /* 日志失败忽略 */ }
     } catch (error) {
       report.errors.push({ id, error: `修复失败: ${String(error?.message ?? error)}` });
       report.sessions.push(entry);
@@ -394,8 +395,9 @@ export async function scanDualFormatSessions() {
       const zstd = findSessionLog(sessionDir);
       if (!plain || !zstd) continue;
       let plainBytes = 0, zstdBytes = 0;
-      try { plainBytes = statSync(plain).size; } catch {}
-      try { zstdBytes = statSync(zstd).size; } catch {}
+      // stat 失败（文件刚被移走等）按 0 字节展示，不阻断扫描
+      try { plainBytes = statSync(plain).size; } catch { /* 读不到按 0 */ }
+      try { zstdBytes = statSync(zstd).size; } catch { /* 读不到按 0 */ }
       report.dual.push({ id: sess, dir: sessionDir, plainBytes, zstdBytes });
     }
   }