dsh-session-conductor 1.3.6 → 1.3.8

package/lib/apply.js

@@ -50,6 +50,8 @@ import {
   collectSessionTitleMessages, resolveSessionTitle, stateSuffixOf, stripTitleStateSuffix, refreshTitleState,
 } from "./features/rename/title.js";
 import { SEARCH_MIN_QUERY, searchSessions } from './features/search.js';
+// 价值判定索引：同一份会话内容在 TTL（默认 24 小时）内只算一次，避免每次筛选都重读日志
+import { getValueVerdict, putValueVerdict, saveValueIndexNow } from './features/value-index.js';
 // 成员模型：本文件用到 findTargetAgent / switchAgentModel / getMemberModelOverride /
 //   applyModelOverride / validateModelPair（拆出 apply.js 时漏了这一行 import，
 //   运行到相关代码路径会 ReferenceError: getMemberModelOverride is not defined）
@@ -88,6 +90,8 @@ export async function apply(ctx, config = {}) {
     maxContinuesPerSession: num(config?.maxContinuesPerSession, 1, MAX_CONTINUES_PER_SESSION_LIMIT, DEFAULTS.maxContinuesPerSession),
     turnTimeoutMs: num(config?.turnTimeoutMs, 60 * 1000, 6 * 3600 * 1000, DEFAULTS.turnTimeoutMs),
     scanIntervalMs: num(config?.scanIntervalMs, 30 * 1000, 24 * 3600 * 1000, DEFAULTS.scanIntervalMs),
+    // 价值判定索引有效期（小时）：同一份会话内容在该时长内只算一次（默认 24 小时，可配置覆盖）
+    valueIndexTtlHours: num(config?.valueIndexTtlHours, 1, 24 * 30, DEFAULTS.valueIndexTtlHours),
     // 自动重命名模型路由（成对配置才生效；缺省 = 继承会话 request/header 的对话模型）
     autoRenameProvider: typeof config?.autoRenameProvider === "string" && config.autoRenameProvider !== "" ? config.autoRenameProvider : undefined,
     autoRenameModel: typeof config?.autoRenameModel === "string" && config.autoRenameModel !== "" ? config.autoRenameModel : undefined,
@@ -318,6 +322,13 @@ export async function apply(ctx, config = {}) {
           res.setHeader("Cache-Control", "no-store");
           if (res.socket?.setNoDelay) res.socket.setNoDelay(true);
           res.write(JSON.stringify({ ok: true, stream: true }) + "\n"); // 头行（前端跳过非会话行）
+          // 立即把头行推出去：冷缓存时后面要逐份解压上百份日志（实测 41~226 秒），
+          // 若头行压在缓冲里，浏览器这侧会一直「没有响应」，看起来就像接口挂了。
+          // flushHeaders/flush 老版本不一定有，取不到就跳过（写操作本身已尽量及时）。
+          try {
+            if (typeof res.flushHeaders === "function") res.flushHeaders();
+            if (typeof res.flush === "function") res.flush();
+          } catch { /* 不支持 flush 的宿主不影响主流程 */ }
           const onItem = (item) => { try { res.write(JSON.stringify(item) + "\n"); } catch { /* 连接已断 */ } };
           await buildSessionListCached(ctx, { onItem, serial: true });
           try { res.end(); } catch { /* 连接已断 */ }
@@ -1064,6 +1075,57 @@ export async function apply(ctx, config = {}) {
             : 3;
           const useLlm = body?.llm === true;
           const sessions = await buildSessionListCached(ctx); // 价值分析走缓存（容忍 5s 陈旧，避免与面板刷新叠加扫描）
+          // 流式（`?stream=1` 或 Accept: application/x-ndjson）：**每分析完一个会话就推一行**。
+          // 前端拿到 value==="low" 立刻勾上（分析出一个勾一个），不必等全量跑完 ——
+          // 全量要逐个读上百份日志，慢的是读取本身，而读取是天然可增量的。
+          // 判定规则与批量路径同源（value.js 的 classifySessionLevel），不在这里另写一套。
+          const wantValueStream = /application\/x-ndjson/i.test(req.headers?.accept ?? "")
+            || String(req.url ?? "").includes("stream=1");
+          if (wantValueStream) {
+            // body.ids：只分析这些会话（面板已先用归档/时间/目录在本地筛过一轮，
+            // 没必要把全量会话都读一遍事件）。不传 = 全量。
+            const wantedIds = Array.isArray(body?.ids)
+              ? new Set(body.ids.filter((id) => typeof id === "string" && id !== ""))
+              : null;
+            const streamTargets = wantedIds ? sessions.filter((s) => wantedIds.has(s.id)) : sessions;
+            res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
+            res.setHeader("Cache-Control", "no-store");
+            if (res.socket?.setNoDelay) res.socket.setNoDelay(true);
+            res.write(JSON.stringify({ ok: true, stream: true, total: streamTargets.length }) + "\n");
+            try {
+              if (typeof res.flushHeaders === "function") res.flushHeaders();
+            } catch { /* 老宿主不支持 flush，不影响主流程 */ }
+            const { classifySessionLevel } = await lazyValue();
+            let done = 0;
+            for (const s of streamTargets) {
+              done += 1;
+              // ① 索引命中（内容没变 + 未超 TTL）→ 零 I/O 直接给结论
+              const cachedVerdict = getValueVerdict(ctx, s.id, s.updatedAt);
+              if (cachedVerdict) {
+                try {
+                  res.write(JSON.stringify({
+                    id: s.id, value: cachedVerdict.value, score: cachedVerdict.score,
+                    reason: cachedVerdict.reason, cached: true, done, total: streamTargets.length,
+                  }) + "\n");
+                } catch { break; }
+                continue;
+              }
+              // ② 没索引 / 会话变过 / 超 TTL → 真读一次日志
+              let events = [];
+              try {
+                const found = await sessionEventsOf(ctx, s.id);
+                events = found?.events ?? [];
+              } catch { /* 读不到就当空事件：会走 artifact-safe 保守判 high，不误删 */ }
+              const verdict = classifySessionLevel(s, events, new Date(), staleDays);
+              putValueVerdict(ctx, s.id, s.updatedAt, verdict);
+              try {
+                res.write(JSON.stringify({ ...verdict, cached: false, done, total: streamTargets.length }) + "\n");
+              } catch { break; }
+            }
+            saveValueIndexNow(ctx); // 本次算出来的结论立刻落盘（下次筛选直接命中索引）
+            try { res.end(); } catch { /* 连接已断 */ }
+            return;
+          }
           // 一次性读取各会话事件（复用，避免大会话重复解压导致超时/失败）
           const eventsById = {};
           // 逐个会话读取最后 assistant 文本 + 最后用户消息（损坏/不可读会话跳过，用空串）

package/lib/client-parts/apply.js

@@ -17,20 +17,22 @@
         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/client-parts/components/panel.js

@@ -5,18 +5,18 @@
       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（预览页离线垫片/
@@ -31,20 +31,51 @@
         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;
@@ -58,10 +89,12 @@
                 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();
@@ -73,12 +106,37 @@
           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]);
@@ -439,15 +497,20 @@
             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);
@@ -484,116 +547,108 @@
         }
       };
 
-      // —— 按条件删除（预览 + 执行）——
-      // 预览页离线模式（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);
-          }
-          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"));
+        }).map((s) => s.id);
+        if (baseIds.length === 0) {
+          // 勾选是「替换」语义：这次条件什么都没匹配到，必须把上一次的勾选清掉 ——
+          // 否则界面还留着上次的勾选与「删除选中 (N)」，很容易照着上次的结果误删。
+          replaceSelected([]);
+          window.alert(t("deleteByRule.noMatch"));
           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);
         }
       };
 
@@ -721,14 +776,7 @@
                   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", {
@@ -1091,10 +1139,16 @@
                           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", {
@@ -1140,26 +1194,22 @@
                           (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", {
@@ -1215,6 +1265,7 @@
                                   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 },

package/lib/client-parts/foundation/bootstrap.js

@@ -13,12 +13,16 @@
 
     // ---------- 工具 ----------
 
-    // 全局 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));
     };