zcode-pro 0.20.3 → 1.0.0

package/src/inject/features/ws-running.js

@@ -17,6 +17,7 @@
 // 恢复，探查会打扰（实测首启会出现项目逐个展开又收起的干扰）。
 // 开关：helper wsRunningSpin（默认 true）。
 import { rpc } from '../core.js';
+import { projectRows, findProjectRow, rowPath, projectRowSelector } from './ws-rows.js';
 
 let installed = false;
 let enabled = true;
@@ -33,7 +34,80 @@ const CONFIG_POLL_MIN_MS = 5000;   // 配置未变化时逐次拉长轮询间隔
 const CONFIG_POLL_MAX_MS = 60000;
 
 const TASK_SEL = '[data-task-item-key]';
-const WS_SEL = '[data-testid^="workspace-item-"]';
+// 项目行选择器双结构（3.15.x 旧 testid 行 / 3.16.1 起 section[data-project-id]）
+const WS_SEL = () => projectRowSelector();
+
+function findWsRow(ws) {
+  return findProjectRow(ws);
+}
+
+// 折叠且运行中时，项目图标换成与任务行运行中同款的 loader（lucide 圆弧 +
+// 应用自带的 animate-spin 类，旋转速度与任务行完全一致）；结束后还原 folder。
+// React 重渲染会重建 folder svg，apply 周期（观察器 + 兜底轮询）会重新换上
+// 与任务行同款 loader：优先克隆页面上官方 loader 图标（形状/粗细/段数自动跟随
+// 应用版本），找不到再用内置的 lucide loader 多段短辐条图形（不是单圆弧）
+const LOADER_FALLBACK_PATHS = [
+  'M12 2v4', 'm16.2 7.8 2.9-2.9', 'M18 12h4', 'm19.8 16.2-2.9 2.9',
+  'M12 18v4', 'm7.8 19.8-2.9-2.9', 'M6 12H2', 'm4.2 7.8 2.9-2.9',
+];
+function makeLoaderSvg(baseClass) {
+  const ns = 'http://www.w3.org/2000/svg';
+  const proto = document.querySelector('svg.lucide-loader');
+  if (proto) {
+    const clone = proto.cloneNode(true);
+    const origClass = proto.getAttribute('class') || '';
+    // 保留尺寸/颜色类，去掉官方动画（显隐由我们控制，animate 统一自己加）
+    const keep = origClass.split(/\s+/).filter((c) => /^(size-|text-)/.test(c)).join(' ');
+    clone.setAttribute('class', ((keep || baseClass) + ' animate-spin zcodepro-ws-loader').trim());
+    return clone;
+  }
+  const svg = document.createElementNS(ns, 'svg');
+  svg.setAttribute('viewBox', '0 0 24 24');
+  svg.setAttribute('fill', 'none');
+  svg.setAttribute('stroke', 'currentColor');
+  svg.setAttribute('stroke-width', '2');
+  svg.setAttribute('stroke-linecap', 'round');
+  svg.setAttribute('stroke-linejoin', 'round');
+  svg.setAttribute('class', (baseClass + ' animate-spin zcodepro-ws-loader').trim());
+  for (const d of LOADER_FALLBACK_PATHS) {
+    const path = document.createElementNS(ns, 'path');
+    path.setAttribute('d', d);
+    svg.append(path);
+  }
+  return svg;
+}
+function setRunningIcon(holder, on) {
+  if (!holder) return;
+  if (on) {
+    // folder 的隐藏由 CSS 完成（span.zcodepro-ws-running 类稳定，React 重建的
+    // folder 也会被规则罩住）；这里只负责确保 loader 在场
+    if (holder.querySelector(':scope > svg.zcodepro-ws-loader')) return;
+    const orig0 = holder.querySelector(':scope > svg:not(.zcodepro-ws-loader)');
+    const base = (orig0 ? (orig0.getAttribute('class') || '') : 'size-4').replace(/lucide-[a-z-]*/g, '').trim() || 'size-4';
+    holder.append(makeLoaderSvg(base));
+  } else {
+    holder.querySelectorAll(':scope > svg.zcodepro-ws-loader').forEach((el) => el.remove());
+  }
+}
+
+// 行首图标容器（旋转图标的挂点）：
+// 旧结构：行.firstElementChild 里的 span；新结构：virtual-project-toggle 的首个 span（folder 图标容器）
+function iconHolderOf(row) {
+  if (row.hasAttribute && row.hasAttribute('data-project-id')) {
+    const toggle = row.querySelector('[data-testid="virtual-project-toggle"]');
+    return toggle ? toggle.querySelector(':scope > span') : null;
+  }
+  return row.firstElementChild && row.firstElementChild.querySelector(':scope > span');
+}
+
+// 运行中的行首图标是 loader；空闲行该位置为空或错误/未读圆点。只认行首图标位
+// （旧结构为 span>svg 嵌套，新结构槽 span 直接含 svg，两者都在 firstElementChild 子树内）
+function isRunningRow(el) {
+  const scope = el.firstElementChild;
+  if (!scope) return false;
+  const svg = scope.querySelector('svg[class*="lucide-loader"]');
+  return !!svg;
+}
 
 const runningByWs = new Map(); // 工作区路径（原样，来自会话键）→ Set(会话键)
 const peekTimers = new Map();  // 工作区 → 复核定时器
@@ -44,6 +118,78 @@ let wsWithRows = new Set();    // 最近一次扫描时仍有会话行在 DOM
 
 // —— 工具 ——
 
+// 应用内部服务对象（含 zcodeTaskService.releaseWorkspacePreparation）：从 React
+// fiber 树上找持有它的组件（file-menu.js 同款取 fiber 的思路），找到后缓存
+let servicesRef = null;
+export function findServices() {
+  if (servicesRef) return servicesRef;
+  try {
+    const rootEl = document.getElementById('root');
+    const containerKey = rootEl && Object.keys(rootEl).find((k) => k.startsWith('__reactContainer$'));
+    if (!containerKey) return null;
+    const seen = new Set();
+    let found = null;
+    const scanObj = (o) => {
+      if (!o || typeof o !== 'object' || seen.has(o) || found) return;
+      seen.add(o);
+      const ts = o.zcodeTaskService;
+      if (ts && typeof ts === 'object' && typeof ts.releaseWorkspacePreparation === 'function') found = o;
+    };
+    let visited = 0;
+    const visit = (f) => {
+      if (!f || found || visited > 60000) return;
+      visited++;
+      for (const holder of [f.memoizedProps, f.memoizedState]) {
+        if (!holder || typeof holder !== 'object') continue;
+        scanObj(holder);
+        for (const v of Object.values(holder)) {
+          if (v && typeof v === 'object') scanObj(v);
+        }
+      }
+      visit(f.child);
+      visit(f.sibling);
+    };
+    visit(rootEl[containerKey]);
+    if (found) servicesRef = found;
+    return found;
+  } catch {
+    return null;
+  }
+}
+
+// 权威空闲判定：官方 zcodeTaskService.listActiveTaskIds 返回该工作区仍处非终态
+// （运行/创建/流式等）的会话，来自 CLI 实时活动集合——比侧栏 DOM 的 loader 可靠
+// （DOM 有“提交消息到 loader 渲染”与页面刷新后折叠项目的盲区，曾致误杀）。
+// workspacePath 的尾斜杠形式必须与订阅时一致（roots 两种都有），两种各查一次。
+// 返回 true=确认空闲、false=仍在运行、null=接口不可用或查询失败（按忙处理）
+export async function authoritativeIdle(ws) {
+  const services = findServices();
+  const ts = services && services.zcodeTaskService;
+  if (!ts || typeof ts.listActiveTaskIds !== 'function') return null;
+  try {
+    const base = String(ws).replace(/[\\/]+$/, '');
+    const a = await ts.listActiveTaskIds({ workspacePath: base });
+    const b = await ts.listActiveTaskIds({ workspacePath: base + '/' });
+    const ids = [...(Array.isArray(a) ? a : []), ...(Array.isArray(b) ? b : [])].map(String);
+    if (!Array.isArray(a) || !Array.isArray(b)) return null;
+    if (!ids.length) return true;
+    // 终态过滤与 globalAnyActive 同一判据：syncer 卡滞的已完成会话不算运行
+    //（DB status 终态且近 5 分钟无更新 = 卡滞；有更新 = 复活在跑）
+    const st = await rpc('/task-statuses?ids=' + encodeURIComponent(ids.join(','))).catch(() => null);
+    const TERMINAL = new Set(['completed', 'error', 'interrupted']);
+    const live = (id) => {
+      const rec = st && st.ok && st.available ? st.statuses[id] : undefined;
+      if (rec === undefined) return true;
+      if (!TERMINAL.has(rec.status)) return true;
+      return Date.now() - rec.updatedAt < 300_000;
+    };
+    return !ids.some(live);
+  } catch {
+    return null; // 方法不存在（≤3.15.x 的服务对象）或查询失败：一律按忙
+  }
+}
+
+
 function workspaceOf(key) {
   // 会话键格式 <workspace_path>:<sess_id>；sess 段固定以 "sess_" 开头，
   // 按它定位分隔符（Windows 盘符路径里也有冒号，不能按第一个 ':' 切）
@@ -51,22 +197,11 @@ function workspaceOf(key) {
   return i > 0 ? key.slice(0, i) : key;
 }
 
-function findWsRow(ws) {
-  return document.querySelector(`[data-testid="workspace-item-${CSS.escape(ws)}"]`);
-}
-
 function wsHead(row) {
+  // 旧结构行容器自身带 aria-expanded；新结构在 virtual-project-toggle 按钮上
   return row.matches('[aria-expanded]') ? row : row.querySelector('[aria-expanded]');
 }
 
-// 运行中的行首图标是 loader；空闲行该位置为空 span（无 svg）。只认行首图标位
-// （span 的直接子级），行内操作按钮等处将来即使出现 loader 也不算
-function isRunningRow(el) {
-  const holder = el.firstElementChild && el.firstElementChild.querySelector(':scope > span');
-  if (!holder) return false;
-  return [...holder.children].some((c) => c.tagName === 'svg' && (c.getAttribute('class') || '').includes('lucide-loader'));
-}
-
 function domRowsOf(ws) {
   return [...document.querySelectorAll(TASK_SEL)]
     .filter((e) => workspaceOf(e.getAttribute('data-task-item-key') || '') === ws);
@@ -168,20 +303,219 @@ function handleRemovals(muts) {
 
 function apply() {
   const seen = new Set();
-  for (const row of document.querySelectorAll(WS_SEL)) {
-    const path = row.getAttribute('data-testid').slice('workspace-item-'.length);
+  for (const row of document.querySelectorAll(WS_SEL())) {
+    const path = rowPath(row);
+    if (!path) continue;
     seen.add(path);
     const head = wsHead(row);
     const collapsed = !head || head.getAttribute('aria-expanded') === 'false';
-    const running = !!(enabled && collapsed && runningByWs.get(path) && runningByWs.get(path).size);
-    // 类挂在图标的外层 span 上：展开/收起时 React 会重建 svg，span 是稳定节点
-    const icon = row.firstElementChild && row.firstElementChild.querySelector(':scope > span');
-    if (icon) icon.classList.toggle('zcodepro-ws-running', running);
+    // 折叠态优先权威扫描结果（多目录项目的行匹配在 DOM 侧不可靠）；
+    // 权威不可用（≤3.15.x）时回退 DOM 运行记录
+    const domRunning = !!(runningByWs.get(path) && runningByWs.get(path).size);
+    // 路径两侧都去尾分隔符再比（任务键前缀可能带尾斜杠，权威集合不带）
+    const normP = (v) => String(v || '').replace(/[\\/]+$/, '');
+    const running = enabled && collapsed && (activeProjectPaths.size ? [...activeProjectPaths].some((p2) => normP(p2) === normP(path)) : domRunning);
+    // 换同款 loader 图标（类标记仅用于 CSS 隐藏 folder）
+    const icon = iconHolderOf(row);
+    icon?.classList.toggle('zcodepro-ws-running', running);
+    setRunningIcon(icon, running);
   }
+  // 分区头（“任务”“项目”官方分区按钮与“已置顶”标题）：分区内有任务在跑时
+  // 头部行首挂同款 loader（分区折叠后任务行不在场，检测不到自然熄灭）
+  applySectionSpin();
   // 侧栏里已不存在的项目清掉状态
   for (const ws of [...runningByWs.keys()]) if (!seen.has(ws)) runningByWs.delete(ws);
 }
 
+// 分区头识别：官方分区头按钮（含 chevron svg）与“已置顶”标题（h3）。
+// 归属（project/task）与容器引用只在分区展开时解析一次并缓存（WeakMap）：
+// 分区折叠后其容器整体卸载，向上重解析会落到别的分区容器（如展开着的
+// “任务”分区），把“项目”头误判成 task——折叠期间一律用缓存的归属，
+// 不再重解析；React 重建头部元素时缓存失效，展开态会重新解析补上
+const headInfoCache = new WeakMap(); // head → { cont, kind }
+// 文本兜底：分区头按钮被界面重建且其分区正折叠（自有容器已卸载、无法结构
+// 解析）时，按分区名定归属——向外层猜会落到含项目行的容器，把“任务”头
+// 误判成“项目”（实测）。分区名跟随界面语言，zh/en 双语覆盖
+// 官方分区标题（i18n 键 project.projects / project.tasks 的实际文案，随界面
+// 语言）：zh 项目/任务、en Projects/Tasks。语言包再加语言时同步此处
+const PROJECT_HEAD_TEXTS = new Set(['项目', 'projects']);
+const TASK_HEAD_TEXTS = new Set(['任务', 'tasks']);
+function kindFromHeadText(head) {
+  const text = (head.textContent || '').trim().toLowerCase();
+  if (PROJECT_HEAD_TEXTS.has(text)) return 'project';
+  if (TASK_HEAD_TEXTS.has(text)) return 'task';
+  return null;
+}
+function sectionHeads() {
+  const heads = [];
+  for (const sv of document.querySelectorAll('svg[data-purpose-section-chevron]')) {
+    const btn = sv.closest('button');
+    if (btn) heads.push(btn);
+  }
+  for (const h3 of document.querySelectorAll('h3')) heads.push(h3);
+  return heads.map((head) => {
+    const cached = headInfoCache.get(head);
+    if (cached) return { head, cont: cached.cont, kind: cached.kind };
+    // 官方分区头（BUTTON）的归属以分区名为准（“项目”/“任务”是官方固定分区，
+    // 文本即真值）；结构解析只在文本不认识时兜底。已置顶标题（h3）恒属 task。
+    const textKind = head.tagName === 'BUTTON' ? kindFromHeadText(head) : 'task';
+    let cont = head.parentElement;
+    while (cont && !cont.querySelector('li[data-task-item-key]') && cont !== document.body) cont = cont.parentElement;
+    const contOk = cont && cont !== document.body;
+    const kind = textKind || (contOk ? (cont.querySelector('section[data-project-id]') ? 'project' : 'task') : null);
+    headInfoCache.set(head, { cont: contOk ? cont : null, kind });
+    return { head, cont: contOk ? cont : null, kind };
+  }).filter((x) => x.head);
+}
+
+const SEC_SPIN_CLASS = 'zcodepro-ws-sec-spin';
+
+// 全局权威扫描：listActiveTaskIds 遍历侧栏全部项目（/projects-v2 提供路径，
+// 尾斜杠两种形式各查一次），任一非终态会话即“有任务在跑”。10 秒节流缓存；
+// 接口不可用（≤3.15.x）时无缓存，分区头退回 DOM 检测
+let anyActiveCache = { at: 0, value: null, busy: false };
+// 活跃按分区归属：task = “任务”分区（非项目工作区），project = “项目”分区
+const sectionActive = { task: false, project: false };
+// 权威扫描发现的有活跃任务的项目路径集合（全部 root）；项目行折叠态判定用
+let activeProjectPaths = new Set();
+// 周期复查：缓存到期就无条件重扫（不看当前值）——只在 true 时扫会有两个缺口：
+// 空闲后新任务启动无人触发（折叠分区头不亮）；任务结束但数据库完成状态尚未
+// 写入的过渡窗口里旧值一直被沿用。每 10 秒全量一次，扫描本身是内存级过滤
+setInterval(() => {
+  if (!anyActiveCache.busy && Date.now() - anyActiveCache.at >= 10_000) globalAnyActive();
+}, 10_000);
+function globalAnyActive() {
+  if (anyActiveCache.value !== null && Date.now() - anyActiveCache.at < 10_000) return anyActiveCache.value;
+  if (anyActiveCache.busy) return anyActiveCache.value === true;
+  anyActiveCache.busy = true;
+  sectionActive.task = false;
+  sectionActive.project = false;
+  activeProjectPaths = new Set();
+  void (async () => {
+    let hit = null;
+    try {
+      const res = await rpc('/projects-v2').catch(() => null);
+      const services = findServices();
+      const ts = services && services.zcodeTaskService;
+      if (res && res.ok && res.available && ts && typeof ts.listActiveTaskIds === 'function') {
+        hit = false;
+        // 项目路径集合（任一 root）：活跃任务命中即属“项目”分区；非项目工作区
+        //（draft/独立任务）的活跃属“任务”分区——两个分区头分别提示
+        const projPaths = new Set();
+        for (const proj of res.projects || []) {
+          for (const r of proj.roots || []) {
+            const b = String(r.path || '').replace(/[\\/]+$/, '');
+            if (b) projPaths.add(b);
+          }
+        }
+        // 非项目工作区清单收紧：任务索引的 workspace_path 含历史残留（旧机器/
+        // 已删目录），syncer 可能在其上误报活跃；只认“任务”分区实际会显示的——
+        // 即侧栏当前可见的任务行所在工作区（从 DOM 任务行键取，分区展开时可靠）
+        const taskSidePaths = new Set();
+        for (const el of document.querySelectorAll('[data-task-item-key]')) {
+          const sec = el.closest('section[data-project-id]');
+          if (sec) continue; // 项目内任务的运行由项目侧覆盖
+          const k = el.getAttribute('data-task-item-key') || '';
+          const cut = k.lastIndexOf(':');
+          if (cut > 1) taskSidePaths.add(k.slice(0, cut).replace(/[\\/]+$/, ''));
+        }
+        const scanPaths = new Set([...projPaths, ...taskSidePaths]);
+        const byKind = { task: new Set(), project: new Set() };
+        const byKindByPath = new Map(); // base → 活跃 id 数组
+        const rootToProject = new Map(); // root 路径 → 项目名
+        const projectPaths = new Map(); // 项目名 → 全部 root 路径
+        for (const proj of res.projects || []) {
+          const names = [];
+          for (const r of proj.roots || []) {
+            const b = String(r.path || '').replace(/[\\/]+$/, '');
+            if (b) { rootToProject.set(b, proj.name); names.push(b); }
+          }
+          projectPaths.set(proj.name, names);
+        }
+        for (const base of scanPaths) {
+          const a = await ts.listActiveTaskIds({ workspacePath: base });
+          const b = await ts.listActiveTaskIds({ workspacePath: base + '/' });
+          const ids = [...(Array.isArray(a) ? a : []), ...(Array.isArray(b) ? b : [])].map(String);
+          if (!ids.length) continue;
+          byKindByPath.set(base, ids);
+          const kind = projPaths.has(base) ? 'project' : 'task';
+          for (const id of ids) byKind[kind].add(id);
+        }
+        const allIds = [...byKind.task, ...byKind.project];
+        // 终态过滤：官方 syncer 可能卡滞（已完成仍报活跃，任务行 loader 卡转），
+        // 到任务索引核对，已终态的不计
+        const st = allIds.length ? await rpc('/task-statuses?ids=' + encodeURIComponent(allIds.join(','))).catch(() => null) : null;
+        // 终态判据须加新近度：DB 的 status 是“最后结局”，会话被复活继续用时
+        // 不回滚（实测本会话 interrupted 后复跑）——终态但 updated_at 近 5 分钟内
+        // 有动静的按真活跃；长期不动的才是 syncer 卡滞误报
+        const TERMINAL = new Set(['completed', 'error', 'interrupted']);
+        const live = (id) => {
+          const rec = st && st.ok && st.available ? st.statuses[id] : undefined;
+          if (rec === undefined) return true;
+          if (!TERMINAL.has(rec.status)) return true;
+          return Date.now() - rec.updatedAt < 300_000;
+        };
+        // 活跃的项目路径集合（项目行折叠态判定用）：按 root→项目聚合，
+        // 该项目任一 root 上有活跃任务即记入
+        activeProjectPaths = new Set();
+        for (const [base, ids] of byKindByPath) {
+          if (!projPaths.has(base)) continue;
+          if (ids.some(live)) {
+            const projName = rootToProject.get(base);
+            if (projName) for (const p2 of projectPaths.get(projName) || []) activeProjectPaths.add(p2);
+          }
+        }
+        // 任务侧再加一道 DOM 确认：非项目任务行上必须真有 loader 在转——
+        // 侧栏显示的就是真相，syncer 报告的活跃（尤其历史残留工作区）不足为凭
+        const taskDomRunning = !!document.querySelector('[data-task-item-key]:not(section[data-project-id] *) svg[class*="lucide-loader"]');
+        if (taskDomRunning && [...byKind.task].some(live)) sectionActive.task = true;
+        if ([...byKind.project].some(live)) sectionActive.project = true;
+        hit = sectionActive.task || sectionActive.project;
+      }
+    } catch { /* 查询失败保持旧值 */ }
+    if (hit !== null) anyActiveCache = { at: Date.now(), value: hit, busy: false };
+    else anyActiveCache.busy = false;
+    apply();
+  })();
+  return anyActiveCache.value === true;
+}
+function applySectionSpin() {
+  if (!enabled) {
+    document.querySelectorAll('.' + SEC_SPIN_CLASS).forEach((el) => el.remove());
+    return;
+  }
+  for (const { head, cont, kind } of sectionHeads()) {
+    const running = !!(cont && cont.querySelector('li[data-task-item-key] svg[class*="lucide-loader"]'));
+    // “任务”分区与“已置顶”标题：展开时任务行的 loader 直接可见，头部不再重复
+    // 提示，仅在分区折叠时挂。“项目”分区头（容器含项目行 section）不受此限——
+    // 折叠的单个项目仍由项目行的权威复核提示。
+    // 仅分区折叠时显示：展开时任务行的 loader 直接可见，头部不重复。
+    // 分区折叠会把内容行全部卸载（DOM 检测失效），改看权威扫描按归属分类的活跃：
+    // “项目”分区头看项目侧，“任务”分区与“已置顶”标题看非项目工作区（draft 等）
+    let expanded = true;
+    if (head.tagName === 'BUTTON') expanded = head.getAttribute('aria-expanded') !== 'false';
+    else {
+      // 已置顶标题（h3）：折叠是藏起任务列表，按列表实际显示判定
+      const list = head.nextElementSibling;
+      expanded = !list || list.offsetHeight > 0;
+    }
+    if (!kind) return; // 折叠后解析不到归属且无缓存：跳过（不动现有图标）
+    const scoped = kind === 'project' ? sectionActive.project : sectionActive.task;
+    // 折叠态一律只信权威扫描：DOM 检测在折叠后不可靠（容器卸载后解析会落到
+    // 别的分区，多目录项目的行匹配也套不上），且权威扫描周期覆盖刷新
+    const want = !expanded && scoped;
+    const existing = head.querySelector(':scope > .' + SEC_SPIN_CLASS);
+    if (want && !existing) {
+      const span = document.createElement('span');
+      span.className = 'flex size-4 shrink-0 items-center justify-center ' + SEC_SPIN_CLASS;
+      span.append(makeLoaderSvg('size-4'));
+      head.prepend(span);
+    } else if (!want && existing) {
+      existing.remove();
+    }
+  }
+}
+
 // —— 无感探查 ——
 
 function schedulePeek(ws, delay) {
@@ -215,6 +549,23 @@ function syncPeeks() {
 let peekChain = Promise.resolve();
 
 async function peek(ws, opts) {
+  // 折叠期间的周期复核（非 manual）优先走官方权威判定：不展开项目、没有
+  // “先展开再缩起”的高度起伏；接口不可用（≤3.15.x）时走原 DOM 无感探查
+  if (!opts?.manual) {
+    const auth = await authoritativeIdle(ws);
+    if (auth !== null) {
+      if (auth) {
+        runningByWs.delete(ws); // 空闲：熄灭旋转
+      } else {
+        let set = runningByWs.get(ws);
+        if (!set) { set = new Set(); runningByWs.set(ws, set); }
+        set.add(ws + ':active'); // 占位键：apply 只看集合大小
+        schedulePeek(ws, PEEK_REPEAT_MS);
+      }
+      apply();
+      return true;
+    }
+  }
   const run = () => peekInner(ws, opts);
   const p = peekChain.then(run, run);
   peekChain = p.catch(() => {});
@@ -252,9 +603,10 @@ async function peekInner(ws, opts) {
   // 会话行隐藏改走 style 元素（见 installPeekHider）：挂载当帧即 display:none，
   // 与观察器回调时序、列表容器结构均无关
   const hider = installPeekHider(ws);
+  let readOk = false;
   try {
     toggleNavSafe(head);
-    await settleAndRead(ws);
+    readOk = await settleAndRead(ws);
     // 读完后收起；用户在探查期间点了项目行就不再干预
     const rowNow = findWsRow(ws) || row;
     const headNow = wsHead(rowNow);
@@ -273,7 +625,8 @@ async function peekInner(ws, opts) {
   apply();
   const set = runningByWs.get(ws);
   if (set && set.size && enabled) schedulePeek(ws, PEEK_REPEAT_MS);
-  return true;
+  // 一个任务行都没读到（展开没生效/行未渲染）= 未验证成，调用方按“忙”处理
+  return readOk;
 }
 
 // —— 供 idle-reclaim 复用 ——
@@ -308,11 +661,13 @@ export async function verifyWorkspaceNotRunning(ws) {
 }
 
 // 等该项目的会话行渲染稳定后读取运行状态；行始终没出现视为项目无会话，清除记录
+// resolve(true)=读到行并稳定；resolve(false)=一个行都没读到（未验证成）
 function settleAndRead(ws) {
   return new Promise((resolve) => {
     const t0 = Date.now();
     let lastCount = -1;
     let stableAt = 0;
+    let zeroRows = false;
     const timer = setInterval(() => {
       const rows = domRowsOf(ws);
       const elapsed = Date.now() - t0;
@@ -321,7 +676,9 @@ function settleAndRead(ws) {
       if (!settled && elapsed < PEEK_MAX_MS) return;
       clearInterval(timer);
       if (lastCount === 0) {
-        runningByWs.delete(ws);
+        // 一个任务行都没读到：多半是展开没生效或行尚未渲染，不能当作“项目无
+        // 会话”清掉运行记录（idle-reclaim 复核据此判空闲会误杀运行中会话）
+        zeroRows = true;
       } else {
         let set = runningByWs.get(ws);
         if (!set) { set = new Set(); runningByWs.set(ws, set); }
@@ -331,7 +688,7 @@ function settleAndRead(ws) {
           else set.delete(key);
         }
       }
-      resolve();
+      resolve(!zeroRows);
     }, 80);
   });
 }
@@ -398,12 +755,12 @@ function relevant(muts) {
   // 增删、React 重建行内元素），聊天流式输出的 characterData/class 高频变动
   // 一概不进回调（实测后台态全页 5 秒仅 5 个变动、全为非 childList）
   for (const m of muts) {
-    if (inSel(m.target, TASK_SEL) || inSel(m.target, WS_SEL)) return true;
+    if (inSel(m.target, TASK_SEL) || inSel(m.target, WS_SEL())) return true;
     for (const n of m.addedNodes) {
-      if (n instanceof Element && (n.matches(TASK_SEL) || n.matches(WS_SEL) || n.querySelector(TASK_SEL) || n.querySelector(WS_SEL))) return true;
+      if (n instanceof Element && (n.matches(TASK_SEL) || n.matches(WS_SEL()) || n.querySelector(TASK_SEL) || n.querySelector(WS_SEL()))) return true;
     }
     for (const n of m.removedNodes) {
-      if (n instanceof Element && (n.matches(TASK_SEL) || n.matches(WS_SEL) || n.querySelector(TASK_SEL))) return true;
+      if (n instanceof Element && (n.matches(TASK_SEL) || n.matches(WS_SEL()) || n.querySelector(TASK_SEL))) return true;
     }
   }
   return false;
@@ -466,7 +823,7 @@ export function startWsRunningSpin() {
   // 只认真实点击：探查自己派发的合成点击（isTrusted=false）不算用户操作
   document.addEventListener('click', (e) => {
     if (!e.isTrusted) return;
-    const row = e.target instanceof Element && e.target.closest(WS_SEL);
+    const row = e.target instanceof Element && e.target.closest(WS_SEL());
     if (row) wsTouchAt.set(row, Date.now());
   }, true);
 }

package/src/inject/index.js

@@ -7,11 +7,11 @@ import { handleFileMenu } from './features/file-menu.js';
 import { startImageMenu } from './features/image-menu.js';
 import { startSettingsEntry } from './features/settings-entry.js';
 import { startAliasWatcher } from './features/alias.js';
+import { startAliasMigrationWatcher } from './features/alias-migration.js';
 import { startTaskOrderWatcher } from './features/task-order.js';
 import { startSessionSwitch } from './features/session-switch.js';
 import { startTitleLock } from './features/title-lock.js';
 import { startTitleGen } from './features/title-gen.js';
-import { startPinnedExpandSuppression } from './features/pinned-expand.js';
 import { startWsRunningSpin } from './features/ws-running.js';
 import { startIdleReclaim } from './features/idle-reclaim.js';
 import { startToolbarIcons } from './features/toolbar-icons.js';
@@ -48,12 +48,13 @@ import { ensureStyle } from './ui.js';
       try { handleFileMenu(content); } catch { /* ignore */ }
     });
     try { void startAliasWatcher(); } catch { /* ignore */ }
+    // 别名迁移弹窗（3.16.1+ 且仍有存量别名时才动作），内部自带等待与窗口聚焦判断
+    try { startAliasMigrationWatcher(); } catch { /* ignore */ }
     try { startTaskOrderWatcher(); } catch { /* ignore */ }
     try { startSessionSwitch(); } catch { /* ignore */ }
     try { startTitleLock(); } catch { /* ignore */ }
     try { startTitleGen(); } catch { /* ignore */ }
     try { startImageMenu(); } catch { /* ignore */ }
-    try { startPinnedExpandSuppression(); } catch { /* ignore */ }
     try { startWsRunningSpin(); } catch { /* ignore */ }
     try { startIdleReclaim(); } catch { /* ignore */ }
     try { startToolbarIcons(); } catch { /* ignore */ }

package/src/inject/ui.js

@@ -38,7 +38,7 @@ const contentClass = 'w-full sm:max-w-md rounded-2xl border-none bg-popover/98 p
 // Esc 只关最上层，避免一次 Esc 把两层一起关掉
 let dialogStack = [];
 
-export function openDialog({ title, description, onMount, onClose, width = 'sm:max-w-md', overlay = 'dim', draggable = false, posKey = '', dismissOnOutside = true, bodyClass = '' }) {
+export function openDialog({ title, description, onMount, onClose, width = 'sm:max-w-md', overlay = 'dim', draggable = false, posKey = '', dismissOnOutside = true, bodyClass = '', closable = false }) {
   const L = t();
   const prevActive = document.activeElement;
   let cleanupDrag = null;
@@ -72,8 +72,21 @@ export function openDialog({ title, description, onMount, onClose, width = 'sm:m
   }
 
   const titleEl = h('h2', { class: 'text-lg font-semibold leading-none tracking-tight text-foreground' }, title);
+  // closable：标题行右侧加 ✕（样式与设置弹窗的自绘关闭钮同款）；拖动把手仍是标题文字本身
+  const titleRow = closable
+    ? h('div', { class: 'flex items-start justify-between gap-2' },
+        titleEl,
+        h('button', {
+          type: 'button',
+          class: 'zcodepro-close',
+          title: L.close,
+          'aria-label': L.close,
+          onMousedown: (e) => { e.stopPropagation(); },
+          onClick: () => { close(); },
+        }, '✕'))
+    : titleEl;
   content.append(
-    titleEl,
+    titleRow,
     // 注意不能把 null 直接传给 append：DOM 会把 null 渲染成字面量 "null" 文本
     ...(description ? [h('p', { class: 'mt-2 text-ui-sm/relaxed text-foreground-subtle' }, description)] : [])
   );
@@ -345,7 +358,7 @@ export function settingRow(name, desc, checked, onToggle, extra) {
   },
     h('div', { class: 'min-w-0 flex-1' },
       h('div', { class: 'text-ui-sm font-medium text-foreground' }, name),
-      ...(desc ? [h('div', { class: 'mt-0.5 text-ui-xs/relaxed text-foreground-subtle' }, desc)] : [])),
+      h('div', { class: 'mt-0.5 text-ui-xs/relaxed text-foreground-subtle', 'data-zcodepro-row-desc': '' }, desc ?? '')),
     ...(extraEl ? [extraEl] : []),
     h('button', {
       type: 'button',
@@ -623,13 +636,9 @@ export function ensureStyle() {
     .zcodepro-imgmenu-item:hover {
       background-color: var(--color-accent, color-mix(in oklab, var(--color-foreground, #888) 10%, transparent));
     }
-    /* 折叠项目运行提示（ws-running.js）：项目图标旋转。动画类挂在图标外层的
-       稳定 span 上，展开/收起时应用重建 svg 也不受影响；时长与应用 loader 一致 */
-    @keyframes zcodepro-ws-spin { to { transform: rotate(360deg); } }
-    span.zcodepro-ws-running > svg {
-      animation: zcodepro-ws-spin 1s linear infinite;
-      transform-origin: center;
-    }
+    /* 折叠项目运行提示：folder 图标让位给 loader（loader 由脚本插入，
+       folder 可能被 React 随时重建，靠类选择器统一隐藏，后代写法兼容包装层） */
+    span.zcodepro-ws-running svg:not(.zcodepro-ws-loader) { display: none !important; }
     /* 无感探查期间盖在项目行上的冻结克隆：固定定位、不响应指针 */
     .zcodepro-ws-frozen {
       position: fixed;
@@ -743,7 +752,7 @@ export function ensureStyle() {
     }
     .zcodepro-pin-head:hover .zcodepro-pin-chevron svg { opacity: 1; }
     .zcodepro-pin-collapsed .zcodepro-pin-chevron svg { transform: rotate(-90deg); }
-    .zcodepro-pin-collapsed > ul { display: none !important; }
+    .zcodepro-pin-collapsed > :is(ul, div):has(li[data-task-item-key]) { display: none !important; }
     /* 折叠后去掉标题自带的底部留白，与下一分区的间隔和其他分区节奏一致 */
     .zcodepro-pin-collapsed .zcodepro-pin-head { padding-bottom: 0; }
   `));