dsh-session-conductor 1.3.7 → 1.3.9

package/lib/features/trash.js

@@ -0,0 +1,206 @@
+// 会话回收站：删除只打标记，文件原样保留；到期或手动清空才真正删盘。
+//
+// 【为什么这么设计】删除是不可逆操作，而会话日志动辄几十 MB。把「删除」降级为
+// 「在索引里打一个标记」，就同时得到三件事：
+//   ① 还原是秒级且零风险（文件从没动过）；
+//   ② 误删可撤销（按批次整批还原）；
+//   ③ 真正删盘集中在两个可控时机 —— 到期（保留天数可配，默认 7 天）或一键清空。
+//
+// 【落盘】<DSH_HOME>/storages/dsh-session-conductor/trash.json，原子写（tmp + rename）。
+//   条目：{ [sessionId]: { deletedAt, batchId, title, cwd, updatedAt, archived } }
+//   不存在/损坏都按「空回收站」处理，绝不影响列表与删除本身。
+
+import { cfg } from "../core/config.js";
+import { getSection, setSection, saveStoreNow } from "../core/index-store.js";
+
+const TRASH_VERSION = 1;
+const DEFAULT_RETENTION_DAYS = 7;
+const MAX_RETENTION_DAYS = 365;
+const DAY_MS = 24 * 3600 * 1000;
+
+let trashCache = null;
+
+/** 读回收站（进程内只读一次；索引不可用按空处理）。
+ *  落盘统一走 <DSH_HOME>/storages/dsh-session-conductor/index.json 的 trash section。 */
+export function loadTrash(ctx) {
+  if (trashCache !== null) return trashCache;
+  trashCache = { version: TRASH_VERSION, entries: {} };
+  try {
+    const section = getSection(ctx, "trash");
+    if (section?.entries && typeof section.entries === "object") {
+      trashCache = { version: TRASH_VERSION, entries: section.entries };
+      if (Number.isFinite(section.retentionDays)) trashCache.retentionDays = section.retentionDays;
+    }
+  } catch {
+    // 索引不可用：按空回收站继续
+  }
+  return trashCache;
+}
+
+/** 立即落盘（交给统一索引存储做原子写）。失败只丢内存态，不抛。 */
+export function saveTrashNow(ctx) {
+  if (trashCache === null) return;
+  try {
+    setSection(ctx, "trash", {
+      entries: trashCache.entries,
+      ...(Number.isFinite(trashCache.retentionDays) ? { retentionDays: trashCache.retentionDays } : {}),
+    });
+    saveStoreNow(ctx);
+  } catch {
+    // 写盘失败：下次再试，不影响「已标记」的内存态
+  }
+}
+
+/**
+ * 保留天数：**优先取回收站文件里存的值**（面板上改的就是它），
+ * 没设置过才回落到配置 trashRetentionDays / 默认 7 天。范围 1~365。
+ */
+export function retentionDays(ctx) {
+  const stored = ctx ? Number(loadTrash(ctx).retentionDays) : NaN;
+  if (Number.isFinite(stored) && stored >= 1) return Math.min(MAX_RETENTION_DAYS, Math.round(stored));
+  const days = Number(cfg?.trashRetentionDays);
+  if (!Number.isFinite(days) || days < 1) return DEFAULT_RETENTION_DAYS;
+  return Math.min(MAX_RETENTION_DAYS, Math.round(days));
+}
+
+/** 设置保留天数（写回收站文件，立即生效）。 */
+export function setRetentionDays(ctx, days) {
+  const value = Math.min(MAX_RETENTION_DAYS, Math.max(1, Math.round(Number(days) || DEFAULT_RETENTION_DAYS)));
+  const trash = loadTrash(ctx);
+  trash.retentionDays = value;
+  saveTrashNow(ctx);
+  return value;
+}
+
+/** 当前被标记删除的会话 id 集合（列表/搜索据此隐藏）。 */
+export function trashedIds(ctx) {
+  return new Set(Object.keys(loadTrash(ctx).entries));
+}
+
+/** 单个会话是否在回收站里。 */
+export function isTrashed(ctx, sessionId) {
+  return typeof sessionId === "string" && sessionId !== "" && sessionId in loadTrash(ctx).entries;
+}
+
+/**
+ * 回收站列表（按删除时间倒序），附带到期时间与剩余天数。
+ * @returns {Array<{sessionId,title,cwd,updatedAt,archived,deletedAt,batchId,expiresAt,remainingDays}>}
+ */
+export function listTrash(ctx) {
+  const ttl = retentionDays(ctx) * DAY_MS;
+  const now = Date.now();
+  return Object.entries(loadTrash(ctx).entries)
+    .map(([sessionId, entry]) => {
+      const deletedAt = typeof entry?.deletedAt === "number" ? entry.deletedAt : 0;
+      const expiresAt = deletedAt + ttl;
+      return {
+        sessionId,
+        title: entry?.title ?? null,
+        cwd: entry?.cwd ?? null,
+        updatedAt: entry?.updatedAt ?? null,
+        archived: entry?.archived === true,
+        deletedAt,
+        batchId: entry?.batchId ?? "",
+        expiresAt,
+        remainingDays: Math.max(0, Math.ceil((expiresAt - now) / DAY_MS)),
+      };
+    })
+    .sort((a, b) => b.deletedAt - a.deletedAt);
+}
+
+/** 生成一个批次号（一次删除操作 = 一个批次，撤销按批次整批还原）。 */
+export function newBatchId() {
+  return `b${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+}
+
+/**
+ * 标记删除（不碰文件）。
+ * @param {object} ctx
+ * @param {Array<string>} sessionIds
+ * @param {object} [metaById] 会话快照（title/cwd/updatedAt/archived），用于回收站列表展示
+ * @param {string} [batchId] 指定批次（批量删除传同一个）
+ * @returns {{batchId:string, marked:string[]}}
+ */
+export function markDeleted(ctx, sessionIds, metaById = {}, batchId = newBatchId()) {
+  const trash = loadTrash(ctx);
+  const marked = [];
+  const now = Date.now();
+  for (const id of Array.isArray(sessionIds) ? sessionIds : []) {
+    if (typeof id !== "string" || id === "") continue;
+    const meta = metaById?.[id] ?? {};
+    trash.entries[id] = {
+      deletedAt: now,
+      batchId,
+      title: meta.title ?? null,
+      cwd: meta.cwd ?? null,
+      updatedAt: typeof meta.updatedAt === "number" ? meta.updatedAt : null,
+      archived: meta.archived === true,
+    };
+    marked.push(id);
+  }
+  if (marked.length > 0) saveTrashNow(ctx);
+  return { batchId, marked };
+}
+
+/**
+ * 还原指定会话（删标记，文件本来就在）。
+ * @returns {{restored:string[], missing:string[]}}
+ */
+export function restoreSessions(ctx, sessionIds) {
+  const trash = loadTrash(ctx);
+  const restored = [];
+  const missing = [];
+  for (const id of Array.isArray(sessionIds) ? sessionIds : []) {
+    if (typeof id !== "string" || id === "") continue;
+    if (id in trash.entries) {
+      delete trash.entries[id];
+      restored.push(id);
+    } else {
+      missing.push(id);
+    }
+  }
+  if (restored.length > 0) saveTrashNow(ctx);
+  return { restored, missing };
+}
+
+/** 最近一个批次（撤销用）。空回收站返回 null。 */
+export function latestBatch(ctx) {
+  const entries = Object.entries(loadTrash(ctx).entries);
+  if (entries.length === 0) return null;
+  let best = null;
+  for (const [sessionId, entry] of entries) {
+    const at = typeof entry?.deletedAt === "number" ? entry.deletedAt : 0;
+    if (best === null || at > best.deletedAt) {
+      best = { sessionId, deletedAt: at, batchId: entry?.batchId ?? "" };
+    }
+  }
+  if (best === null) return null;
+  const ids = entries.filter(([, e]) => (e?.batchId ?? "") === best.batchId).map(([id]) => id);
+  return { batchId: best.batchId, deletedAt: best.deletedAt, ids };
+}
+
+/** 已到期（超过保留天数）的会话 id。 */
+export function expiredIds(ctx, now = Date.now()) {
+  const ttl = retentionDays(ctx) * DAY_MS;
+  return Object.entries(loadTrash(ctx).entries)
+    .filter(([, entry]) => {
+      const at = typeof entry?.deletedAt === "number" ? entry.deletedAt : 0;
+      return at > 0 && now - at >= ttl;
+    })
+    .map(([id]) => id);
+}
+
+/** 从回收站移除条目（真删完成后调用；不落盘，由调用方统一保存）。 */
+export function forgetTrashed(ctx, sessionIds) {
+  const trash = loadTrash(ctx);
+  let removed = 0;
+  for (const id of Array.isArray(sessionIds) ? sessionIds : []) {
+    if (id in trash.entries) { delete trash.entries[id]; removed += 1; }
+  }
+  return removed;
+}
+
+/** 测试钩子：清空内存态。 */
+export function resetTrashForTest() {
+  trashCache = null;
+}

package/lib/features/value-index.js

@@ -0,0 +1,120 @@
+// 会话价值索引：把「这条会话值不值得留」的判定结果按会话落盘复用。
+//
+// 【为什么需要】价值判定必须读会话日志（逐帧解压 + 逐行解析），实测本机样本：
+//   0.2 MB ≈ 85 ms、1.6 MB ≈ 311 ms、7 MB ≈ 1.1 s、30 MB ≈ 7 s、86 MB ≈ 16 s（解压吞吐约 5 MB/s）。
+//   上百条会话全量重算就是几十秒起步 —— 而判定结果在「会话没变」时是稳定的，
+//   每次筛选都重算纯属浪费。
+//
+// 【失效判据（两条，任一不满足即重算）】
+//   ① 变更令牌：列表项 updatedAt 变了（说明又追加了事件）→ 旧结论作废；
+//   ② 时间上限：超过 valueIndexTtlHours（默认 24 小时，配置可覆盖）→ 重算一次。
+//   两条合起来的语义是「同一份内容 24 小时内只算一次」。
+//
+// 【落盘】<DSH_HOME>/storages/dsh-session-conductor/value-index.json，原子写（tmp + rename），
+//   节流 2 秒合并多次写入；任何异常都退化为「没有索引」，绝不影响筛选本身。
+
+import { cfg } from "../core/config.js";
+import { getSection, setSection, saveStoreNow } from "../core/index-store.js";
+
+const VALUE_INDEX_VERSION = 1;
+const DEFAULT_TTL_HOURS = 24;
+const SAVE_DEBOUNCE_MS = 2000;
+
+/** { version, entries: { [sessionId]: { at, updatedAt, value, score, reason } } } */
+let indexCache = null;
+let indexPath = null;
+let indexDirty = false;
+let indexTimer = null;
+
+/** 读索引（进程内只读一次；索引不可用都按空处理，不向上抛）。
+ *  落盘统一走 <DSH_HOME>/storages/dsh-session-conductor/index.json 的 value section。 */
+export function loadValueIndex(ctx) {
+  if (indexCache !== null) return indexCache;
+  indexCache = { version: VALUE_INDEX_VERSION, entries: {} };
+  try {
+    const section = getSection(ctx, "value");
+    if (section?.entries && typeof section.entries === "object") {
+      indexCache = { version: VALUE_INDEX_VERSION, entries: section.entries };
+    }
+  } catch {
+    // 索引不可用：按空索引继续
+  }
+  return indexCache;
+}
+
+/** 有效期（毫秒）：默认 24 小时，可由配置 valueIndexTtlHours 覆盖。 */
+export function valueIndexTtlMs() {
+  const hours = Number(cfg?.valueIndexTtlHours);
+  const effective = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_TTL_HOURS;
+  return effective * 3600_000;
+}
+
+/**
+ * 取可复用的判定结果；没有 / 会话变过 / 超期都返回 null（调用方据此决定重算）。
+ * @param {object} ctx 插件上下文
+ * @param {string} sessionId 会话 id
+ * @param {number|null} updatedAt 列表项上的最后活动时间（变更令牌）
+ */
+export function getValueVerdict(ctx, sessionId, updatedAt) {
+  const entry = loadValueIndex(ctx).entries[sessionId];
+  if (!entry) return null;
+  if (typeof updatedAt === "number" && typeof entry.updatedAt === "number" && entry.updatedAt !== updatedAt) return null;
+  if (Date.now() - (entry.at ?? 0) > valueIndexTtlMs()) return null;
+  return entry;
+}
+
+/** 写入一条判定结果（标记脏，节流落盘）。 */
+export function putValueVerdict(ctx, sessionId, updatedAt, verdict) {
+  const index = loadValueIndex(ctx);
+  index.entries[sessionId] = {
+    at: Date.now(),
+    updatedAt: typeof updatedAt === "number" ? updatedAt : null,
+    value: verdict.value,
+    score: verdict.score ?? 0,
+    reason: verdict.reason ?? "",
+  };
+  indexDirty = true;
+  if (indexTimer !== null) return;
+  indexTimer = setTimeout(() => {
+    indexTimer = null;
+    if (indexDirty) saveValueIndexNow(ctx);
+  }, SAVE_DEBOUNCE_MS);
+  if (typeof indexTimer?.unref === "function") indexTimer.unref();
+}
+
+/**
+ * 忘掉某个会话的价值判定（删除会话后必须调用）。
+ * 否则删掉的会话还留着一条「低价值」结论，下次筛选若按索引命中就会把它勾出来 ——
+ * 而它其实已经不存在了。
+ * @returns {boolean} true = 确实删掉了条目
+ */
+export function forgetValueVerdict(ctx, sessionId) {
+  if (!sessionId) return false;
+  const index = loadValueIndex(ctx);
+  if (!index?.entries || !(sessionId in index.entries)) return false;
+  delete index.entries[sessionId];
+  indexDirty = true;
+  saveValueIndexNow(ctx);
+  return true;
+}
+
+/** 立即落盘（原子写：tmp + rename）。失败只丢缓存，不抛。 */
+export function saveValueIndexNow(ctx) {
+  if (indexCache === null) return;
+  try {
+    setSection(ctx, "value", { entries: indexCache.entries });
+    saveStoreNow(ctx);
+    indexDirty = false;
+  } catch {
+    // 写盘失败（只读卷/磁盘满）：本次不落盘，下次继续尝试
+  }
+}
+
+/** 测试钩子：清空内存态并允许重新指定路径。 */
+export function resetValueIndexForTest() {
+  indexCache = null;
+  indexPath = null;
+  indexDirty = false;
+  if (indexTimer !== null) clearTimeout(indexTimer);
+  indexTimer = null;
+}

package/lib/i18n/en.json

@@ -13,6 +13,21 @@
     "tab.archived": "Archived",
     "tab.active": "Active",
     "tab.help": "Help",
+    "tab.trash": "Trash",
+    "trash.retention.label": "Keep",
+    "trash.retention.unit": "days",
+    "trash.retention.save": "Save",
+    "trash.undo": "Undo last delete",
+    "trash.undo.title": "Restore the latest batch ({n})",
+    "trash.restoreSelected": "Restore selected ({n})",
+    "trash.selectAll": "Select all",
+    "trash.empty": "Empty trash",
+    "trash.emptyConfirm": "Emptying the trash permanently deletes {n} sessions (irreversible). Continue?",
+    "trash.restore": "Restore",
+    "trash.emptyList": "Trash is empty",
+    "trash.hint": "Deleting only marks the session; files stay until the retention period ends or you empty the trash",
+    "trash.remaining": "{n} day(s) left",
+    "trash.nothingToUndo": "Nothing to undo",
     "list.empty": "No sessions yet",
     "list.archivedEmpty": "Nothing archived",
     "list.activeEmpty": "No active sessions (live/running)",
@@ -62,8 +77,8 @@
     "action.analyze": "Analyze",
     "action.busy": "Working…",
     "action.retry": "Retry",
-    "confirm.delete.title": "Permanently delete session \"{title}\"?",
-    "confirm.delete.body": "This cannot be undone (the session log will be removed too).",
+    "confirm.delete.title": "Delete session \"{title}\"?",
+    "confirm.delete.body": "The session moves to the Trash and can be restored from the Trash tab at any time. Files are only removed when the retention period (default 7 days) expires or you empty the trash.",
     "error.action": "Action failed: {message}",
     "meta.time.now": "just now",
     "meta.time.minutes": "{n}m ago",
@@ -71,8 +86,8 @@
     "meta.time.days": "{n}d ago",
     "meta.time.months": "{n}mo ago",
     "meta.time.years": "{n}y ago",
-    "help.delete.title": "Delete session (added by this plugin)",
-    "help.delete.desc": "The built-in UI has no way to delete a session. This plugin adds it: refuses to delete a running session, double-checks before deleting, removes the log for good.",
+    "help.delete.title": "Delete sessions (added by this plugin)",
+    "help.delete.desc": "The built-in UI has no way to delete a session; this plugin adds it. Deleting only marks the session - files stay untouched: it goes to the Trash tab, where you can restore one, restore several, or undo the latest batch. Running sessions are refused. Files are really removed only when the retention period expires (configurable, default 7 days) or you empty the trash.",
     "help.autoRename.title": "Auto-rename (added by this plugin)",
     "help.autoRename.desc": "Turn on \"Auto-rename\" for a session and after each finished turn the plugin asks an AI to compare recent session content against the current title; when the topic has clearly drifted it generates a new title and renames automatically. Titles carry a live state suffix: \"（运行中）\" = turn in progress, \"（已中断）\" = crashed/errored and waiting to resume; updated at turn boundaries. Rate-limited (5 min interval, needs a few new messages) to keep token costs low.",
     "help.autoContinue.title": "Auto-resume (added by this plugin)",
@@ -99,23 +114,23 @@
     "search.hits": "{n} sessions matched",
     "search.close": "Collapse results",
     "deleteBatch.action": "Delete selected ({n})",
-    "deleteBatch.confirm.title": "Permanently delete the {n} selected sessions?",
-    "deleteBatch.confirm.body": "This cannot be undone (logs are removed too); running sessions are skipped automatically.",
-    "deleteBatch.done": "Deleted {deleted}{skippedText}",
-    "deleteBatch.skipped": ", skipped {n} (running/undeletable)",
-    "deleteByRule.action": "Delete by rule",
+    "deleteBatch.confirm.title": "Delete the {n} selected sessions?",
+    "deleteBatch.confirm.body": "They move to the Trash and can be restored anytime. Running sessions are skipped automatically.",
+    "deleteBatch.done": "Moved {deleted} to the Trash{skippedText}",
+    "deleteBatch.skipped": ", skipped {n} (running / not deletable)",
+    "deleteByRule.action": "Filter",
     "deleteByRule.label.archivedOnly": "Archived only",
     "deleteByRule.label.inactiveDays": "Inactive for more than {n} days (0 = any)",
     "deleteByRule.label.cwdPrefix": "cwd prefix (optional, group scope)",
-    "deleteByRule.previewBtn": "Preview",
-    "deleteByRule.preview": "Rule matches {n} sessions. Delete? (running ones are skipped)",
+    "deleteByRule.previewBtn": "Select matching sessions",
+    "deleteByRule.filtering": "Filtering… (low-value check reads every session)",
     "deleteByRule.noMatch": "No sessions match the rule",
-    "deleteByRule.run": "Delete",
     "deleteByRule.cancel": "Cancel",
     "deleteByRule.label.lowValue": "Low-value only (value analysis; dust/duplicates)",
     "deleteByRule.label.inactiveDays.pre": "Inactive for more than ",
     "deleteByRule.label.inactiveDays.post": " days (0 = any)",
-    "deleteByRule.offlineHint": "Preview page is an offline snapshot; deletion is not executed here — use the DSH GUI"
+    "deleteByRule.analyzing": "Analyzing low value {done}/{total} (selects as it goes)",
+    "deleteByRule.andHint": "All four conditions are AND-ed: a session is selected only if every enabled condition matches (unchecked = that condition is ignored)"
   },
   "sessionGroup": {
     "title": "Session Groups",
@@ -202,4 +217,4 @@
     "armCurNone": "Current: not selected",
     "renderFail": "Settings render failed: "
   }
-}
+}

package/lib/i18n/zh.json

@@ -13,6 +13,21 @@
     "tab.archived": "已归档",
     "tab.active": "活跃",
     "tab.help": "说明",
+    "tab.trash": "回收站",
+    "trash.retention.label": "保留",
+    "trash.retention.unit": "天",
+    "trash.retention.save": "保存",
+    "trash.undo": "撤销上次删除",
+    "trash.undo.title": "还原最近一批（{n} 个）",
+    "trash.restoreSelected": "还原选中 ({n})",
+    "trash.selectAll": "全选",
+    "trash.empty": "一键清空",
+    "trash.emptyConfirm": "清空回收站会立即真删 {n} 个会话（不可恢复），确定吗？",
+    "trash.restore": "还原",
+    "trash.emptyList": "回收站是空的",
+    "trash.hint": "删除只是打标记、文件还在；到期（保留天数）或一键清空才真正删盘",
+    "trash.remaining": "剩 {n} 天",
+    "trash.nothingToUndo": "没有可撤销的删除",
     "list.empty": "还没有会话",
     "list.archivedEmpty": "没有已归档的会话",
     "list.activeEmpty": "当前没有活跃会话（live/running）",
@@ -55,8 +70,8 @@
     "action.analyze": "分析",
     "action.busy": "处理中…",
     "action.retry": "重试",
-    "confirm.delete.title": "确定要永久删除会话「{title}」吗？",
-    "confirm.delete.body": "删除后无法恢复（会话日志与记录将一并删除）。",
+    "confirm.delete.title": "确定要删除会话「{title}」吗？",
+    "confirm.delete.body": "会话会移入回收站，可在「回收站」页随时还原；只有到期（保留天数，默认 7 天）或一键清空才真正删盘。",
     "action.undo": "撤回消息",
     "undo.preview.empty": "（无文本消息）",
     "confirm.undo.title": "撤回最后一条消息？",
@@ -72,7 +87,7 @@
     "meta.time.months": "{n}个月前",
     "meta.time.years": "{n}年前",
     "help.delete.title": "删除会话（本插件新增）",
-    "help.delete.desc": "内置界面没有任何删除会话的入口。本插件补上了：拒绝删除运行中的会话，删除前二次确认，删除后日志一并清除、不可恢复。",
+    "help.delete.desc": "内置界面没有任何删除会话的入口，本插件补上了。删除**只打标记、不动会话文件**：会话会进「回收站」标签页，可单条还原、多选还原，或按批次撤销最近一次删除；运行中的会话拒绝删除。真正删盘只发生在回收站到期（保留天数可设，默认 7 天）或「一键清空」。",
     "help.autoRename.title": "自动重命名（本插件新增）",
     "help.autoRename.desc": "给会话勾选「自动重命名」后，每个回合结束，插件会用 AI 分析最近会话内容；发现主题/方向已明显偏离当前标题时，自动生成新标题并改掉。标题会带上实时状态后缀：「（运行中）」= 正在执行回合、「（已中断）」= 崩溃/错误中断待续跑；回合结束自动更新。分析带 5 分钟最小间隔和新增消息数门槛，避免频繁调用浪费额度。",
     "help.autoContinue.title": "自动续跑（本插件新增）",
@@ -99,23 +114,23 @@
     "search.hits": "命中 {n} 个会话",
     "search.close": "收起结果",
     "deleteBatch.action": "删除选中 ({n})",
-    "deleteBatch.confirm.title": "确定要永久删除选中的 {n} 个会话吗？",
-    "deleteBatch.confirm.body": "删除后无法恢复（日志一并清除）；运行中的会话会被自动跳过。",
-    "deleteBatch.done": "已删除 {deleted} 个{skippedText}",
+    "deleteBatch.confirm.title": "确定要删除选中的 {n} 个会话吗？",
+    "deleteBatch.confirm.body": "会移入回收站，可随时还原；运行中的会话会被自动跳过。",
+    "deleteBatch.done": "已移入回收站 {deleted} 个{skippedText}",
     "deleteBatch.skipped": "，跳过 {n} 个（运行中/不可删）",
-    "deleteByRule.action": "按条件删除",
+    "deleteByRule.action": "筛选",
     "deleteByRule.label.archivedOnly": "仅已归档会话",
     "deleteByRule.label.inactiveDays": "超过 {n} 天未活跃（0=不限）",
     "deleteByRule.label.cwdPrefix": "目录前缀（可选，限定分组）",
-    "deleteByRule.previewBtn": "预览命中",
-    "deleteByRule.preview": "按条件命中 {n} 个会话，确定删除吗？（运行中的会被跳过）",
+    "deleteByRule.previewBtn": "勾选符合条件的会话",
+    "deleteByRule.filtering": "筛选中…（低价值需逐个会话读事件，请稍候）",
     "deleteByRule.noMatch": "没有符合条件的会话",
-    "deleteByRule.run": "执行删除",
     "deleteByRule.cancel": "取消",
     "deleteByRule.label.lowValue": "仅低价值会话（价值分析判定，灰尘/重复可删）",
     "deleteByRule.label.inactiveDays.pre": "超过 ",
     "deleteByRule.label.inactiveDays.post": " 天未活跃（0=不限）",
-    "deleteByRule.offlineHint": "预览页为离线快照，不执行真实删除——请到 DSH GUI 操作"
+    "deleteByRule.analyzing": "低价值分析中 {done}/{total}（分析出一个勾一个）",
+    "deleteByRule.andHint": "四个条件为「与」关系：只有同时满足的条件才会被勾选（勾选框不选=该条件不参与）"
   },
   "sessionGroup": {
     "title": "会话分组",
@@ -202,4 +217,4 @@
     "armCurNone": "当前：未选择",
     "renderFail": "设置页渲染失败："
   }
-}
+}

package/lib/sessions/list-cache.js

@@ -7,45 +7,32 @@
 //  ③ 列表 TTL 缓存与失效（写操作后 invalidateSessionListCache 立即失效）。
 // 列表的构建流程（buildSessionList）在 list.js。
 
-import { readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
-import path from "node:path";
+import { getSection, setSection, saveStoreNow } from "../core/index-store.js";
 import { log } from "../shared/log.js";
-import { cfg, resolveDshHome, autoRenameEnabled, effectiveAutoContinue } from "../core/config.js";
+import { cfg, autoRenameEnabled, effectiveAutoContinue } from "../core/config.js";
 import { continueJobs } from "../core/state.js";
 import { stripArchiveWsPrefix } from "../features/rename/title.js";
 
 /** 缓存文件版本（不符视为空缓存）。 */
 const LIST_CACHE_VERSION = 1;
-/** 缓存文件所在子目录。 */
-const LIST_CACHE_SUBDIR = ["storages", "dsh-session-conductor"];
 
-/** 落盘缓存内容：{ version, entries: { [id]: { rev, title, updatedAt, interruption, inspectError, cwd, createdAt, parentSession } } } */
+/** 内存缓存：{ version, entries: { [id]: { rev, title, updatedAt, interruption, inspectError, cwd, createdAt, parentSession } } }
+ *  落盘统一走 <DSH_HOME>/storages/dsh-session-conductor/index.json 的 list section。 */
 let listDiskCache = null;
-let listDiskCachePath = null;
 let listDiskCacheDirty = false;
 let listDiskCacheTimer = null;
 
-/** 缓存文件绝对路径（首次调用时解析并缓存）。 */
-export function listCacheFilePath(ctx) {
-  if (listDiskCachePath !== null) return listDiskCachePath;
-  const home = resolveDshHome(ctx, cfg);
-  listDiskCachePath = home ? path.join(home, ...LIST_CACHE_SUBDIR, "list-cache.json") : "";
-  return listDiskCachePath;
-}
-
-/** 读落盘缓存（进程内只读一次）。任何异常都退化成空缓存，不向上抛。 */
+/** 读缓存（进程内只读一次）。任何异常都退化成空缓存，不向上抛。 */
 export function loadListDiskCache(ctx) {
   if (listDiskCache !== null) return listDiskCache;
   listDiskCache = { version: LIST_CACHE_VERSION, entries: {} };
-  const file = listCacheFilePath(ctx);
-  if (!file) return listDiskCache;
   try {
-    const parsed = JSON.parse(readFileSync(file, "utf8"));
-    if (parsed?.version === LIST_CACHE_VERSION && parsed.entries !== null && typeof parsed.entries === "object") {
-      listDiskCache = { version: LIST_CACHE_VERSION, entries: parsed.entries };
+    const section = getSection(ctx, "list");
+    if (section?.entries && typeof section.entries === "object") {
+      listDiskCache = { version: LIST_CACHE_VERSION, entries: section.entries };
     }
   } catch {
-    // 首次运行（文件不存在）/ 文件损坏 / JSON 非法：按空缓存继续，本次解析完会覆盖写入
+    // 索引不可用：按空缓存继续，本次解析完会覆盖写入
   }
   return listDiskCache;
 }
@@ -67,25 +54,51 @@ export function scheduleSaveListDiskCache(ctx) {
 /** 立即原子落盘（写临时文件再 rename，避免下次启动读到半个文件）。 */
 export function saveListDiskCacheNow(ctx) {
   if (!listDiskCacheDirty || listDiskCache === null) return;
-  const file = listCacheFilePath(ctx);
-  if (!file) return;
   listDiskCacheDirty = false;
   try {
-    mkdirSync(path.dirname(file), { recursive: true });
-    const tmpPath = `${file}.tmp`;
-    writeFileSync(tmpPath, JSON.stringify(listDiskCache), "utf8");
-    renameSync(tmpPath, file);
+    setSection(ctx, "list", { entries: listDiskCache.entries });
+    saveStoreNow(ctx);
   } catch (error) {
     // 落盘失败只是让下次重新解析，不影响列表功能；记录下来便于诊断
     log(ctx, `会话列表缓存落盘失败（不影响功能）: ${String(error?.message ?? error)}`);
   }
 }
 
+/**
+ * 「这个会话的列表信息过期了」的统一入口：内存 TTL 缓存 + 落盘索引条目一起作废。
+ *
+ * 凡是改了会话**可见属性**（标题、归档态、状态后缀、内容）的写操作都必须调它一次 ——
+ * 只失效内存缓存不够：冷会话的标题/归档态来自落盘索引，revision 没变就不会重算，
+ * 于是表现为「后端改好了、面板还是旧的」。删除走 forgetSessionInListCache（条目直接删掉）。
+ */
+export function markSessionListStale(ctx, sessionId) {
+  if (sessionId) forgetSessionInListCache(ctx, sessionId);
+  invalidateSessionListCache();
+}
+
 /** 立即标记为脏（用于「清理完缓存条目后强制落盘」）。 */
 export function markListDiskCacheDirty() {
   listDiskCacheDirty = true;
 }
 
+/**
+ * 忘掉某个会话的落盘缓存条目（删除/移走后必须调用）。
+ *
+ * 为什么必须有：面板现在**先读落盘索引**出列表（冷缓存时否则要等 41~226 秒），
+ * 删掉的会话若只从内存与磁盘上消失、索引里还留着，刷新页面就又被索引"复活"显示出来。
+ * 这里把条目删掉并立刻落盘，保证「删了就是删了」。
+ * @returns {boolean} true = 确实删掉了条目
+ */
+export function forgetSessionInListCache(ctx, sessionId) {
+  if (!sessionId) return false;
+  const cache = loadListDiskCache(ctx);
+  if (!cache?.entries || !(sessionId in cache.entries)) return false;
+  delete cache.entries[sessionId];
+  listDiskCacheDirty = true;
+  saveListDiskCacheNow(ctx);
+  return true;
+}
+
 /** 当前是否处于脏状态（构建段据此决定收尾是否落盘）。 */
 export function isListDiskCacheDirty() {
   return listDiskCacheDirty;
@@ -165,7 +178,6 @@ export function settleListBuild(promise, items) {
 /** 测试钩子：清空列表缓存状态（单测在场景之间调用）。 */
 export function resetListCacheForTest() {
   listDiskCache = null;
-  listDiskCachePath = null;
   listDiskCacheDirty = false;
   if (listDiskCacheTimer !== null) clearTimeout(listDiskCacheTimer);
   listDiskCacheTimer = null;

package/lib/sessions/list.js

@@ -221,6 +221,17 @@ export async function buildSessionList(ctx, opts = {}) { // dsh-skip-func-length
     }
   }
 
+  // 回收站里的会话不进列表：删除只是打标记，文件仍在磁盘上，只是对外隐藏。
+  try {
+    const { trashedIds } = await import("../features/trash.js");
+    const hidden = trashedIds(ctx);
+    if (hidden.size > 0) {
+      for (let i = items.length - 1; i >= 0; i -= 1) {
+        if (hidden.has(items[i].id)) items.splice(i, 1);
+      }
+    }
+  } catch { /* 回收站不可用不影响列表 */ }
+
   items.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
   return items;
 }