dsh-session-conductor 1.3.7 → 1.3.8

package/lib/features/session-ops.js

@@ -111,7 +111,6 @@ export async function deleteSession(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 +139,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 +158,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 两组同步清，防同名会话重建后误判）
@@ -320,13 +338,18 @@ export async function deleteBatchSessions(ctx, sessionIds) {
   const persistIds = new Set();
   let canCheckPersist = false;
   try {
-    // 持久化会话权威来源 = persistence.list()（mock 与真实实现都提供）；
-    // listArtifacts 仅作补充（可能未实现/返回空，不代表会话不存在）
+    // 持久化会话权威来源 = persistence.list()。
+    // ⚠️ 宿主返回的是 **SessionPersistenceSnapshot**（`{ header, revision, ... }`），
+    // 不是裸 header —— 只认 `m.id` 会得到空集合，于是每个 id 都被判成 not-found，
+    // 批量删除「全部跳过」正是这么来的（列表侧早就按 `entry.header ?? entry` 兼容了）。
     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);
+        for (const m of metas) {
+          const id = m?.id ?? m?.header?.id;
+          if (typeof id === "string" && id !== "") persistIds.add(id);
+        }
       }
     }
   } catch { canCheckPersist = false; }

package/lib/features/value-index.js

@@ -0,0 +1,135 @@
+// 会话价值索引：把「这条会话值不值得留」的判定结果按会话落盘复用。
+//
+// 【为什么需要】价值判定必须读会话日志（逐帧解压 + 逐行解析），实测本机样本：
+//   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 { readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import path from "node:path";
+
+import { cfg, resolveDshHome } from "../core/config.js";
+
+const VALUE_INDEX_VERSION = 1;
+const VALUE_INDEX_SUBDIR = ["storages", "dsh-session-conductor"];
+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;
+
+/** 索引文件绝对路径（首次解析后缓存）。 */
+export function valueIndexFilePath(ctx) {
+  if (indexPath !== null) return indexPath;
+  const home = resolveDshHome(ctx, cfg);
+  indexPath = home ? path.join(home, ...VALUE_INDEX_SUBDIR, "value-index.json") : "";
+  return indexPath;
+}
+
+/** 读索引（进程内只读一次；文件不存在/损坏都按空索引处理，不向上抛）。 */
+export function loadValueIndex(ctx) {
+  if (indexCache !== null) return indexCache;
+  indexCache = { version: VALUE_INDEX_VERSION, entries: {} };
+  const file = valueIndexFilePath(ctx);
+  if (!file) return indexCache;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (parsed?.version === VALUE_INDEX_VERSION && parsed.entries && typeof parsed.entries === "object") {
+      indexCache = { version: VALUE_INDEX_VERSION, entries: parsed.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) {
+  const file = valueIndexFilePath(ctx);
+  if (!file || indexCache === null) return;
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const tmpPath = `${file}.tmp-${process.pid}`;
+    writeFileSync(tmpPath, JSON.stringify(indexCache), "utf8");
+    renameSync(tmpPath, file);
+    indexDirty = false;
+  } catch {
+    // 写盘失败（只读卷/磁盘满）：本次不落盘，下次继续尝试
+  }
+}
+
+/** 测试钩子：清空内存态并允许重新指定路径。 */
+export function resetValueIndexForTest() {
+  indexCache = null;
+  indexPath = null;
+  indexDirty = false;
+  if (indexTimer !== null) clearTimeout(indexTimer);
+  indexTimer = null;
+}

package/lib/i18n/en.json

@@ -103,19 +103,19 @@
     "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",
+    "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",

package/lib/i18n/zh.json

@@ -103,19 +103,19 @@
     "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": "会话分组",

package/lib/sessions/list-cache.js

@@ -81,11 +81,41 @@ export function saveListDiskCacheNow(ctx) {
   }
 }
 
+/**
+ * 「这个会话的列表信息过期了」的统一入口：内存 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;

package/lib/value.js

@@ -346,6 +346,37 @@ export function keywordMatch(title, lastUserText, keywords) {
   return { hit: matched.length > 0, matched };
 }
 
+/**
+ * 单会话价值判定（流式用）：与 analyzeValuesWithKeywords 里「无关键词 / 无 LLM」那条路径
+ * **同一套规则**，只是按会话逐个算 —— 便于边分析边把结果推给前端（分析出一个勾一个），
+ * 不必等全量跑完才给第一个结果。
+ *
+ * 规则顺序：assessValue 特征评分 → 事件不可读时保守判 high（孤儿/未登记会话不误删）。
+ * 关键词与 LLM 分支不在流式路径里（面板筛选不用它们）。
+ * @param {object} session 会话对象
+ * @param {Array} events 该会话事件流（读不到传空数组）
+ * @param {Date} now
+ * @param {number} staleDays
+ * @returns {{id:string, value:"high"|"low", score:number, reason:string, source:string, status:string}}
+ */
+export function classifySessionLevel(session, events, now = new Date(), staleDays = 3) {
+  const evs = Array.isArray(events) ? events : [];
+  const feats = buildValueFeatures(evs, session, now);
+  const { status } = classifySessionValue(session, lastAssistantText(evs), now, staleDays);
+  let scored = assessValue(feats);
+  if (feats && feats.eventCount === 0 && !(feats.activeHours > LONG_STALE_HOURS)) {
+    scored = { value: "high", score: VALUE_SCORE.artifactSafe, reason: "事件不可读（孤儿/未登记），保守保留", source: "artifact-safe" };
+  }
+  return {
+    id: session.id,
+    value: scored.value,
+    score: scored.score ?? 0,
+    reason: scored.reason || "",
+    source: scored.source || "rule",
+    status,
+  };
+}
+
 /**
  * 关键词命中 → 高/低价值聚合（关键词命中即无条件 high，其余走 assessValue 特征评分）。
  * @param {Array} sessions 会话对象数组

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-conductor",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "description": "DSH session management enhancement: archive/restore sessions, batch & conditional delete, AI auto-rename, interrupted-session auto-resume, release idle sessions, workspace grouping, undo last message, repair damaged session logs, value analysis, full-text search, per-member model switching (list_models / set_member_model), and plan/closing template injection (system-prompt + context).",
   "type": "module",
   "main": "lib/index.js",