dsh-session-conductor 1.3.7 → 1.3.9

package/lib/client-parts/components/panel.js

@@ -12,12 +12,16 @@
       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=未预览）
+      // —— 回收站（删除只是打标记，这里管理被标记的会话）——
+      const [trashItems, setTrashItems] = react.useState(null); // null = 尚未加载
+      const [trashSel, setTrashSel] = react.useState(() => new Set());
+      const [trashRetention, setTrashRetention] = react.useState(7); // 保留天数
+      const [trashBatch, setTrashBatch] = react.useState(null); // 最近一个删除批次（撤销用）
 
       // list 流式——NDJSON 每行一个会话，读到立即追加显示（每获取一个追加一个，
       // 不等全部）；按 updatedAt 倒序插入保持列表顺序；旧一次性 JSON（预览页离线垫片/
@@ -58,11 +62,25 @@
           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;
@@ -76,10 +94,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();
@@ -105,6 +125,23 @@
       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]);
@@ -465,15 +502,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);
@@ -510,119 +552,276 @@
         }
       };
 
-      // —— 按条件删除（预览 + 执行）——
-      // 预览页离线模式（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,
-        }));
-        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;
-          if (days > 0) {
-            const updated = m.updatedAt;
-            if (!Number.isFinite(updated) || now - updated < days * 86400000) return false;
-          }
-          if (prefix !== "") {
-            const cwd = String(m.cwd ?? "").replace(/\/+$/, "");
-            if (cwd !== prefix && !cwd.startsWith(prefix + "/")) return false;
-          }
-          if (ruleLowValue && !lowIds.has(m.sessionId)) return false;
-          return true;
+      // —— 勾选的公共入口 ——
+      // 行内勾选框、筛选、清空都必须走这两个函数：状态只有 `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;
         });
-        return matched;
+      };
+      const replaceSelected = (ids) => {
+        setSelected(new Set((Array.isArray(ids) ? ids : []).filter((id) => typeof id === "string" && id !== "")));
       };
 
-      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;
+      // —— 回收站操作 ——
+      // 删除只是打标记，所以还原就是「删标记」，几乎零成本；真删只发生在到期与一键清空。
+      const loadTrashItems = async () => {
+        try {
+          const res = await window.__scFetch("/api/session-conductor/trash", { headers: { accept: "application/json" } }, 0);
+          const body = await res.json();
+          if (!body?.ok) throw new Error(body?.error?.message ?? "trash load failed");
+          const items = Array.isArray(body.items) ? body.items : [];
+          setTrashItems(items);
+          setTrashRetention(Number(body.retentionDays) || 7);
+          setTrashBatch(body.latestBatch ?? null);
+          setTrashSel((prev) => new Set([...prev].filter((id) => items.some((it) => it.sessionId === id))));
+        } catch (cause) {
+          window.alert(t("error.action", { message: cause instanceof Error ? cause.message : String(cause) }));
         }
+      };
+      const restoreTrash = async (ids) => {
+        if (!Array.isArray(ids) || ids.length === 0) return;
         try {
-          const res = await window.__scFetch("/api/session-conductor/delete-by-rule", {
+          const res = await window.__scFetch("/api/session-conductor/trash/restore", {
             method: "POST",
             headers: { "Content-Type": CONTENT_TYPE_JSON },
-            body: JSON.stringify({
-              archivedOnly: ruleArchivedOnly,
-              inactiveDays: Number(ruleDays) || 0,
-              cwdPrefix: rulePrefix.trim(),
-              lowValue: ruleLowValue,
-              dryRun: true,
-            }),
-          });
+            body: JSON.stringify({ sessionIds: ids }),
+          }, 0);
           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"));
+          if (!body?.ok) throw new Error(body?.error?.message ?? "restore failed");
+          setTrashSel(new Set());
+          await loadTrashItems();
+          await refresh();
         } catch (cause) {
-          const message = cause instanceof Error ? cause.message : String(cause);
-          window.alert(t("error.action", { message }));
-        } finally {
-          setBusy(null);
+          window.alert(t("error.action", { message: cause instanceof Error ? cause.message : String(cause) }));
         }
       };
-
-      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 restoreLastBatch = async () => {
+        try {
+          const res = await window.__scFetch("/api/session-conductor/trash/restore-last-batch", { method: "POST", headers: { "Content-Type": CONTENT_TYPE_JSON }, body: "{}" }, 0);
+          const body = await res.json();
+          if (!body?.ok) throw new Error(body?.error?.message ?? "restore batch failed");
+          if ((body.restored ?? []).length === 0) window.alert(t("trash.nothingToUndo"));
+          setTrashSel(new Set());
+          await loadTrashItems();
+          await refresh();
+        } catch (cause) {
+          window.alert(t("error.action", { message: cause instanceof Error ? cause.message : String(cause) }));
         }
-        const yes = window.confirm(t("deleteByRule.preview", { n: rulePreview.length }));
-        if (!yes) return;
-        setBusy("__rule__");
+      };
+      const emptyTrashAll = async () => {
+        const n = (trashItems ?? []).length;
+        if (n === 0) return;
+        if (!window.confirm(t("trash.emptyConfirm", { n }))) return;
         try {
-          const res = await window.__scFetch("/api/session-conductor/delete-by-rule", {
+          const res = await window.__scFetch("/api/session-conductor/trash/empty", {
             method: "POST",
             headers: { "Content-Type": CONTENT_TYPE_JSON },
-            body: JSON.stringify({
-              archivedOnly: ruleArchivedOnly,
-              inactiveDays: Number(ruleDays) || 0,
-              cwdPrefix: rulePrefix.trim(),
-              lowValue: ruleLowValue,
-              dryRun: false,
-            }),
-          });
+            body: JSON.stringify({ confirm: true }),
+          }, 0);
           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();
+          if (!body?.ok) throw new Error(body?.error?.message ?? "empty failed");
+          setTrashSel(new Set());
+          await loadTrashItems();
+        } catch (cause) {
+          window.alert(t("error.action", { message: cause instanceof Error ? cause.message : String(cause) }));
+        }
+      };
+      const saveTrashRetention = async () => {
+        try {
+          const res = await window.__scFetch("/api/session-conductor/trash/retention", {
+            method: "POST",
+            headers: { "Content-Type": CONTENT_TYPE_JSON },
+            body: JSON.stringify({ days: Number(trashRetention) || 7 }),
+          }, 0);
+          const body = await res.json();
+          if (!body?.ok) throw new Error(body?.error?.message ?? "retention failed");
+          setTrashRetention(Number(body.retentionDays) || 7);
+          await loadTrashItems();
+        } catch (cause) {
+          window.alert(t("error.action", { message: cause instanceof Error ? cause.message : String(cause) }));
+        }
+      };
+      const toggleTrashSel = (sessionId, checked) => {
+        setTrashSel((prev) => {
+          const next = new Set(prev);
+          if (checked) next.add(sessionId); else next.delete(sessionId);
+          return next;
+        });
+      };
+
+      // —— 筛选：按条件把会话**自动勾选**到列表里 ——
+      // 批量删除只有一条路径：「勾选 → 删除选中」。条件（归档 / 价值 / 时间 / 目录）只负责把该勾的勾上。
+      // ① 归档 / 时间 / 目录：面板手里每一行已经带着 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 prefix = rulePrefix.trim().replace(/\/+$/, "");
+        const days = Number(ruleDays) || 0;
+        const baseIds = list.filter((s) => {
+          if (ruleArchivedOnly && s.archived !== true) return false;
+          if (days > 0) {
+            const updated = typeof s.updatedAt === "number" ? s.updatedAt : NaN;
+            if (!Number.isFinite(updated) || now - updated < days * 86400000) return false;
+          }
+          if (prefix !== "") {
+            const cwd = String(s.cwd ?? "").replace(/\/+$/, "");
+            if (cwd !== prefix && !cwd.startsWith(prefix + "/")) return false;
+          }
+          return true;
+        }).map((s) => s.id);
+        if (baseIds.length === 0) {
+          // 勾选是「替换」语义：这次条件什么都没匹配到，必须把上一次的勾选清掉 ——
+          // 否则界面还留着上次的勾选与「删除选中 (N)」，很容易照着上次的结果误删。
+          replaceSelected([]);
+          window.alert(t("deleteByRule.noMatch"));
+          return;
+        }
+        // 切到「全部」让勾选结果当场可见 + 收起条件表单回到列表
+        setTab("all");
+        setRuleOpen(false);
+        if (!ruleLowValue) { replaceSelected(baseIds); return; } // 纯本地，点完即勾
+        setBusy("__rule__");
+        try {
+          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);
         }
       };
 
+      /** 回收站面板：工具栏（保留期 / 撤销 / 还原选中 / 全选 / 一键清空）+ 条目列表 */
+      const renderTrash = () => (0, react_jsx_runtime.jsxs)("div", {
+        style: { padding: PADDING_BAR },
+        children: [
+          (0, react_jsx_runtime.jsxs)("div", {
+            style: { display: "flex", gap: 6, alignItems: "center", flexWrap: "wrap", marginBottom: 8, fontSize: FONT_SIZE_SMALL },
+            children: [
+              (0, react_jsx_runtime.jsx)("span", { style: { color: CSS_LABEL_SECONDARY }, children: t("trash.retention.label") }),
+              (0, react_jsx_runtime.jsx)("input", {
+                type: "number", min: 1, max: 365, value: trashRetention,
+                style: { width: 64, height: SMALL_CONTROL_HEIGHT, borderRadius: CONTROL_RADIUS, border: CSS_BORDER_L2, background: CSS_BG_BASE, color: CSS_LABEL_PRIMARY, padding: "0 6px", fontSize: FONT_SIZE_SMALL },
+                onChange: (e) => setTrashRetention(e.target.value),
+              }),
+              (0, react_jsx_runtime.jsx)("span", { style: { color: CSS_LABEL_TERTIARY }, children: t("trash.retention.unit") }),
+              (0, react_jsx_runtime.jsx)("button", { style: S.actionBtn(false), onClick: saveTrashRetention, children: t("trash.retention.save") }),
+              (0, react_jsx_runtime.jsx)("button", {
+                style: S.actionBtn(false),
+                disabled: !trashBatch || (trashBatch.ids ?? []).length === 0,
+                title: trashBatch ? t("trash.undo.title", { n: (trashBatch.ids ?? []).length }) : t("trash.nothingToUndo"),
+                onClick: restoreLastBatch,
+                children: t("trash.undo"),
+              }),
+              (0, react_jsx_runtime.jsx)("button", {
+                style: S.actionBtn(false),
+                disabled: trashSel.size === 0,
+                onClick: () => restoreTrash([...trashSel]),
+                children: t("trash.restoreSelected", { n: trashSel.size }),
+              }),
+              (0, react_jsx_runtime.jsx)("button", {
+                style: S.actionBtn(false),
+                disabled: (trashItems ?? []).length === 0,
+                onClick: () => setTrashSel(new Set((trashItems ?? []).map((it) => it.sessionId))),
+                children: t("trash.selectAll"),
+              }),
+              (0, react_jsx_runtime.jsx)("button", {
+                style: { ...S.actionBtn(true), borderColor: CSS_DANGER, color: CSS_DANGER, marginLeft: "auto" },
+                disabled: (trashItems ?? []).length === 0,
+                onClick: emptyTrashAll,
+                children: t("trash.empty"),
+              }),
+            ],
+          }),
+          (0, react_jsx_runtime.jsx)("div", { style: { fontSize: 11.5, color: CSS_LABEL_TERTIARY, marginBottom: 6 }, children: t("trash.hint") }),
+          trashItems === null
+            ? (0, react_jsx_runtime.jsx)("div", { style: S.empty, children: t("list.loading") })
+            : trashItems.length === 0
+              ? (0, react_jsx_runtime.jsx)("div", { style: S.empty, children: t("trash.emptyList") })
+              : trashItems.map((item) => (0, react_jsx_runtime.jsxs)("div", {
+                  style: { display: "flex", alignItems: "center", gap: 8, padding: "6px 4px", borderTop: "1px solid var(--dsw-alias-border-l1, rgba(128,128,128,.15))" },
+                  children: [
+                    (0, react_jsx_runtime.jsx)("input", {
+                      type: "checkbox",
+                      checked: trashSel.has(item.sessionId),
+                      onChange: (e) => toggleTrashSel(item.sessionId, e.target.checked),
+                    }),
+                    (0, react_jsx_runtime.jsxs)("div", {
+                      style: { flex: 1, minWidth: 0 },
+                      children: [
+                        (0, react_jsx_runtime.jsx)("div", {
+                          style: { fontSize: FONT_SIZE_SMALL, color: CSS_LABEL_PRIMARY, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+                          children: item.title || basenameOf(item.cwd) || item.sessionId,
+                        }),
+                        (0, react_jsx_runtime.jsx)("div", {
+                          style: { fontSize: 11.5, color: CSS_LABEL_TERTIARY, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+                          children: `${item.cwd || item.sessionId} ｜ ${t("trash.remaining", { n: item.remainingDays ?? 0 })}`,
+                        }),
+                      ],
+                    }),
+                    (0, react_jsx_runtime.jsx)("button", {
+                      style: S.actionBtn(false),
+                      onClick: () => restoreTrash([item.sessionId]),
+                      children: t("trash.restore"),
+                    }),
+                  ],
+                }, item.sessionId)),
+        ],
+      });
+
       const rows = sessions ?? [];
       // 列表过滤：标题 / cwd / id / 状态词（大小写不敏感）
       const ql = query.trim().toLowerCase();
@@ -747,14 +946,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", {
@@ -1085,6 +1277,11 @@
                           onClick: () => setTab("active"),
                           children: `${t("tab.active")} (${rows.filter((row) => !row.archived && (row.live === true || row.running === true)).length})`,
                         }),
+                        (0, react_jsx_runtime.jsx)("button", {
+                          style: S.tab(tab === "trash"),
+                          onClick: () => { setTab("trash"); loadTrashItems(); },
+                          children: `${t("tab.trash")}${trashItems === null ? "" : ` (${trashItems.length})`}`,
+                        }),
                         (0, react_jsx_runtime.jsx)("button", {
                           style: S.tab(tab === "help"),
                           onClick: () => setTab("help"),
@@ -1117,10 +1314,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", {
@@ -1166,32 +1369,30 @@
                           (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", {
                       style: S.body,
                       children: tab === "help"
                         ? renderHelp()
+                        : tab === "trash"
+                        ? renderTrash()
                         : (0, react_jsx_runtime.jsxs)(react.Fragment, {
                             children: [
                               // —— 全文搜索结果区（官方 FTS5 优先，自研兜底） ——

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

@@ -13,18 +13,16 @@
 
     // ---------- 工具 ----------
 
-    // 全局 fetch 超时兜底：DSH API 挂起（重负载/路由未注册）时界面不再无限等待。
-    // 与 fetch 同签名（url, opts, timeoutMs），默认 30s；分片统一走 __scFetch。
-    // timeoutMs 传 0（或负数）= **不设超时**：只适合「本来就慢、但会持续吐数据」的流式接口
-    // （会话列表冷缓存要逐份解压上百份日志，实测 41~226 秒；套 30 秒上限必然被中途掐断，
-    //  表现为面板刚重启就报「读取会话列表失败」，等缓存建好后重试又正常）。
-    // 这类接口的正确判据不是「多久没回完」，而是「有没有在吐数据」，由调用方自己盯流。
-    const FETCH_TIMEOUT_MS = 30000;
+    // 统一 fetch 入口（url, opts, timeoutMs）。**默认不设超时**。
+    // 曾经默认 30 秒「兜底」，结果两次把慢但正常的请求掐成失败：
+    //   · 会话列表冷缓存要逐份解压上百份日志（实测 41~226 秒）→ 刚重启报「读取会话列表失败」；
+    //   · 按条件筛选勾了「低价值」时要逐个会话读事件 → 报「操作失败：signal is aborted…」。
+    // 结论：**判定只能按事件驱动**（请求完成 / 失败 / 数据到达），不能靠拍一个秒数上限；
+    // 时间阈值一写死，慢就被误读成坏。真要限时，必须由调用方显式传 timeoutMs 并说清依据。
     window.__scFetch = function (url, opts, timeoutMs) {
-      const budget = timeoutMs === void 0 ? FETCH_TIMEOUT_MS : timeoutMs;
-      if (!(budget > 0)) return fetch(url, opts || {});
+      if (!(timeoutMs > 0)) return fetch(url, opts || {});
       const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), budget);
+      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));
     };