dsh-session-conductor 1.3.6 → 1.3.8

package/lib/client.js

@@ -90,12 +90,16 @@ window.__ModuleLoader__.load({
 
     // ---------- 工具 ----------
 
-    // 全局 fetch 超时兜底：DSH API 挂起（重负载/路由未注册）时界面不再无限等待。
-    // 与 fetch 同签名（url, opts, timeoutMs），默认 30s；分片统一走 __scFetch。
-    const FETCH_TIMEOUT_MS = 30000;
+    // 统一 fetch 入口（url, opts, timeoutMs）。**默认不设超时**。
+    // 曾经默认 30 秒「兜底」，结果两次把慢但正常的请求掐成失败：
+    //   · 会话列表冷缓存要逐份解压上百份日志（实测 41~226 秒）→ 刚重启报「读取会话列表失败」；
+    //   · 按条件筛选勾了「低价值」时要逐个会话读事件 → 报「操作失败：signal is aborted…」。
+    // 结论：**判定只能按事件驱动**（请求完成 / 失败 / 数据到达），不能靠拍一个秒数上限；
+    // 时间阈值一写死，慢就被误读成坏。真要限时，必须由调用方显式传 timeoutMs 并说清依据。
     window.__scFetch = function (url, opts, timeoutMs) {
+      if (!(timeoutMs > 0)) return fetch(url, opts || {});
       const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), timeoutMs || FETCH_TIMEOUT_MS);
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
       const next = opts ? Object.assign({}, opts, { signal: controller.signal }) : { signal: controller.signal };
       return fetch(url, next).finally(() => clearTimeout(timer));
     };
@@ -414,18 +418,18 @@ window.__ModuleLoader__.load({
       const [groups, setGroups] = react.useState(null); // workspaces[]（group/list）；null = host 无分组 API
       const [collapsed, setCollapsed] = react.useState(() => new Set()); // 折叠的分组（含 "__ungrouped__"）
       const [error, setError] = react.useState(null);
+      const [retryIn, setRetryIn] = react.useState(null); // 自动重试倒计时（秒）；null = 没有待重试的定时器
       const [busy, setBusy] = react.useState(null);
       // —— 搜索 + 批量/按条件删除 ——
       const [query, setQuery] = react.useState(""); // 列表过滤关键词
       const [selected, setSelected] = react.useState(() => new Set()); // 批量删除勾选
       const [fullResults, setFullResults] = react.useState(null); // 全文搜索结果（null=未搜索）
       const [fullSearching, setFullSearching] = react.useState(false);
-      const [ruleOpen, setRuleOpen] = react.useState(false); // 按条件删除表单展开
+      const [ruleOpen, setRuleOpen] = react.useState(false); // 筛选条件表单展开
       const [ruleArchivedOnly, setRuleArchivedOnly] = react.useState(true);
       const [ruleDays, setRuleDays] = react.useState(7);
       const [rulePrefix, setRulePrefix] = react.useState("");
       const [ruleLowValue, setRuleLowValue] = react.useState(false); // 低价值筛选（复用价值分析）
-      const [rulePreview, setRulePreview] = react.useState(null); // dryRun 预览（null=未预览）
 
       // list 流式——NDJSON 每行一个会话，读到立即追加显示（每获取一个追加一个，
       // 不等全部）；按 updatedAt 倒序插入保持列表顺序；旧一次性 JSON（预览页离线垫片/
@@ -440,20 +444,51 @@ window.__ModuleLoader__.load({
         next.splice(i, 0, item);
         return next;
       };
+      // 列表拉取失败自动重试：DSH 刚重启时插件路由/宿主服务未必已就绪，首次请求会直接
+      // 网络失败（Failed to fetch），冷缓存首次构建也很慢 —— 靠用户手动点「重试」既费事又
+      // 容易误以为插件坏了。这里按退避自动重试，界面照常给出失败原因 + 下次重试倒计时，
+      // 成功一次即清零。数组长度 = 最多自动重试几次。
+      const LIST_RETRY_DELAYS = [3000, 8000, 20000, 45000];
+      const listRetryRef = react.useRef(0);
+      const listTimerRef = react.useRef(null);
+      const refreshRef = react.useRef(null);
+      // 卸载时清掉待重试的定时器，避免组件已销毁还在拉数据（也会让「已关闭面板」继续打后端）
+      react.useEffect(() => () => {
+        if (listTimerRef.current) clearTimeout(listTimerRef.current);
+        listTimerRef.current = null;
+      }, []);
       const refresh = react.useCallback(async () => {
+        if (listTimerRef.current) { clearTimeout(listTimerRef.current); listTimerRef.current = null; }
+        setRetryIn(null);
         try {
-          const listPromise = window.__scFetch("/api/session-conductor/list", { headers: { Accept: "application/x-ndjson" } });
+          // 流式列表**不设超时**（第三个参数 0）：冷缓存要逐份解压上百份日志，本机实测
+          // 41~226 秒；套 30 秒上限会把「慢但正常」的请求掐成「读取会话列表失败」。
+          const listPromise = window.__scFetch("/api/session-conductor/list", { headers: { Accept: "application/x-ndjson" } }, 0);
           const groupPromise = window.__scFetch("/api/session-conductor/group/list")
             .then((r) => (r.ok ? r.json() : { ok: false })).catch(() => ({ ok: false }));
           const listRes = await listPromise;
           if (!listRes.ok) throw new Error("list failed: HTTP " + listRes.status);
           let lastBatch = null;
           if (typeof listRes.body?.getReader === "function") {
-            // 流式 NDJSON：逐行解析追加
+            // 流式 NDJSON：逐行解析追加。
+            // 但**不逐行 setState**：上百条会话逐条 setSessions 会触发上百次全列表重渲染
+            // （O(n²)），真实数据下界面会卡到无响应。改为攒 150ms 一批、一次性合并。
             const reader = listRes.body.getReader();
             const decoder = new TextDecoder();
             let buf = "";
             const batch = [];
+            const pending = [];
+            let flushTimer = null;
+            const flush = () => {
+              flushTimer = null;
+              if (pending.length === 0) return;
+              const items = pending.splice(0, pending.length);
+              setSessions((cur) => {
+                let next = Array.isArray(cur) ? cur : [];
+                for (const item of items) next = insertSorted(next, item);
+                return next;
+              });
+            };
             for (;;) {
               const { done, value } = await reader.read();
               if (done) break;
@@ -467,10 +502,12 @@ window.__ModuleLoader__.load({
                 try { parsedLine = JSON.parse(line); } catch { continue; } // 半行/头行跳过
                 if (parsedLine && parsedLine.id) {
                   batch.push(parsedLine);
-                  setSessions((cur) => insertSorted(cur, parsedLine)); // 每获取一个追加一个
+                  pending.push(parsedLine);
+                  if (flushTimer === null) flushTimer = setTimeout(flush, 150);
                 }
               }
             }
+            flush();
             lastBatch = batch;
           } else {
             const body = await listRes.json();
@@ -482,12 +519,37 @@ window.__ModuleLoader__.load({
           const groupRes = await groupPromise;
           setGroups(groupRes?.ok === true ? groupRes.workspaces ?? [] : null);
           setError(null);
+          listRetryRef.current = 0; // 成功一次即清零，下次失败从最短退避重来
         } catch (cause) {
           setError(cause instanceof Error ? cause.message : String(cause));
+          const delay = LIST_RETRY_DELAYS[listRetryRef.current];
+          if (delay !== void 0) {
+            listRetryRef.current += 1;
+            setRetryIn(Math.round(delay / 1000));
+            listTimerRef.current = setTimeout(() => { refreshRef.current?.(); }, delay);
+          }
         }
       }, []);
+      refreshRef.current = refresh;
 
       // 启动即自动加载（插件挂载就预取一次，不依赖面板打开）；打开面板时再刷新一次保证最新
+      // ① 先读**落盘索引**（毫秒级）把列表填出来 —— 索引只写不用的话，冷缓存时面板要等
+      //    全量构建（实测 41~226 秒）才有内容，看起来就是「空的」。
+      // ② 随后 refresh() 的流式全量刷新在后台覆盖（每条到了就追加），两者互不阻塞。
+      react.useEffect(() => {
+        let alive = true;
+        (async () => {
+          try {
+            const res = await window.__scFetch("/api/session-conductor/list?fromIndex=true", { headers: { Accept: "application/json" } }, 0);
+            const body = await res.json();
+            if (!alive || !body?.ok) return;
+            const items = Array.isArray(body.sessions) ? body.sessions : [];
+            // 只在当前还是空列表时填充：不要用陈旧索引覆盖已经流式到达的新数据
+            if (items.length > 0) setSessions((cur) => (Array.isArray(cur) && cur.length > 0 ? cur : items));
+          } catch { /* 索引不可用就走全量刷新 */ }
+        })();
+        return () => { alive = false; };
+      }, []);
       react.useEffect(() => {
         refresh();
       }, [refresh]);
@@ -848,15 +910,20 @@ window.__ModuleLoader__.load({
             usedFallback = true;
           }
           if (!body?.ok) throw new Error(body?.error?.message ?? "search failed");
-          const hits = (body.items ?? []).map((h) => ({
-            sessionId: h.sessionId,
+          // 两条搜索来源、两种返回形状：官方 FTS 给 items[]，本插件内置扫描给 hits[]。
+          // 原先只认 items ⇒ 官方接口不存在（本机实测 /api/session-search/query 直接 404，
+          // 必然走内置扫描）时命中恒为空 —— 搜到了也显示「没有找到」，命中区自然点不动。
+          const rawHits = Array.isArray(body.items) ? body.items : (Array.isArray(body.hits) ? body.hits : []);
+          const hits = rawHits.map((h) => ({
+            // sessionId 是点开会话的唯一凭据：缺了就是「点了没反应」，这里兼容常见别名并滤掉空值
+            sessionId: h.sessionId ?? h.session?.id ?? h.id ?? null,
             title: h.title ?? null,
             cwd: h.cwd ?? null,
             archived: h.archived === true,
             running: h.running === true,
             updatedAt: h.updatedAt ?? null,
             matches: Array.isArray(h.matches) ? h.matches : (h.match ? [h.match] : []),
-          }));
+          })).filter((h) => typeof h.sessionId === "string" && h.sessionId !== "");
           setFullResults({ query: keywordText, hits, usedFallback });
         } catch (cause) {
           const message = cause instanceof Error ? cause.message : String(cause);
@@ -893,116 +960,108 @@ window.__ModuleLoader__.load({
         }
       };
 
-      // —— 按条件删除（预览 + 执行）——
-      // 预览页离线模式（window.__BACKEND__ === ""）：按条件删除在快照数据上本地计算预览
-      // （真实 GUI 走后端 API；预览页点预览可立即看到命中，无需后端）
-      const previewLocally = () => {
-        const ep = window.__ENDPOINTS__ || {};
-        const listBody = ep["/api/session-conductor/list"];
-        const vaBody = ep["/api/session-conductor/value-analysis"];
-        const rows = (listBody?.sessions ?? []).map((s) => ({
-          sessionId: s.id,
-          title: s.title,
-          cwd: s.cwd,
-          archived: s.archived === true,
-          updatedAt: typeof s.updatedAt === "number" ? s.updatedAt : null,
-        }));
+      // —— 勾选的公共入口 ——
+      // 行内勾选框、筛选、清空都必须走这两个函数：状态只有 `selected` 一处。
+      // 之前行内勾选自己写一段 setSelected、筛选另写一段，两处口径一旦不同就会出现
+      // 「删除按钮的计数变了，但行内勾选框没勾上」这种鬼现象。
+      const setRowSelected = (sessionId, checked) => {
+        if (typeof sessionId !== "string" || sessionId === "") return;
+        setSelected((prev) => {
+          const next = new Set(prev);
+          if (checked) next.add(sessionId); else next.delete(sessionId);
+          return next;
+        });
+      };
+      const replaceSelected = (ids) => {
+        setSelected(new Set((Array.isArray(ids) ? ids : []).filter((id) => typeof id === "string" && id !== "")));
+      };
+
+      // —— 筛选：按条件把会话**自动勾选**到列表里 ——
+      // 批量删除只有一条路径：「勾选 → 删除选中」。条件（归档 / 价值 / 时间 / 目录）只负责把该勾的勾上。
+      // ① 归档 / 时间 / 目录：面板手里每一行已经带着 archived / cwd / updatedAt，
+      //    纯内存过滤 —— 点完即勾，**不发任何请求**。
+      // ② 低价值：唯一需要读日志的条件，走**流式**分析 —— 服务端每算完一条推一行，
+      //    前端**分析出一个勾一个**。服务端另有价值索引（按 updatedAt + TTL，默认 24 小时），
+      //    命中索引的会话零 I/O 秒回，只有新会话/变过的会话才真读日志。
+      // 全程不设时间上限：完成与否由**请求事件**判定（每行一个结果，读完即结束）。
+      const [filterProgress, setFilterProgress] = react.useState(null); // {done,total}；null=没在分析
+      const streamLowValue = async (baseIds) => {
+        const base = new Set(baseIds);
+        replaceSelected([]); // 低价值：从空开始，分析出一个勾一个
+        setFilterProgress({ done: 0, total: base.size });
+        const res = await window.__scFetch("/api/session-conductor/value-analysis?stream=1", {
+          method: "POST",
+          headers: { "Content-Type": CONTENT_TYPE_JSON, Accept: "application/x-ndjson" },
+          body: JSON.stringify({ ids: baseIds }),
+        }, 0);
+        if (!res.ok) throw new Error("value analysis failed: HTTP " + res.status);
+        if (typeof res.body?.getReader !== "function") throw new Error("value analysis: 宿主未提供流式响应");
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        let picked = 0;
+        let seen = 0;
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buf += decoder.decode(value, { stream: true });
+          let nl;
+          while ((nl = buf.indexOf("\n")) >= 0) {
+            const line = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            if (!line) continue;
+            let row;
+            try { row = JSON.parse(line); } catch { continue; }
+            if (!row || typeof row.id !== "string") continue; // 头行（{ok,stream,total}）跳过
+            seen += 1;
+            setFilterProgress({ done: typeof row.done === "number" ? row.done : seen, total: typeof row.total === "number" ? row.total : base.size });
+            if (row.value === "low" && base.has(row.id)) {
+              picked += 1;
+              setRowSelected(row.id, true); // 走公共勾选入口，行内勾选框与计数永远一致
+            }
+          }
+        }
+        return picked;
+      };
+
+      const applyFilter = async () => {
+        const list = Array.isArray(sessions) ? sessions : [];
         const now = Date.now();
-        const lowIds = new Set((vaBody?.low ?? []).map((i) => i.id));
         const prefix = rulePrefix.trim().replace(/\/+$/, "");
         const days = Number(ruleDays) || 0;
-        const matched = rows.filter((m) => {
-          if (ruleArchivedOnly && !m.archived) return false;
+        const baseIds = list.filter((s) => {
+          if (ruleArchivedOnly && s.archived !== true) return false;
           if (days > 0) {
-            const updated = m.updatedAt;
+            const updated = typeof s.updatedAt === "number" ? s.updatedAt : NaN;
             if (!Number.isFinite(updated) || now - updated < days * 86400000) return false;
           }
           if (prefix !== "") {
-            const cwd = String(m.cwd ?? "").replace(/\/+$/, "");
+            const cwd = String(s.cwd ?? "").replace(/\/+$/, "");
             if (cwd !== prefix && !cwd.startsWith(prefix + "/")) return false;
           }
-          if (ruleLowValue && !lowIds.has(m.sessionId)) return false;
           return true;
-        });
-        return matched;
-      };
-
-      const previewRuleDelete = async () => {
-        setBusy("__rule__");
-        setRulePreview(null);
-        if (typeof window.__BACKEND__ !== "undefined" && window.__BACKEND__ === "") {
-          // 预览页离线：本地计算
-          try {
-            const matched = previewLocally();
-            setRulePreview(matched);
-            if (matched.length === 0) window.alert(t("deleteByRule.noMatch"));
-          } catch (cause) {
-            window.alert(t("error.action", { message: cause instanceof Error ? cause.message : String(cause) }));
-          } finally {
-            setBusy(null);
-          }
+        }).map((s) => s.id);
+        if (baseIds.length === 0) {
+          // 勾选是「替换」语义：这次条件什么都没匹配到，必须把上一次的勾选清掉 ——
+          // 否则界面还留着上次的勾选与「删除选中 (N)」，很容易照着上次的结果误删。
+          replaceSelected([]);
+          window.alert(t("deleteByRule.noMatch"));
           return;
         }
-        try {
-          const res = await window.__scFetch("/api/session-conductor/delete-by-rule", {
-            method: "POST",
-            headers: { "Content-Type": CONTENT_TYPE_JSON },
-            body: JSON.stringify({
-              archivedOnly: ruleArchivedOnly,
-              inactiveDays: Number(ruleDays) || 0,
-              cwdPrefix: rulePrefix.trim(),
-              lowValue: ruleLowValue,
-              dryRun: true,
-            }),
-          });
-          const body = await res.json();
-          if (!body.ok) throw new Error(body.error?.message ?? "preview failed");
-          setRulePreview(body.matched ?? []);
-          if (!body.matched || body.matched.length === 0) window.alert(t("deleteByRule.noMatch"));
-        } catch (cause) {
-          const message = cause instanceof Error ? cause.message : String(cause);
-          window.alert(t("error.action", { message }));
-        } finally {
-          setBusy(null);
-        }
-      };
-
-      const runRuleDelete = async () => {
-        if (!rulePreview || rulePreview.length === 0) return;
-        // 预览页离线模式：不执行真实删除（破坏性操作需真实后端），提示到 DSH GUI
-        if (typeof window.__BACKEND__ !== "undefined" && window.__BACKEND__ === "") {
-          window.alert(t("deleteByRule.offlineHint"));
-          return;
-        }
-        const yes = window.confirm(t("deleteByRule.preview", { n: rulePreview.length }));
-        if (!yes) return;
+        // 切到「全部」让勾选结果当场可见 + 收起条件表单回到列表
+        setTab("all");
+        setRuleOpen(false);
+        if (!ruleLowValue) { replaceSelected(baseIds); return; } // 纯本地，点完即勾
         setBusy("__rule__");
         try {
-          const res = await window.__scFetch("/api/session-conductor/delete-by-rule", {
-            method: "POST",
-            headers: { "Content-Type": CONTENT_TYPE_JSON },
-            body: JSON.stringify({
-              archivedOnly: ruleArchivedOnly,
-              inactiveDays: Number(ruleDays) || 0,
-              cwdPrefix: rulePrefix.trim(),
-              lowValue: ruleLowValue,
-              dryRun: false,
-            }),
-          });
-          const body = await res.json();
-          if (!body.ok) throw new Error(body.error?.message ?? "delete failed");
-          window.alert(t("deleteBatch.done", {
-            deleted: body.deleted?.length ?? 0,
-            skippedText: body.skipped?.length > 0 ? t("deleteBatch.skipped", { n: body.skipped.length }) : "",
-          }));
-          setRuleOpen(false);
-          setRulePreview(null);
-          await refresh();
+          const picked = await streamLowValue(baseIds);
+          if (picked === 0) window.alert(t("deleteByRule.noMatch"));
         } catch (cause) {
           const message = cause instanceof Error ? cause.message : String(cause);
           window.alert(t("error.action", { message }));
         } finally {
           setBusy(null);
+          setFilterProgress(null);
         }
       };
 
@@ -1130,14 +1189,7 @@ window.__ModuleLoader__.load({
                   children: (0, react_jsx_runtime.jsx)("input", {
                     type: "checkbox",
                     checked: selected.has(session.id),
-                    onChange: (event) => {
-                      setSelected((prev) => {
-                        const next = new Set(prev);
-                        if (event.target.checked) next.add(session.id);
-                        else next.delete(session.id);
-                        return next;
-                      });
-                    },
+                    onChange: (event) => setRowSelected(session.id, event.target.checked),
                   }),
                 }),
                 (0, react_jsx_runtime.jsxs)("div", {
@@ -1500,10 +1552,16 @@ window.__ModuleLoader__.load({
                           onClick: () => deleteSelected(),
                           children: t("deleteBatch.action", { n: selected.size }),
                         }),
+                        // 低价值流式分析进度：每收到一条结果就 +1（事件驱动，不是秒表）
+                        filterProgress !== null &&
+                          (0, react_jsx_runtime.jsx)("span", {
+                            style: { fontSize: 12, color: CSS_LABEL_TERTIARY, whiteSpace: "nowrap" },
+                            children: t("deleteByRule.analyzing", { done: filterProgress.done, total: filterProgress.total }),
+                          }),
                         (0, react_jsx_runtime.jsx)("button", {
                           style: S.actionBtn(false),
                           disabled: busy !== null,
-                          onClick: () => { setRuleOpen((v) => !v); setRulePreview(null); },
+                          onClick: () => { setRuleOpen((v) => !v); },
                           children: t("deleteByRule.action"),
                         }),
                         (0, react_jsx_runtime.jsx)("button", {
@@ -1549,26 +1607,22 @@ window.__ModuleLoader__.load({
                           (0, react_jsx_runtime.jsx)("input", {
                             type: "text", value: rulePrefix, placeholder: t("deleteByRule.label.cwdPrefix"),
                             style: { flex: 1, minWidth: RULE_PREFIX_MIN_WIDTH, height: SMALL_CONTROL_HEIGHT, borderRadius: CONTROL_RADIUS, border: CSS_BORDER_L2, background: CSS_BG_BASE, color: CSS_LABEL_PRIMARY, padding: "0 8px", fontSize: FONT_SIZE_SMALL, outline: "none" },
-                            onChange: (e) => { setRulePrefix(e.target.value); setRulePreview(null); },
+                            onChange: (e) => { setRulePrefix(e.target.value); },
                           }),
                           (0, react_jsx_runtime.jsx)("button", {
                             style: S.actionBtn(false),
                             disabled: busy !== null,
-                            onClick: previewRuleDelete,
-                            children: t("deleteByRule.previewBtn"),
+                            onClick: applyFilter,
+                            // 状态由**请求事件**驱动：发起 → 显示「筛选中…」，响应回来 → 立刻给结果。
+                            // 不用秒表、不设超时上限：慢但正常的请求不该被任何时间阈值判成失败。
+                            children: busy === "__rule__" ? t("deleteByRule.filtering") : t("deleteByRule.previewBtn"),
+                          }),
+                          // 条件关系提示：四个条件（归档 / 价值 / 时间 / 目录）是**与**关系，
+                          // 必须同时满足才会被勾选；界面上写清楚，免得误以为是不限/或关系。
+                          (0, react_jsx_runtime.jsx)("span", {
+                            style: { fontSize: 11.5, color: CSS_LABEL_TERTIARY, flexBasis: "100%" },
+                            children: t("deleteByRule.andHint"),
                           }),
-                          rulePreview !== null && rulePreview.length > 0 &&
-                            (0, react_jsx_runtime.jsx)("button", {
-                              style: { ...S.actionBtn(true), borderColor: CSS_DANGER, color: CSS_DANGER },
-                              disabled: busy !== null,
-                              onClick: runRuleDelete,
-                              children: t("deleteByRule.run") + ` (${rulePreview.length})`,
-                            }),
-                          rulePreview !== null && rulePreview.length > 0 &&
-                            (0, react_jsx_runtime.jsx)("span", {
-                              style: { color: CSS_LABEL_TERTIARY, fontSize: 12 },
-                              children: t("search.hits", { n: rulePreview.length }),
-                            }),
                         ],
                       }),
                     (0, react_jsx_runtime.jsx)("div", {
@@ -1624,6 +1678,7 @@ window.__ModuleLoader__.load({
                                   style: S.error,
                                   children: [
                                     t("list.error", { message: error }),
+                                    retryIn !== null && t("list.autoRetry", { n: retryIn }),
                                     " ",
                                     (0, react_jsx_runtime.jsx)("button", {
                                       style: { ...S.actionBtn(false), marginLeft: 6 },
@@ -2132,20 +2187,22 @@ window.__ModuleLoader__.load({
         locale: NS,
         inject: () => ({
           onOpenSession: (sessionId) => {
-            // 打开会话的真实入口随宿主版本不同，按优先级尝试（**不要只认一个**）：
-            //   · workspaceNavigation.openSession(id) —— dsh-client-ui-conversation 的用法
-            //   · ctx.uiWorkspace.openSession(id)    —— dsh-client-ui-chat 的用法
-            //   · sessions.open(id)                  —— 早期路径，保留兜底
-            // 以前只写了第三个，而宿主客户端并没有 `sessions` 这个服务 ⇒ 可选链把失败吞成
-            // 「点了没反应」，且不报错、难查。所以这里：多个入口都试；全失败要留下痕迹。
+            // 打开会话的入口，按「宿主真实存在的」优先级逐个试：
+            //   · ctx.get("uiWorkspace").openSession(id) —— 宿主自己的会话导航服务
+            //     （ui-conversation 内部就是 `const nav = ctx.get('uiWorkspace')` 再 nav.openSession(id)；
+            //       实测宿主包里根本没有 workspaceNavigation / openSession 这类名字，早期写法是猜的）
+            //   · ctx.uiWorkspace.openSession(id) —— 同一服务，仅在本插件声明过依赖时才作为属性可见
+            //   · ctx.get("sessions").open(id)    —— 老版本兜底
+            // 必须用 ctx.get(...)：cordis 里未在 inject 声明的服务**没有** ctx.<name> 属性，
+            // 但 ctx.get(name) 仍能取到 —— 只写 ctx.uiWorkspace 会永远 undefined，点了没反应。
             try {
-              const nav = ctx.get?.("workspaceNavigation");
+              const nav = ctx.get?.("uiWorkspace");
               if (typeof nav?.openSession === "function") return nav.openSession(sessionId);
               if (typeof ctx.uiWorkspace?.openSession === "function") return ctx.uiWorkspace.openSession(sessionId);
               const legacy = ctx.get?.("sessions");
               if (typeof legacy?.open === "function") return legacy.open(sessionId);
               // eslint-disable-next-line no-console
-              console.warn("[session-conductor] 打不开会话：宿主客户端未暴露 workspaceNavigation/uiWorkspace/sessions 任一入口", sessionId);
+              console.warn("[session-conductor] 打不开会话：宿主未暴露 uiWorkspace.openSession / sessions.open", sessionId);
             } catch (error) {
               // 打开失败不阻塞面板，但不再静默
               // eslint-disable-next-line no-console

package/lib/core/config.js

@@ -31,6 +31,10 @@ export const DEFAULTS = {
   retrieveMemoryMinDropTokens: 0, // 触发阈值：下降绝对量（0 = 不限；两者满足其一即触发）
   retrieveMemoryMaxChars: 4000, // 注入总长上限（字符）
   retrieveMemoryMaxCharsPerItem: 800, // 单条（用户消息文本 / AI 首条回应）上限（字符）
+  // ── 价值判定索引 ──
+  // 同一条会话的价值结论在「内容没变（updatedAt 未变）+ 未超过该时长」时直接复用，
+  // 不再重读日志（实测单条 0.2 MB≈85 ms / 7 MB≈1.1 s / 86 MB≈16 s）。默认 24 小时。
+  valueIndexTtlHours: 24,
 };
 
 /** 运行期配置（面板/测试可改）。外部只读引用；改整体请用 setConfig。 */

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,19 @@ 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;
+  // 归档态：索引文件里没存（它是宿主持久化的名单），但取它很便宜（一次内存读），
+  // 顺手带上 —— 否则面板「先读索引出列表」时按归档筛选会全部落空。
+  const registry = ctx.get?.("workspaceRegistry");
+  const archived = new Set(
+    (registry?.archivedSessionIds ?? []).filter((id) => typeof id === "string" && id !== ""),
+  );
   return Object.entries(entries).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

@@ -75,6 +75,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 +116,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 +216,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);