dsh-session-conductor 1.3.7 → 1.3.9

package/lib/core/index-store.js

@@ -0,0 +1,148 @@
+// 插件索引的唯一落盘位置：<DSH_HOME>/storages/dsh-session-conductor/index.json
+//
+// 【为什么要收敛】此前每类索引各写一个文件（list-cache.json / value-index.json / trash.json），
+// 于是同一个目录里躺着三套「版本号 + 原子写 + 路径解析」的复制品：改一处忘一处、
+// 备份/迁移要记三份名字、出问题时不知道先看哪个。现在统一成**一个文件、一个版本号、一个原子写**，
+// 各模块只关心自己的 section。
+//
+// 【结构】
+//   {
+//     version: 1,
+//     list:  { entries: { [sessionId]: {...} } },          // 会话列表解析缓存
+//     value: { entries: { [sessionId]: {...} } },          // 价值判定索引
+//     trash: { entries: { [sessionId]: {...} }, retentionDays }  // 回收站
+//   }
+//
+// 【迁移】首次加载若发现旧文件，按 section 合并进来，并把旧文件改名为
+// `<原名>.migrated`（不删、可回滚）。
+//
+// 【写入】原子写（tmp + rename）。整文件重写：当前规模 30~80 KB、序列化 ~1 ms，
+// 各模块的写盘本来就有节流/低频，代价可忽略；等真到上千条再评估换存储。
+
+import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from "node:fs";
+import path from "node:path";
+
+import { cfg, resolveDshHome } from "./config.js";
+
+const STORE_VERSION = 1;
+const STORE_SUBDIR = ["storages", "dsh-session-conductor"];
+const STORE_FILE = "index.json";
+/** 旧文件 → section 名（迁移用） */
+const LEGACY_FILES = [
+  ["list-cache.json", "list"],
+  ["value-index.json", "value"],
+  ["trash.json", "trash"],
+];
+
+let storeCache = null;
+let storePath = null;
+
+/** 索引文件绝对路径（首次解析后缓存）。 */
+export function storeFilePath(ctx) {
+  if (storePath !== null) return storePath;
+  const home = resolveDshHome(ctx, cfg);
+  storePath = home ? path.join(home, ...STORE_SUBDIR, STORE_FILE) : "";
+  return storePath;
+}
+
+/** 空结构（各 section 都带默认值，调用方不必判空）。 */
+function emptyStore() {
+  return { version: STORE_VERSION, list: { entries: {} }, value: { entries: {} }, trash: { entries: {} } };
+}
+
+/**
+ * 读索引（进程内只读一次）。文件缺失/损坏 → 空结构；随后尝试从旧文件迁移一次。
+ */
+export function loadStore(ctx) {
+  if (storeCache !== null) return storeCache;
+  storeCache = emptyStore();
+  const file = storeFilePath(ctx);
+  if (!file) return storeCache;
+  let loaded = false;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (parsed && typeof parsed === "object") {
+      storeCache = {
+        version: STORE_VERSION,
+        list: { entries: parsed.list?.entries && typeof parsed.list.entries === "object" ? parsed.list.entries : {} },
+        value: { entries: parsed.value?.entries && typeof parsed.value.entries === "object" ? parsed.value.entries : {} },
+        trash: {
+          entries: parsed.trash?.entries && typeof parsed.trash.entries === "object" ? parsed.trash.entries : {},
+          ...(Number.isFinite(parsed.trash?.retentionDays) ? { retentionDays: parsed.trash.retentionDays } : {}),
+        },
+      };
+      loaded = true;
+    }
+  } catch {
+    // 首次运行 / 文件损坏：保持空结构
+  }
+  if (!loaded) migrateLegacyFiles(ctx);
+  return storeCache;
+}
+
+/**
+ * 一次性迁移旧文件：按 section 合并，成功则把旧文件改名 `.migrated`（保留可回滚）。
+ * 任一文件解析失败就跳过它（不阻断启动）。
+ */
+function migrateLegacyFiles(ctx) {
+  const file = storeFilePath(ctx);
+  if (!file) return;
+  const dir = path.dirname(file);
+  let migratedAny = false;
+  for (const [legacyName, section] of LEGACY_FILES) {
+    const legacyPath = path.join(dir, legacyName);
+    if (!existsSync(legacyPath)) continue;
+    try {
+      const parsed = JSON.parse(readFileSync(legacyPath, "utf8"));
+      const entries = parsed?.entries && typeof parsed.entries === "object" ? parsed.entries : null;
+      if (entries) {
+        storeCache[section] = {
+          entries,
+          ...(section === "trash" && Number.isFinite(parsed?.retentionDays) ? { retentionDays: parsed.retentionDays } : {}),
+        };
+        migratedAny = true;
+      }
+      // 迁移后改名：不删除，出问题可人工回滚
+      renameSync(legacyPath, `${legacyPath}.migrated`);
+    } catch {
+      // 旧文件坏了：跳过，保持空 section
+    }
+  }
+  if (migratedAny) saveStoreNow(ctx);
+}
+
+/** 立即落盘（原子写：tmp + rename）。失败只丢本次写入，不抛。 */
+export function saveStoreNow(ctx) {
+  const file = storeFilePath(ctx);
+  if (!file || storeCache === null) return false;
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const tmpPath = `${file}.tmp-${process.pid}`;
+    writeFileSync(tmpPath, JSON.stringify(storeCache), "utf8");
+    renameSync(tmpPath, file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** 取某个 section（不存在时给默认值）。 */
+export function getSection(ctx, name) {
+  const store = loadStore(ctx);
+  if (!store[name]) store[name] = { entries: {} };
+  if (!store[name].entries || typeof store[name].entries !== "object") store[name].entries = {};
+  return store[name];
+}
+
+/** 写某个 section（只改内存，落盘由调用方决定时机）。 */
+export function setSection(ctx, name, value) {
+  const store = loadStore(ctx);
+  store[name] = value;
+  return store[name];
+}
+
+/** 测试钩子：清空内存态。 */
+export function resetStoreForTest() {
+  storeCache = null;
+  storePath = null;
+}

package/lib/features/rename/analysis.js

@@ -173,6 +173,12 @@ export async function analyzeSession(ctx, sessionId, opts = {}) {
   } catch (error) {
     return { ok: false, before: currentTitle, after: currentTitle, error: { code: "rename-failed", message: String(error?.message ?? error) } };
   }
+  // 改完标题立刻让列表缓存作废：冷会话的标题来自落盘索引（revision 没变就不重算），
+  // 不作废就会出现「后端已改名、面板还显示旧标题」。
+  try {
+    const { markSessionListStale } = await import("../../sessions/list-cache.js");
+    markSessionListStale(ctx, session.id);
+  } catch { /* 缓存作废失败不影响重命名本身 */ }
   log(ctx, `自动重命名 ${sessionId}: "${currentTitle ?? "（无标题）"}" → "${finalTitle}"`);
   return { ok: true, renamed: true, before: currentTitle, after: finalTitle, title: finalTitle, reason: "对话主题明显偏移，已自动重命名" };
 }

package/lib/features/rename/title.js

@@ -150,6 +150,11 @@ export async function refreshTitleState(ctx, session) {
   if (next === current) return null;
   try {
     titleService.rename(session, next);
+    // 状态后缀变了也是「可见属性变了」，同样要让列表缓存与落盘索引作废
+    try {
+      const { markSessionListStale } = await import("../../sessions/list-cache.js");
+      markSessionListStale(ctx, session.id);
+    } catch { /* 作废失败不影响标题刷新 */ }
     return next;
   } catch (error) {
     log(ctx, `标题状态刷新失败 ${session.id}: ${String(error?.message ?? error)}`);

package/lib/features/search.js

@@ -88,7 +88,9 @@ export function searchEventsText(events, query, { perSessionMax = SEARCH_PER_SES
 export async function searchSessions(ctx, query, { scope = "all", maxSessions = SEARCH_MAX_SESSIONS, perSessionMax = SEARCH_PER_SESSION_MAX } = {}) {
   const queryText = String(query ?? "").trim();
   if (queryText.length < SEARCH_MIN_QUERY) return { query: queryText, scanned: 0, hits: [] };
-  const sessions = await buildSessionListCached(ctx, { force: true }); // 搜索需绝对新鲜，绕过缓存
+  // 列表用缓存版本（不 force）：一次全量重建本机实测 41~226 秒，而搜索只需要「会话 id 清单」，
+  //   新建会话最多晚一个 TTL（默认 5 秒）出现，代价远小于每次都把上百份日志重解一遍。
+  const sessions = await buildSessionListCached(ctx);
   const hits = [];
   let scanned = 0;
   for (const s of sessions) {
@@ -99,7 +101,7 @@ export async function searchSessions(ctx, query, { scope = "all", maxSessions =
     try {
       const found = await sessionEventsOf(ctx, s.id);
       if (!found) continue;
-      const matches = searchEventsText(found.events, q, { perSessionMax });
+      const matches = searchEventsText(found.events, queryText, { perSessionMax });
       if (matches.length > 0) {
         hits.push({
           sessionId: s.id,
@@ -115,5 +117,5 @@ export async function searchSessions(ctx, query, { scope = "all", maxSessions =
       /* 单个会话失败跳过（损坏日志等），不中断整体搜索 */
     }
   }
-  return { query: q, scanned, hits };
+  return { query: queryText, scanned, hits };
 }

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

@@ -163,15 +163,29 @@ export async function listSessions(ctx) {
 }
 
 /**
- * best-effort 描述目标会话（dryRun 用）：从会话列表里找到它，报告状态与工作区。
- * 列表不可用时如实说明原因，**不阻断**（dryRun 的价值在于「早知道」，不该因为列表拿不到就失败）。
+ * best-effort 描述目标会话（dryRun 用）：报告状态与工作区。
+ *
+ * 【必须只查便宜来源】内存里的 live 会话 → 落盘索引（list-cache.json）。
+ * 曾经这里调 listSessions()（= 全量列表构建），冷缓存时一次 dryRun 预检要 41~226 秒 ——
+ * 「校验 + 预览」本该是毫秒级的事，却变成卡死。预检的正确成本上限是「读一次内存/索引」，
+ * 不是「扫一遍所有会话日志」；查不到就如实说查不到，不为了补一个状态字段去付全量代价。
+ * 列表不可用时如实说明原因，**不阻断**（dryRun 的价值在于「早知道」）。
  */
 export async function describeTarget(ctx, sessionId) {
   try {
-    const items = await listSessions(ctx);
-    const hit = (Array.isArray(items) ? items : []).find((item) => item?.id === sessionId);
-    if (!hit) return "（⚠️ 会话列表里没有这个 id —— 可能写错了，或它是刚建、尚未落盘的会话）";
-    return `（${statusOf(hit)}${hit.archived ? " / 已归档" : ""} ｜ ${String(hit.cwd ?? "(无工作区)")}）`;
+    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 —— 可能写错了，或它是刚建、尚未落盘的会话）";
   } catch (error) {
     return `（目标存在性无法核对：${shortError(error)}）`;
   }

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

@@ -62,12 +62,25 @@ export async function readListIndex(ctx) {
   const { loadListDiskCache } = await import("../../sessions/list-cache.js");
   const entries = loadListDiskCache(ctx)?.entries;
   if (!entries || typeof entries !== "object") return null;
-  return Object.entries(entries).map(([id, e]) => ({
+  // 归档态：索引文件里没存（它是宿主持久化的名单），但取它很便宜（一次内存读），
+  // 顺手带上 —— 否则面板「先读索引出列表」时按归档筛选会全部落空。
+  const registry = ctx.get?.("workspaceRegistry");
+  const archived = new Set(
+    (registry?.archivedSessionIds ?? []).filter((id) => typeof id === "string" && id !== ""),
+  );
+  // 回收站里的会话同样从索引直读里排除（否则面板先读索引时又会把它显示出来）
+  let hidden = new Set();
+  try {
+    const { trashedIds } = await import("../features/trash.js");
+    hidden = trashedIds(ctx);
+  } catch { /* 回收站不可用不影响索引 */ }
+  return Object.entries(entries).filter(([id]) => !hidden.has(id)).map(([id, e]) => ({
     id,
     title: e?.title ?? null,
     cwd: e?.cwd ?? null,
     updatedAt: e?.updatedAt ?? e?.createdAt ?? 0,
     parentSession: e?.parentSession ?? null,
+    archived: archived.has(id),
     fromIndex: true,
   }));
 }

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

@@ -9,7 +9,8 @@
 import { log } from '../shared/log.js';
 import { MSG_NEED_SESSION_ID } from '../shared/constants.js';
 import { titleString, foldTitle, workspaceNameOf, archiveTitleWithWs, stripArchiveWsPrefix } from './rename/title.js';
-import { unarchiveSession, deleteSession, undoLastMessage, deleteBatchSessions, deleteByRule } from './session-ops.js';
+import { unarchiveSession, deleteSession, undoLastMessage, deleteBatchSessions, deleteByRule, emptyTrash, purgeExpiredTrash } from './session-ops.js';
+import { listTrash, latestBatch, restoreSessions, retentionDays, setRetentionDays, loadTrash } from './trash.js';
 
 /** 按规则删除时「超期未活跃天数」入参上限（约 10 年）：防离谱值把全部会话一起圈进去。 */
 const MAX_INACTIVE_DAYS = 3650;
@@ -75,6 +76,11 @@ export function registerSessionOpsRoutes({ webServer, ctx, send, readJson, inval
               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}"`);
               }
             }
@@ -111,6 +117,10 @@ export function registerSessionOpsRoutes({ webServer, ctx, send, readJson, inval
               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}"`);
               }
             }
@@ -207,6 +217,10 @@ export function registerSessionOpsRoutes({ webServer, ctx, send, readJson, inval
               ? 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);
@@ -216,3 +230,133 @@ export function registerSessionOpsRoutes({ webServer, ctx, send, readJson, inval
       },
     });
 }
+
+/**
+ * 注册回收站相关路由。
+ *
+ * 设计要点：删除只是「打标记」，所以还原几乎零成本（文件从没动过）；
+ * 真正删盘只发生在「到期清理」与「一键清空」，两者都要二次确认或由定时器触发。
+ * @param {object} deps
+ * @param {object} deps.webServer 宿主 webServer 服务
+ * @param {object} deps.ctx 插件 ctx
+ * @param {Function} deps.send 响应发送工具
+ * @param {Function} deps.readJson 请求体解析工具
+ * @param {Function} deps.invalidateSessionListCache 会话列表缓存失效（还原后要立刻重新出现）
+ */
+export function registerTrashRoutes({ webServer, ctx, send, readJson, invalidateSessionListCache }) {
+  const touchList = () => {
+    try { invalidateSessionListCache?.(); } catch { /* 失效失败不影响回收站操作 */ }
+  };
+
+  // ---------- GET /api/session-conductor/trash ----------
+  webServer.register({
+    kind: "exact",
+    path: "/api/session-conductor/trash",
+    handler: async (req, res) => {
+      try {
+        if ((req.method ?? "GET") !== "GET") return send(res, 405, { ok: false, error: { code: "METHOD", message: "Method Not Allowed" } });
+        send(res, 200, {
+          ok: true,
+          retentionDays: retentionDays(ctx),
+          items: listTrash(ctx),
+          latestBatch: latestBatch(ctx),
+        });
+      } catch (error) {
+        send(res, 500, { ok: false, error: { code: "trash-list-failed", message: String(error?.message ?? error) } });
+      }
+    },
+  });
+
+  // ---------- 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) } });
+      }
+    },
+  });
+
+  // ---------- 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) } });
+      }
+    },
+  });
+
+  // ---------- 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) } });
+      }
+    },
+  });
+
+  // ---------- 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) } });
+      }
+    },
+  });
+
+  // ---------- 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) } });
+      }
+    },
+  });
+}

package/lib/features/session-ops.js

@@ -18,6 +18,8 @@ import {
 } from "../core/config.js";
 import { sessionEventsOf } from "../sessions/events.js";
 import { detachSessionAgent } from "../sessions/detach.js";
+import { markDeleted, forgetTrashed, expiredIds, loadTrash, saveTrashNow } from "./trash.js";
+import { invalidateSessionListCache } from "../sessions/list-cache.js";
 import { buildSessionListCached } from "../sessions/list.js";
 
 // ---------- 插件开关配置（：落盘 <DSH_HOME>/session-conductor/config.json）----------
@@ -105,13 +107,13 @@ export async function unarchiveSession(ctx, sessionId) {
   });
 }
 
-/** 删除会话（per-session 串行锁）：拒绝运行中/续跑中 → detach → 取消归档 → 记账清理 → 删磁盘日志 → 清理遗留定时器。
- *  同一会话的并发删除请求排队串行执行（withDeleteLock），不做交错。 */
-export async function deleteSession(ctx, sessionId) {
+/** 真删（物理删除）：拒绝运行中/续跑中 → detach → 取消归档 → 记账清理 → 删磁盘日志 → 清理遗留定时器。
+ *  同一会话的并发删除排队串行执行（withDeleteLock），不做交错。
+ *  ⚠️ 只由回收站调用（到期清理 / 一键清空），面板上的「删除」走 deleteSession（只打标记）。 */
+export async function deleteSessionPhysically(ctx, sessionId) {
   return withDeleteLock(sessionId, async () => {
     const sessions = ctx.get("sessions");
     const workspaceRegistry = ctx.get("workspaceRegistry");
-    const persistence = ctx.get("sessionPersistence");
 
     // 0. 运行中 / 续跑中的会话拒绝删除
     const live = sessions?.get(sessionId);
@@ -140,11 +142,16 @@ export async function deleteSession(ctx, sessionId) {
     // 4. 删除磁盘 artifact（session 目录）。sqlite 查询索引会对账自动清理。
     //    先 detach 再删文件：持久化协调器在 session/disposed 后退休该会话，
     //    不会再把它写回磁盘。
-    if (persistence?.listArtifacts) {
-      const artifacts = await persistence.listArtifacts();
-      const artifact = artifacts.find((entry) => entry.header?.id === sessionId);
-      if (artifact?.path) {
-        const sessionDir = path.dirname(artifact.path);
+    //
+    //    ⚠️ 0.2.x 已移除 `persistence.listArtifacts`：原实现整段是死代码 ——
+    //    只做了 detach、**文件一个没删**，重启后会话原样回来（表现为「删除成功但没删掉」）。
+    //    现在直接按 id 定位日志文件（findSessionLogById 扫 <DSH_HOME>/sessions/<project>/<id>/），
+    //    取其所在目录删除。
+    try {
+      const { findSessionLogById, sessionsRootOf } = await import("../sessions/events.js");
+      const logPath = findSessionLogById(sessionId, sessionsRootOf());
+      if (logPath) {
+        const sessionDir = path.dirname(logPath);
         await rm(sessionDir, { recursive: true, force: true });
         // 尽力清理空的 project 目录（会话删光后不留空壳）
         const projectDir = path.dirname(sessionDir);
@@ -154,6 +161,20 @@ export async function deleteSession(ctx, sessionId) {
           // 目录非空或不可读，保留即可
         }
       }
+    } catch {
+      // 定位/删除失败不阻断（内存侧已 detach），文件会留下 —— 下次删除会再试
+    }
+
+    // 4.5 同步清理两份**落盘索引**：删掉的会话不能在索引里继续存在。
+    //     面板现在先读落盘索引出列表（否则冷缓存要等 41~226 秒），索引不清就会出现
+    //     「删掉了、刷新又回来」；价值索引同理（下次筛选还会把它当低价值勾出来）。
+    try {
+      const { forgetSessionInListCache } = await import("../sessions/list-cache.js");
+      forgetSessionInListCache(ctx, sessionId);
+      const { forgetValueVerdict } = await import("./value-index.js");
+      forgetValueVerdict(ctx, sessionId);
+    } catch {
+      // 索引清理失败不影响删除本身（下次全量重建会自然 prune 掉）
     }
 
     // 5. 清理自动重命名 / 自动续跑开关（config.json 两组同步清，防同名会话重建后误判）
@@ -177,6 +198,68 @@ export async function deleteSession(ctx, sessionId) {
   });
 }
 
+// ---------- 删除 = 打回收站标记 ----------
+
+/**
+ * 会话快照（回收站列表展示用）：只查便宜来源（内存 live → 落盘索引），**不跑全量列表构建**。
+ * 预检/快照的成本上限是「读一次内存或索引」，不是「扫一遍所有会话日志」。
+ */
+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 {};
+  }
+}
+
+/**
+ * 删除会话 = **只打回收站标记**（会话文件原样保留）。
+ * 运行中/续跑中仍然拒绝（删一个正在跑的会话没有意义）。
+ * 真正删盘只发生在：回收站到期（保留天数可配，默认 7 天）或「一键清空」。
+ */
+export async function deleteSession(ctx, sessionId) {
+  const result = await deleteBatchSessions(ctx, [sessionId]);
+  if (result.deleted.length > 0) return { ok: true, trashed: true, batchId: result.batchId };
+  const reason = result.skipped[0]?.reason ?? "error";
+  const message = reason === "running" ? "会话正在运行，无法删除" : "删除失败：会话不存在或不可读";
+  return { ok: false, error: { code: reason, message } };
+}
+
+/** 到期真删：把超过保留天数的条目从磁盘上删掉（只由定时器/手动清理调用）。 */
+export async function purgeExpiredTrash(ctx, now = Date.now()) {
+  const ids = expiredIds(ctx, now);
+  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 (deleted.length > 0) { saveTrashNow(ctx); invalidateSessionListCache(); }
+  return { deleted, remaining: ids.length - deleted.length };
+}
+
+/** 一键清空：立即真删回收站里的全部会话（不可恢复）。 */
+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 { /* 单条失败跳过 */ }
+  }
+  saveTrashNow(ctx);
+  invalidateSessionListCache();
+  return { deleted, remaining: ids.length - deleted.length };
+}
+
 // ---------- 撤回最后一条用户消息 ----------
 
 /**
@@ -311,43 +394,33 @@ export async function deleteBatchSessions(ctx, sessionIds) {
   const ids = [...new Set(
     (Array.isArray(sessionIds) ? sessionIds : []).filter((id) => typeof id === "string" && id !== "")
   )];
-  const deleted = [];
   const skipped = [];
-  // 修复：预检会话是否存在（live 或已持久化），不存在的进 skipped(not-found)，
-  // 不再被误报为「已删除」。persistence 不可用/返回空（如测试 mock）时保守处理：
-  // 仅当「明确知道不存在」才跳过，否则交给 deleteSession 正常判定。
-  const persistence = ctx.get("sessionPersistence");
-  const persistIds = new Set();
-  let canCheckPersist = false;
-  try {
-    // 持久化会话权威来源 = persistence.list()（mock 与真实实现都提供）；
-    // listArtifacts 仅作补充（可能未实现/返回空，不代表会话不存在）
-    if (persistence?.list) {
-      const metas = await persistence.list();
-      if (Array.isArray(metas)) {
-        canCheckPersist = true;
-        for (const m of metas) if (m?.id) persistIds.add(m.id);
-      }
-    }
-  } catch { canCheckPersist = false; }
+  const targets = [];
   const sessionsSvc = ctx.get("sessions");
-  const liveIds = new Set(sessionsSvc?.list?.()?.map((s) => s.id) ?? []);
+  const { findSessionLogById, sessionsRootOf } = await import("../sessions/events.js");
   for (const id of ids) {
-    // 仅当列表查询可用且明确不在其中 → not-found；否则尝试删除
-    const knownMissing = canCheckPersist ? (!liveIds.has(id) && !persistIds.has(id)) : false;
-    if (knownMissing) {
-      skipped.push({ sessionId: id, reason: "not-found" });
-      continue;
-    }
-    try {
-      const deleteResult = await deleteSession(ctx, id);
-      if (deleteResult.ok) deleted.push(id);
-      else skipped.push({ sessionId: id, reason: deleteResult.error?.code ?? "error" });
-    } catch {
-      skipped.push({ sessionId: id, reason: "error" });
+    // 运行中 / 续跑中：拒绝（删一个正在跑的会话没有意义）
+    const live = sessionsSvc?.get?.(id);
+    if (live && hasOpenTurn(live.events)) { skipped.push({ sessionId: id, reason: "running" }); continue; }
+    if (continueJobs.has(id)) { skipped.push({ sessionId: id, reason: "running" }); continue; }
+    // 存在性：live 或磁盘上确实有日志；都没有才 not-found（避免往回收站里塞垃圾 id）
+    let exists = Boolean(live);
+    if (!exists) {
+      try { exists = Boolean(findSessionLogById(id, sessionsRootOf())); } catch { exists = false; }
     }
+    if (!exists) { skipped.push({ sessionId: id, reason: "not-found" }); continue; }
+    targets.push(id);
   }
-  return { requested: ids.length, deleted, skipped };
+  if (targets.length === 0) return { requested: ids.length, deleted: [], skipped, batchId: null };
+
+  // 快照（回收站列表要显示标题/目录/删除时间）+ 统一批次号
+  const metaById = {};
+  for (const id of targets) metaById[id] = await describeForTrash(ctx, id);
+  const { batchId, marked } = markDeleted(ctx, targets, metaById);
+
+  // 列表里立刻隐藏（面板/工具都读列表与索引，两处都要失效）
+  invalidateSessionListCache();
+  return { requested: ids.length, deleted: marked, skipped, batchId };
 }
 
 /**