magic-agent 2.4.2 → 2.6.0

package/client-ui-mobile/reqs.js

@@ -24,18 +24,25 @@
   var H = null;                // 宿主（index.html 注入）
   var els = {};                // 需求页内部元素
   var REQ_DATA = null;         // 最近一次清单（重画用，避免每次点都重新拉）
-  var REQ_BUSY = false;        // 「整理」进行中（防重复点击）
+  /* 整理进行中的状态：**按空间**各记一把锁（2026-10-24 用户：「点一个模块整理，
+     其他整理也不能点了 不对」）。同一空间内的空间级 / 模块级整理互斥（共享 state 文件），
+     不同空间互不影响；「全部整理」才是全局锁。 */
+  var REQ_BUSY = {};           // 空间 key → 该入口的进行中文案（空对象 = 没有单空间在整理）
+  var REQ_BATCH = false;       // 「全部整理」进行中（它本来就要串行跑所有空间）
   var REQ_BUSY_LABEL = '全部整理'; // 顶栏按钮的进行中文案（重渲染后要能恢复）
-  var REQ_BUSY_KEY = '';       // 本次整理的组头（空间 key；空 = 全部整理，所有组头都置忙）
   var REQ_OPEN = {};           // 工作区展开状态（key = 工作区 id），与会话列表的 WS_OPEN 同构
   var REQ_ALIVE = null;        // 仍有会话的空间路径集合；null = 拿不到会话清单（不筛）
   var REQ_DETAIL = null;       // 二级视图：{key: 工作区 key, mod: 模块名, ws: 工作区对象}
+  var REQ_GRAPH_WS = null;     // 图谱视图：当前画的是哪个工作区（复用 #reqDetail 容器）
 
   /* 一级 / 二级两个容器的内容都在这里渲染 —— index.html 里只留空壳。 */
   var ROOT_HTML =
     '<div class="history__top">' +
       '<span class="history__title">需求</span>' +
-      '<button class="history__disconnect" id="btnReqSync" type="button">全部整理</button>' +
+      '<span class="history__topacts">' +
+        '<button class="history__disconnect reqs__graphbtn" id="btnReqGraph" type="button">图谱</button>' +
+        '<button class="history__disconnect" id="btnReqSync" type="button">全部整理</button>' +
+      '</span>' +
     '</div>' +
     '<div class="history__list" id="reqList"></div>';
   var DETAIL_HTML =
@@ -45,16 +52,163 @@
       '<button class="history__disconnect" id="btnReqDetailSync" type="button" title="只整理这个模块">整理</button>' +
     '</div>' +
     '<div class="history__list" id="reqDetailList"></div>';
+  var GRAPH_HTML =
+    '<div class="history__top">' +
+      '<button class="topbar__icon" id="btnReqGraphBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>' +
+      '<span class="history__title" id="reqGraphTitle">关系图谱</span>' +
+    '</div>' +
+    '<div class="reqgraph__pick" id="reqGraphPick"></div>' +
+    '<div class="reqgraph__stage" id="reqGraphStage"><div class="history__hint">读取中…</div></div>' +
+    '<div class="reqgraph__legend" id="reqGraphLegend"></div>';
 
-  /* 路径归一：只去尾部斜杠，不做 realpath —— 与 core 登记表里的 workspace 同一口径。 */
-  function reqNormDir(p) { return String(p || '').replace(/\/+$/, ''); }
+  /* 路径归一：**统一分隔符 + 去尾部斜杠**。
+     ⚠️ 必须统一 '\\' → '/'：桌面可能是 Windows，服务端给的是 D:\workspace\magic-agent，
+        而自定义空间里存的是归一后的 D:/workspace/magic-agent —— 不统一就认不出是同一个
+        空间（需求页会多出一个空间组、别名也贴不上）。
+     ⚠️ 任务页（index.html）里有一份同名实现 —— 改动两处要同步，否则两页口径就分叉了。 */
+  function reqNormDir(p) { return String(p || '').replace(/\\/g, '/').replace(/\/+$/, ''); }
+  /* 空间键（比较用）：归一之上再修**盘符大小写**（Windows 上 d: 与 D: 是同一个盘，
+     但路径其余部分大小写敏感 —— Linux 上 Foo 与 foo 是两个目录）。 */
+  function spaceKey(p) {
+    var s = reqNormDir(p);
+    return s.replace(/^([a-z]):/, function (m, d) { return d.toUpperCase() + ':'; });
+  }
+  /* 最后一级目录名（**不显示路径**）：同时按 '/' 与 '\\' 切，Windows 路径也要切得动。 */
+  function baseName(p) {
+    var s = reqNormDir(p).split('/').filter(Boolean);
+    return s.pop() || String(p || '');
+  }
   /* 宿主能力的短名（函数体里沿用原 index 的写法，搬迁时不用到处加 H.） */
   function hEl(tag, cls, text) { return H.hEl(tag, cls, text); }
   function elSpan(cls, text) { return H.elSpan(cls, text); }
   function svgUse(id, size) { return H.svgUse(id, size); }
   function toast(msg) { return H.toast(msg); }
 
-  function reqFeatureRow(f) {
+  /* 空间显示名：**自定义空间的别名优先**，没有别名就用服务端给的目录名。
+     口径与任务页一致（index.html 的 spaceLabel）—— 同一个空间在两页不能一个叫别名
+     一个叫目录名，用户会以为认错了空间（2026-10-24：自定义空间支持别名）。
+     ⚠️ 兜底**不能落到整条路径**（w.dir）：任务页永远只显示最后一级文件夹名，
+        需求页落成整条路径 = 用户看到的是 D:\workspace\magic-agent 这种长串，
+        一行放不下也认不出是哪个项目（用户 2026-10-24：「否则显示最后1级的文件夹不要路径」）。 */
+  function reqSpaceLabel(w) {
+    var alias = '';
+    try { alias = H.getSpaceAlias ? String(H.getSpaceAlias(w.dir || w.id || '') || '') : ''; } catch (e) {}
+    return alias || w.name || baseName(w.dir || '') || w.id;
+  }
+
+  /* 相机徽标的判定（**纯函数**：DOM 之外的逻辑单独拎出来，好测）。
+   *
+   * 触发条件 = 归纳时从对话里提取到了页面地址（page_url）：
+   *   · 有地址、还没截过 → 「待截图」（点它去截）；
+   *   · 有地址、截过了     → 「N 图」（点它可以再截一张）。
+   * 没有 page_url 的功能点**不出这个徽标** —— 不给「点了必然失败」的死入口。
+   *
+   * 返回 null = 不画徽标；否则 {text, cls}。 */
+  function reqShotBadge(f) {
+    if (!f || !f.page_url) return null;
+    var n = Number(f.shots) || 0;
+    return {
+      text: n > 0 ? (n + ' 图') : '待截图',
+      cls: n > 0 ? 'reqshot__badge--has' : 'reqshot__badge--todo'
+    };
+  }
+
+  /* ══════════ 整理失败的原因：先给一句人话，原文折叠进「详情」══════════
+   * 服务端 last_error 存的是引擎原始报错：`HTTP 402: {"type":"error",...}`，
+   * 还常被截断（core 侧 240 字）。原样铺在页面上就是一屏乱码，用户看不出「该干嘛」；
+   * 这里只做两件事（2026-10-25 用户：「整理报错设计一下显示」）：
+   *   ① 认得出类别（额度 / 登录 / 限流 / 超时）→ 类别 + 一句原因 + 下一步；
+   *   ② 认不出 → 剥掉 JSON 噪声，只留人能读的部分（**不编造原因**）。
+   * 原文始终留着给「详情」：排查要看的 request_id / http_code 都在里面。
+   * 纯函数，不碰 DOM —— 好单独验。 */
+  function reqErrJsonMessage(s) {
+    var m = /"message"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(s);
+    if (!m) return '';
+    try { return String(JSON.parse('"' + m[1] + '"')); } catch (e) { return m[1]; }
+  }
+  /* 兜底文案：去掉 `HTTP 402:` 前缀、尾部 `(attempts=1, non-retryable)` 与 JSON 主体。
+     没有 message 的 JSON 本身就是一坨代码，留着只会挤爆卡片（原文在「详情」里）。 */
+  function reqErrPlain(s) {
+    var t = String(s || '')
+      .replace(/^HTTP\s+\d{3}\s*[:：]\s*/i, '')
+      .replace(/\s*\(attempts=\d+[^)]*\)\s*$/i, '')
+      .trim();
+    var i = t.indexOf('{');
+    if (i >= 0) t = t.slice(0, i).trim();
+    return t;
+  }
+  /* 按字符（不是 UTF-16 单元）截断，避免把 emoji / 生僻字截成半个。 */
+  function reqCut(s, n) {
+    var arr = Array.from(String(s == null ? '' : s));
+    return arr.length > n ? arr.slice(0, n).join('') + '…' : arr.join('');
+  }
+  /* 返回 {badge, msg, hint, raw}：badge 为空 = 认不出类别（不硬套标签）。 */
+  function reqErrInfo(raw) {
+    var text = String(raw || '').replace(/\s+/g, ' ').trim();
+    var info = { badge: '', msg: '', hint: '', raw: text };
+    if (!text) return info;
+    var status = Number((/HTTP\s+(\d{3})/i.exec(text) || [])[1]) || 0;
+    var type = ((/"type"\s*:\s*"([a-z_]+)"/i.exec(text) || [])[1] || '').toLowerCase();
+    var msg = reqErrJsonMessage(text);
+    if (status === 402 || type.indexOf('insufficient') >= 0 || type.indexOf('balance') >= 0) {
+      info.badge = '额度不足';
+      info.msg = msg || '引擎账号的额度已用尽，这一轮没有开始跑。';
+      info.hint = '报错来自引擎账号；补充额度后再点「整理」。';
+    } else if (status === 401 || status === 403 || type.indexOf('auth') >= 0 || type.indexOf('permission') >= 0) {
+      info.badge = '未授权';
+      info.msg = msg || '引擎拒绝了这个请求（登录状态或权限不对）。';
+      info.hint = '到「我的 → 引擎」重新登录 / 检查权限后再试。';
+    } else if (status === 429 || type.indexOf('rate_limit') >= 0 || /too many requests/i.test(text)) {
+      info.badge = '请求过频';
+      info.msg = msg || '引擎限流了，这一轮没有跑。';
+      info.hint = '隔一会儿再点「整理」。';
+    } else if (/timeout|timed out|deadline exceeded|超时/i.test(text)) {
+      info.badge = '超时';
+      info.msg = msg || '整理在限定时间内没跑完。';
+      info.hint = '可以进模块页单独整理，一次只跑一个模块。';
+    } else {
+      info.msg = msg || reqErrPlain(text);
+    }
+    if (!info.msg) info.msg = '服务端没有给出原因（原文见下）。';
+    return info;
+  }
+
+  /* 失败提示卡：类别 + 一句人话 + 下一步；原文默认收起（点「详情」看全文）。
+     不再用 history__hint —— 那是居中灰字，长错误铺开就是一大坨，也说不清轻重。 */
+  function reqErrorCard(raw) {
+    var info = reqErrInfo(raw);
+    var box = hEl('div', 'reqerr');
+    var head = hEl('div', 'reqerr__head');
+    var ico = elSpan('reqerr__ico');
+    ico.appendChild(svgUse('#i-bang', 14));
+    head.appendChild(ico);
+    head.appendChild(elSpan('reqerr__t', '上次整理失败'));
+    if (info.badge) head.appendChild(elSpan('reqerr__badge', info.badge));
+    box.appendChild(head);
+    box.appendChild(hEl('div', 'reqerr__msg', reqCut(info.msg, 160)));
+    if (info.hint) box.appendChild(hEl('div', 'reqerr__hint', info.hint));
+    if (info.raw) {
+      var more = document.createElement('button');
+      more.type = 'button'; more.className = 'reqerr__more';
+      more.appendChild(elSpan('', '详情'));
+      var chev = elSpan('reqerr__chev');
+      chev.appendChild(svgUse('#i-chev-d', 12));
+      more.appendChild(chev);
+      var pre = hEl('pre', 'reqerr__raw', info.raw);
+      pre.hidden = true;
+      more.onclick = function () {
+        var open = pre.hidden;
+        pre.hidden = !open;
+        more.classList.toggle('is-open', open);
+        more.firstChild.textContent = open ? '收起' : '详情';
+      };
+      box.appendChild(more);
+      box.appendChild(pre);
+    }
+    return box;
+  }
+
+  function reqFeatureRow(f, ctx) {
     /* 一行 = 一个功能点，**照会话行的排布**做（图标 + 标题 / 副标题 / 右侧时间）：
        标题（功能点名称）→ 归纳结论 / 需求描述 → 「N 需求点 · M 结论 · 来源 K」。
        为什么优先结论：这一页要回答的是「这个功能定了什么」，不是「记录了多少条」。 */
@@ -76,6 +230,33 @@
     if (!f.has_final) meta.push('未定稿');
     if (meta.length) col.appendChild(hEl('span', 'srow__s', meta.join(' · ')));
     b.appendChild(col);
+    /* 相机徽标：功能点**涉及页面改造**时出现（2026-10-25 用户：「需求文档整理时
+       如果设计页面改造 调用内置浏览器mcp 对完成情况截图标注并放在文档中」）。
+       判定见 reqShotBadge（纯函数，好测）；core 不支持截图能力位时不画。 */
+    var shot = reqShotBadge(f);
+    if (shot && (!H.canShot || H.canShot())) {
+      var badge = hEl('span', 'reqshot__badge ' + shot.cls);
+      badge.appendChild(svgUse('#i-shot', 13));
+      badge.appendChild(elSpan('', shot.text));
+      badge.title = f.page_url;
+      /* 徽标在行**里面**：HTML 不允许 button 套 button，所以渲染成 span[role=button]，
+         点它时 stopPropagation —— 否则会顺手把整行也点了（整行 = 打开文档）。 */
+      badge.setAttribute('role', 'button');
+      badge.setAttribute('aria-label', '页面完成情况截图');
+      badge.onclick = function (ev) {
+        if (ev && ev.stopPropagation) ev.stopPropagation();
+        if (ev && ev.preventDefault) ev.preventDefault();
+        if (!H.openShot) { toast('当前版本不支持截图'); return; }
+        H.openShot({
+          ws: ctx && ctx.ws ? ctx.ws : '',
+          module: ctx && ctx.module ? ctx.module : (f.module || ''),
+          name: f.name || '',
+          caption: '',
+          url: f.page_url || ''
+        });
+      };
+      b.appendChild(badge);
+    }
     if (f.updated_at) {
       var d = new Date(Number(f.updated_at) || 0);
       if (!isNaN(d.getTime())) {
@@ -91,10 +272,15 @@
      一级只回答「这个空间有哪几块、每块多少条」—— 需求一多时画功能点会把目录撑成长列表，
      结构反而看不见了（2026-10-22 用户定稿：两级，一级只显示空间和模块）。
      idx = 排序后的位次（0 = 需求条数最多的那个）。 */
+  /* 空间 key：一级行、二级详情、整理锁**必须**用同一把（大小写 / 路径分隔符归一），
+     否则「锁的是 A、按钮标记的是 B」，置忙永远对不上。 */
+  function reqWsKey(w) {
+    return spaceKey((w && (w.id || w.dir || w.name)) || '');
+  }
   function reqWorkspaceBlock(w, idx) {
     var wrap = hEl('div', '');
     var head = hEl('div', 'wsrow__head');
-    var key = w.id || w.dir || w.name || '';
+    var key = reqWsKey(w);
     var count = Number(w.feature_count) || 0;
     /* 默认只展开**第一个**（需求条数最多的那个），其余折叠（用户 2026-10-22）：
        空间一多，全展开就是一屏拉到底的长列表，什么结构都看不出来。
@@ -102,7 +288,7 @@
     var open = (REQ_OPEN[key] !== undefined) ? !!REQ_OPEN[key] : (idx === 0);
     var tog = document.createElement('button');
     tog.type = 'button'; tog.className = 'wsrow__open wsrow__open--req';
-    tog.appendChild(elSpan('wsrow__l', w.name || w.dir || w.id));
+    tog.appendChild(elSpan('wsrow__l', reqSpaceLabel(w)));
     /* 模块数 + 功能点数：一行说清这个空间有多大，比只写空间名有用。
        用**中性色**（不是 wsrow__badge 那枚 queued 紫）—— 那是「等待中」的语义色，
        空间规模不是状态，套上会让人误以为这个空间在排队。 */
@@ -130,11 +316,7 @@
     wrap.appendChild(head);
     if (!open) return wrap;
 
-    if (w.last_error) {
-      var err = hEl('div', 'history__hint', '上次整理失败：' + w.last_error);
-      err.style.color = 'var(--warning)';
-      wrap.appendChild(err);
-    }
+    if (w.last_error) wrap.appendChild(reqErrorCard(w.last_error));
     var shown = 0;
     (w.modules || []).forEach(function (m) {
       var fs = (m.features || []);
@@ -181,7 +363,10 @@
       mh.style.paddingLeft = '16px';
       mh.appendChild(elSpan('sechead__t', m.name + ' (' + fs.length + ')'));
       sec.appendChild(mh);
-      fs.forEach(function (f) { sec.appendChild(reqFeatureRow(f)); });
+      fs.forEach(function (f) {
+        /* ctx 带上空间与模块：截图要按「哪个空间的哪个模块的哪个功能点」落到文档里。 */
+        sec.appendChild(reqFeatureRow(f, { ws: w.dir || w.id || '', module: m.name || '' }));
+      });
       frag.appendChild(sec);
     });
     if (!frag.childNodes.length) {
@@ -192,14 +377,21 @@
 
   /* 进二级：记下是哪个空间的哪个模块，只画这个模块的需求。 */
   function openReqDetail(w, mod) {
-    var key = w.id || w.dir || w.name || '';
+    var key = reqWsKey(w);
     REQ_DETAIL = { key: key, mod: mod, ws: w };
+    REQ_GRAPH_WS = null;
+    /* 图谱视图与二级视图共用 #reqDetail 容器：从图谱点功能点进来时，
+       容器里还是 GRAPH_HTML —— 先还原成二级页骨架再渲染。 */
+    if (!els.detail.querySelector('#reqDetailList')) {
+      els.detail.innerHTML = DETAIL_HTML;
+      mountDetail();
+    }
     renderRequirements();
     /* 空间在两次渲染之间被删掉了（会话全删 → 空间联动消失）：
        renderRequirements 会把 REQ_DETAIL 清空，这时别停在空白的二级页，退回目录。 */
     if (!REQ_DETAIL) { H.showRoot(); return; }
     H.showDetail();
-    if (els.detailTitle) els.detailTitle.textContent = (w.name || w.dir || w.id) + ' · ' + mod;
+    if (els.detailTitle) els.detailTitle.textContent = reqSpaceLabel(w) + ' · ' + mod;
     /* 页里只有这一个模块，进来从顶部看起（旧的「滚到当前模块」已无意义）。 */
     if (els.detailList) els.detailList.scrollTop = 0;
   }
@@ -222,7 +414,7 @@
        拿不到会话/目录清单时（REQ_ALIVE=null）不筛。 */
     var all = (data && data.workspaces) || [];
     var list = all.filter(function (w) {
-      var dir = reqNormDir(w && w.dir);
+      var dir = spaceKey(w && w.dir);
       /* 根目录 / 归一后是空串 —— 「!dir 就放行」的老写法会把它漏进来，
          需求页于是出现一个叫「/」的假空间（用户 2026-10-22：「没有空间的不需要」）。
          这里先卡一道：不是真空间目录的直接不画。 */
@@ -249,9 +441,9 @@
       if (!hit) { REQ_DETAIL = null; }
       else {
         REQ_DETAIL.ws = hit;
-        if (els.detailTitle) els.detailTitle.textContent = (hit.name || hit.dir || hit.id) + ' · ' + REQ_DETAIL.mod;
+        if (els.detailTitle) els.detailTitle.textContent = reqSpaceLabel(hit) + ' · ' + REQ_DETAIL.mod;
         if (els.detailList) els.detailList.replaceChildren(reqDetailBlock(REQ_DETAIL));
-        if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
+        reqPaintBusy();
         return;
       }
     }
@@ -270,7 +462,7 @@
     list.forEach(function (w, i) { frag.appendChild(reqWorkspaceBlock(w, i)); });
     els.list.replaceChildren(frag);
     /* 整理进行中切走再回来：新 DOM 的按钮默认是可点的，这里按当前状态重新置忙。 */
-    if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
+    reqPaintBusy();
   }
 
   function loadRequirements(quiet) {
@@ -305,13 +497,13 @@
               需求页照收就会多出一堆 a1/t1/tmp 假空间。
              ⚠️ 根目录 / 与 /tmp 这类系统目录不是空间，哪怕历史上有会话在那儿跑过。 */
           var alive = {};
-          (H.getRootDirs() || []).forEach(function (d) { if (d && d.path) alive[reqNormDir(d.path)] = 1; });
+          (H.getRootDirs() || []).forEach(function (d) { if (d && d.path) alive[spaceKey(d.path)] = 1; });
           (dirs || []).forEach(function (d) {
-            if (d && d.path && String(d.name || '').indexOf('magic-') === 0) alive[reqNormDir(d.path)] = 1;
+            if (d && d.path && String(d.name || '').indexOf('magic-') === 0) alive[spaceKey(d.path)] = 1;
           });
-          (H.getCustomSpaces() || []).forEach(function (p) { if (p) alive[reqNormDir(p)] = 1; });
+          (H.getCustomSpaces() || []).forEach(function (p) { if (p) alive[spaceKey(p)] = 1; });
           H.topLevelSessions(sess).forEach(function (s) {
-            if (s && s.workspace && H.isRealSpaceDir(s.workspace)) alive[reqNormDir(s.workspace)] = 1;
+            if (s && s.workspace && H.isRealSpaceDir(s.workspace)) alive[spaceKey(s.workspace)] = 1;
           });
           REQ_ALIVE = alive;
         } else {
@@ -357,29 +549,43 @@
       });
   }
 
-  /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用（防重复点）。
-     只有**真正在整理的那个入口**显示「整理中…」：
-       · 点某个空间 / 某个模块的「整理」→ 只有这一组的文案变；
-       · 点「全部整理」→ 所有组头一起变（那才是全部在跑）。
-     其余按钮只置灰、保持「整理」—— 否则点一个模块会让人以为所有空间都在整理。 */
-  function reqSetBusy(on, label, busyKey) {
-    if (busyKey === undefined) busyKey = REQ_BUSY_KEY;
-    if (on) { if (label !== undefined) REQ_BUSY_LABEL = label; }
-    else REQ_BUSY_LABEL = '全部整理';
+  /* 置忙 / 解除 / 按状态重画。
+     纪律（2026-10-24 用户：一个在整理，别的整理不该也不能被锁）：
+       · 单个空间整理 → 只禁用**这个空间**的组头按钮与它二级页的「整理」；
+         其他空间的「整理」照常可点（各空间 state 互相独立）；
+       · 「全部整理」→ 所有按钮一起禁用（那确实是全部在跑）。
+     顶栏「全部整理」与任何单个整理互斥：避免「边跑单个边点全部」把同一空间跑两遍。 */
+  function reqBusyFor(key) { return REQ_BATCH || !!REQ_BUSY[key]; }
+  function reqBusyAny() { return REQ_BATCH || Object.keys(REQ_BUSY).length > 0; }
+  function reqBeginBusy(key, label) {
+    if (key) REQ_BUSY[key] = label || '整理中…';
+    else REQ_BATCH = true;
+    if (label !== undefined) REQ_BUSY_LABEL = label;
+    reqPaintBusy();
+  }
+  function reqEndBusy(key) {
+    if (key) delete REQ_BUSY[key];
+    else { REQ_BATCH = false; REQ_BUSY_LABEL = '全部整理'; }
+    reqPaintBusy();
+  }
+  function reqPaintBusy() {
     var btn = els.sync;
     if (btn) {
-      btn.disabled = !!on;
-      if (label !== undefined) btn.textContent = label;
+      btn.disabled = reqBusyAny();
+      btn.textContent = REQ_BATCH ? (REQ_BUSY_LABEL || '整理中…') : '全部整理';
     }
     var dbtn = els.detailSync;
     if (dbtn) {
-      dbtn.disabled = !!on;
-      dbtn.textContent = on ? '整理中…' : '整理';
+      var dkey = REQ_DETAIL ? (REQ_DETAIL.key || reqWsKey(REQ_DETAIL.ws)) : '';
+      var busy = reqBusyFor(dkey);
+      dbtn.disabled = busy;
+      dbtn.textContent = busy ? '整理中…' : '整理';
     }
     Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
-      b.disabled = !!on;
-      if (!on) { b.textContent = '整理'; return; }
-      b.textContent = (!busyKey || b.getAttribute('data-ws') === busyKey) ? '整理中…' : '整理';
+      var k = spaceKey(b.getAttribute('data-ws') || '');
+      var label = REQ_BUSY[k];
+      b.disabled = REQ_BATCH || !!label;
+      b.textContent = label || (REQ_BATCH ? '整理中…' : '整理');
     });
   }
 
@@ -390,15 +596,16 @@
      服务端按 state 判断走哪条路：没初始化过 → 先按空间目录反推基线；
      模块级不会触发首次初始化（目录基线天然是空间级的）。 */
   function consolidateRequirements(target, module) {
-    if (REQ_BUSY || !target) return;
+    if (!target) return;
     var ws = target.dir || target.id || '';
     if (!ws) return;
     module = String(module || '').trim();
+    /* 锁粒度 = 空间：同一空间里空间级 / 模块级整理共享 state，不能并发；
+       不同空间互不影响（点了 A 还能点 B）。 */
+    var targetKey = reqWsKey(target);
+    if (!targetKey || reqBusyFor(targetKey)) return;
     var firstTime = target.initialized === false && !module;
-    var targetKey = target.id || target.dir || '';
-    REQ_BUSY = true;
-    REQ_BUSY_KEY = targetKey;
-    reqSetBusy(true, firstTime ? '初始化中…' : '整理中…', targetKey);
+    reqBeginBusy(targetKey, firstTime ? '初始化中…' : '整理中…');
     reqPostConsolidate(ws, module)
       .then(function (d) {
         var prefix = module ? '模块「' + module + '」' : '';
@@ -406,16 +613,27 @@
           if (d.created || d.updated) toast('已按空间目录生成需求：新建 ' + (d.created || 0) + ' · 更新 ' + (d.updated || 0));
           else toast('已按空间目录初始化：暂未识别到功能点');
         }
+        /* 模块去重（core 收尾时合并「表达同一件事」的已有模块）：
+           有合并就不是 noop —— 用户点「整理」想看到的就是这个反馈。 */
+        else if (d.merged) {
+          var extra = (d.updated || d.created)
+            ? ' · 更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0) : '';
+          toast((prefix || '整理完成') + '：合并 ' + d.merged + ' 个相似模块' + extra);
+        }
         else if (d.noop) toast(prefix ? prefix + '没有新的对话需要整理' : '没有新的对话需要整理');
         else if (d.updated || d.created) toast((prefix || '整理完成') + '：更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0));
         else toast(prefix ? prefix + '整理完成' : '整理完成');
         loadRequirements(true);   // 后台刷新（不闪「读取中」）
       })
-      .catch(function (e) { toast('整理失败：' + ((e && e.message) || e)); })
+      .catch(function (e) {
+        /* 失败原因走与卡片同一套归类：toast 只放一句人话（原始 JSON 会撑爆 toast），
+           再刷新一次清单 —— 服务端已把原因写进 state，卡片随即出现，可点「详情」看原文。 */
+        var info = reqErrInfo((e && e.message) || String(e || ''));
+        toast('整理失败：' + (info.badge || reqCut(info.msg, 40)));
+        loadRequirements(true);
+      })
       .then(function () {
-        REQ_BUSY = false;
-        REQ_BUSY_KEY = '';
-        reqSetBusy(false, '全部整理');
+        reqEndBusy(targetKey);
       });
   }
 
@@ -425,10 +643,10 @@
   function reqAllWorkspaces() {
     var seen = {};
     var list = ((REQ_DATA && REQ_DATA.workspaces) || []).filter(function (w) {
-      var key = w.dir || w.id || '';
+      var key = reqWsKey(w);
       if (!key || seen[key]) return false;
       /* 会话已全部删除的空间不参与「全部整理」：否则又会把它重新生成出来。 */
-      var dir = reqNormDir(w.dir);
+      var dir = spaceKey(w.dir);
       if (REQ_ALIVE && dir && !REQ_ALIVE[dir]) return false;
       seen[key] = true;
       return true;
@@ -442,20 +660,16 @@
   }
 
   function consolidateAllRequirements() {
-    if (REQ_BUSY) return;
+    if (reqBusyAny()) return;
     var list = reqAllWorkspaces();
     if (!list.length) {
       toast('还没有可整理的空间');
       return;
     }
-    REQ_BUSY = true;
-    REQ_BUSY_KEY = '';        // 空 = 全部整理：所有组头一起显示「整理中…」
-    reqSetBusy(true, '整理中 0/' + list.length);
+    reqBeginBusy('', '整理中 0/' + list.length);
     var i = 0, ok = 0, fail = 0, created = 0, updated = 0, firstErr = '';
     function done() {
-      REQ_BUSY = false;
-      REQ_BUSY_KEY = '';
-      reqSetBusy(false, '全部整理');
+      reqEndBusy('');
       loadRequirements(true);
       if (fail) {
         toast('全部整理完成：成功 ' + ok + ' · 失败 ' + fail + (firstErr ? '（' + firstErr + '）' : ''));
@@ -467,8 +681,7 @@
       if (i >= list.length) { done(); return; }
       var w = list[i++];
       REQ_BUSY_LABEL = '整理中 ' + i + '/' + list.length;
-      var btn = els.sync;
-      if (btn) btn.textContent = REQ_BUSY_LABEL;
+      reqPaintBusy();
       reqPostConsolidate(w.dir || w.id || '', '')
         .then(function (d) {
           ok++;
@@ -477,13 +690,216 @@
         })
         .catch(function (e) {
           fail++;
-          if (!firstErr) firstErr = (e && e.message) || String(e);
+          if (!firstErr) {
+            var info = reqErrInfo((e && e.message) || String(e || ''));
+            firstErr = info.badge || reqCut(info.msg, 24);
+          }
         })
         .then(step);
     }
     step();
   }
 
+  /* ══════════ 会话↔需求关系图谱（2026-10-25）══════════
+   * 数据：GET /desk/requirements/graph?ws=<id|目录>（core --requirements-graph，纯读不调模型）。
+   * 渲染：vendor 的 d3-force（力导向）+ 手绘 SVG —— 会话=圆、功能点=圆角矩形，
+   * 按模块着色；点功能点节点跳该模块的需求列表（复用二级页），点会话节点弹标题。
+   * 复用 #reqDetail 容器（第三态 REQ_GRAPH_WS）：它本来就是「需求页的下钻视图」，
+   * 宿主 hideAll/showDetail 的显隐逻辑不用动。 */
+  function mountDetail() {
+    els.detailList = els.detail.querySelector('#reqDetailList');
+    els.detailTitle = els.detail.querySelector('#reqDetailTitle');
+    els.detailBack = els.detail.querySelector('#btnReqDetailBack');
+    els.detailSync = els.detail.querySelector('#btnReqDetailSync');
+    if (els.detailBack) els.detailBack.onclick = function () { closeReqDetail(); };
+    if (els.detailSync) els.detailSync.onclick = function () {
+      if (!REQ_DETAIL || !REQ_DETAIL.ws) return;
+      consolidateRequirements(REQ_DETAIL.ws, REQ_DETAIL.mod);
+    };
+  }
+
+  function openReqGraph() {
+    var all = (REQ_DATA && REQ_DATA.workspaces) || [];
+    /* 图谱入口给「需求最多的那个空间」当默认（与列表排序口径一致），可顶部切换。 */
+    var w = all[0] || null;
+    REQ_GRAPH_WS = w;
+    REQ_DETAIL = null;
+    els.detail.innerHTML = GRAPH_HTML;
+    H.showDetail();
+    var back = els.detail.querySelector('#btnReqGraphBack');
+    if (back) back.onclick = function () {
+      REQ_GRAPH_WS = null;
+      els.detail.innerHTML = DETAIL_HTML;
+      mountDetail();
+      H.showRoot();
+      renderRequirements();
+    };
+    renderGraphPick();
+    if (w) loadGraph(w); else {
+      var st = els.detail.querySelector('#reqGraphStage');
+      if (st) st.innerHTML = '<div class="history__hint">还没有任何空间。在任务里聊几句，这里会出现关系图谱。</div>';
+    }
+  }
+
+  function graphWsList() {
+    var all = (REQ_DATA && REQ_DATA.workspaces) || [];
+    return all.filter(function (w) {
+      var dir = spaceKey(w && w.dir);
+      if (!H.isRealSpaceDir(dir)) return false;
+      return !REQ_ALIVE || !dir || !!REQ_ALIVE[dir];
+    });
+  }
+
+  function renderGraphPick() {
+    var pick = els.detail.querySelector('#reqGraphPick');
+    if (!pick) return;
+    var list = graphWsList();
+    pick.replaceChildren.apply(pick, list.map(function (w) {
+      var b = hEl('button', 'reqgraph__chip' + (REQ_GRAPH_WS && REQ_GRAPH_WS.id === w.id ? ' is-on' : ''));
+      b.type = 'button';
+      b.textContent = reqSpaceLabel(w);
+      b.onclick = function () {
+        REQ_GRAPH_WS = w;
+        renderGraphPick();
+        loadGraph(w);
+      };
+      return b;
+    }));
+  }
+
+  function loadGraph(w) {
+    var st = els.detail.querySelector('#reqGraphStage');
+    if (!st) return;
+    st.innerHTML = '<div class="history__hint">读取中…</div>';
+    var hdr = H.getToken() ? { 'X-Magic-Token': H.getToken() } : {};
+    var where = encodeURIComponent(w.id || w.dir || '');
+    fetch(H.getBase() + '/desk/requirements/graph?ws=' + where, { headers: hdr })
+      .then(function (r) {
+        if (r.status === 501) return r.json().then(function (e) { throw new Error((e && e.error) || '当前 core 不支持需求聚合'); });
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        return r.json();
+      })
+      .then(function (d) {
+        if (REQ_GRAPH_WS !== w) return; // 用户已切走：旧响应作废
+        var g = d && d.workspaces && d.workspaces[0];
+        if (!g || !g.nodes || !g.nodes.length) {
+          st.innerHTML = '<div class="history__hint">这个空间还没有会话↔需求的关系。先点「整理」归纳一轮。</div>';
+          return;
+        }
+        renderGraphStage(g);
+      })
+      .catch(function (e) {
+        if (REQ_GRAPH_WS !== w) return;
+        st.innerHTML = '<div class="history__hint">读取失败：' + String((e && e.message) || e) + '</div>';
+      });
+  }
+
+  /* 模块 → 颜色（确定性 hash → HSL，明暗主题都看得清：饱和度/亮度取中间值）。 */
+  function graphModuleColor(mod) {
+    var h = 0, s = String(mod || '');
+    for (var i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) % 360;
+    return 'hsl(' + h + ',55%,58%)';
+  }
+
+  function renderGraphStage(g) {
+    var st = els.detail.querySelector('#reqGraphStage');
+    if (!st) return;
+    var cyLib = window.cytoscape;
+    if (!cyLib) {
+      st.innerHTML = '<div class="history__hint">图谱组件（cytoscape）没加载出来，刷新页面试试。</div>';
+      return;
+    }
+    /* fCoSE 布局扩展是可选的：没注册就回落内置 cose（同为力导向，效果稍逊）。 */
+    if (window.cytoscapeFcose && window.cytoscape.use) {
+      try { window.cytoscape.use(window.cytoscapeFcose); } catch (e) {}
+    }
+    st.replaceChildren();
+
+    var elsData = g.nodes.map(function (n) {
+      return {
+        group: 'nodes',
+        data: { id: n.id, label: n.title || n.id, kind: n.type, module: n.module || '' }
+      };
+    });
+    (g.edges || []).forEach(function (e) {
+      elsData.push({ group: 'edges', data: { id: e.source + '\u2192' + e.target, source: e.source, target: e.target } });
+    });
+
+    var cy = cyLib({
+      container: st,
+      elements: elsData,
+      style: [
+        { selector: 'node', style: {
+          label: 'data(label)', color: 'var(--ink)', 'font-size': 11,
+          'text-valign': 'bottom', 'text-margin-y': 4,
+          'background-color': '#888', 'border-width': 2, 'border-color': 'var(--raised)'
+        } },
+        { selector: 'node[kind = "session"]', style: {
+          shape: 'ellipse', width: 12, height: 12,
+          'background-color': 'var(--muted)'
+        } },
+        { selector: 'node[kind = "feature"]', style: {
+          shape: 'round-rectangle', width: 'label', height: 28,
+          padding: '8px', 'background-color': 'data(color)',
+          'font-size': 11
+        } },
+        { selector: 'edge', style: {
+          width: 1.5, 'line-color': 'var(--border)', 'curve-style': 'straight',
+          'target-arrow-shape': 'none', opacity: 0.9
+        } },
+        { selector: 'node:active', style: { 'overlay-opacity': 0.1 } }
+      ],
+      layout: { name: 'preset', fit: false },
+      wheelSensitivity: 0.2,   /* 触屏/滚轮缩放手感 */
+      boxSelectionEnabled: false,
+      autoungrabify: false
+    });
+
+    /* 节点配色：feature 按模块 hash 着色（data(color) 上文已引用）。 */
+    cy.nodes('[kind = "feature"]').forEach(function (n) {
+      n.data('color', graphModuleColor(n.data('module')));
+    });
+
+    /* 布局：fCoSE（专业力导向，注册失败回落内置 cose）；定稿后 fit 到视口。 */
+    var layName = window.cytoscapeFcose ? 'fcose' : 'cose';
+    cy.layout({
+      name: layName, animate: false, randomize: true,
+      idealEdgeLength: 90, nodeRepulsion: 9000, nodeSeparation: 110,
+      padding: 30
+    }).run();
+    cy.fit(undefined, 30);
+    cy.userZoomingEnabled(true);
+    cy.userPanningEnabled(true);
+
+    /* 交互：点功能点 → 该模块需求列表（复用二级页）；点会话 → 弹标题。 */
+    cy.on('tap', 'node[kind = "feature"]', function (evt) {
+      if (REQ_GRAPH_WS) openReqDetail(REQ_GRAPH_WS, evt.target.data('module') || '未分组');
+    });
+    cy.on('tap', 'node[kind = "session"]', function (evt) {
+      toast(evt.target.data('label'));
+    });
+
+    /* 图例：模块配色一览（前 6 个模块 + 会话）。 */
+    var lg = els.detail.querySelector('#reqGraphLegend');
+    if (lg) {
+      var mods = [];
+      g.nodes.forEach(function (n) { if (n.type === 'feature' && mods.indexOf(n.module) < 0) mods.push(n.module); });
+      var frag = document.createDocumentFragment();
+      frag.appendChild(hEl('span', 'reqgraph__lg reqgraph__lg--sess', '● 会话'));
+      mods.slice(0, 6).forEach(function (m) {
+        var it = hEl('span', 'reqgraph__lg');
+        it.style.color = graphModuleColor(m);
+        it.textContent = '● ' + (m || '未分组');
+        frag.appendChild(it);
+      });
+      lg.replaceChildren(frag);
+    }
+    /* 离开页面时销毁实例（WebView 里 canvas 实例常驻会占内存）。 */
+    els.graphCy = cy;
+    if (els.graphCyOld) { try { els.graphCyOld.destroy(); } catch (e) {} }
+    els.graphCyOld = cy;
+  }
+
   /* 挂载：index.html 在 DOM 就绪后调用一次。
      host 里的 getter 必须保持为函数 —— 切环境后 BASE/TOKEN/空间清单会变。 */
   function mount(host) {
@@ -495,24 +911,23 @@
     els.root = root;
     els.detail = detail;
     els.list = root.querySelector('#reqList');
-    els.detailList = detail.querySelector('#reqDetailList');
-    els.detailTitle = detail.querySelector('#reqDetailTitle');
     els.sync = root.querySelector('#btnReqSync');
-    els.detailBack = detail.querySelector('#btnReqDetailBack');
-    els.detailSync = detail.querySelector('#btnReqDetailSync');
+    els.graphBtn = root.querySelector('#btnReqGraph');
+    mountDetail();
     /* 两个动作：全部整理 / 返回一级；二级页的「整理」只作用于**当前模块**
        （不是整空间、更不是全部空间 —— 用户点哪个模块，就只整理哪个模块）。 */
     if (els.sync) els.sync.onclick = function () { consolidateAllRequirements(); };
-    if (els.detailBack) els.detailBack.onclick = function () { closeReqDetail(); };
-    if (els.detailSync) els.detailSync.onclick = function () {
-      if (!REQ_DETAIL || !REQ_DETAIL.ws) return;
-      consolidateRequirements(REQ_DETAIL.ws, REQ_DETAIL.mod);
-    };
+    if (els.graphBtn) els.graphBtn.onclick = function () { openReqGraph(); };
   }
 
   /* 进入「需求」tab：每次进来都回到一级目录并拉一次清单（只读，不触发归纳）。 */
   function show() {
     REQ_DETAIL = null;
+    REQ_GRAPH_WS = null;
+    if (els.detail && !els.detail.querySelector('#reqDetailList')) {
+      els.detail.innerHTML = DETAIL_HTML;
+      mountDetail();
+    }
     loadRequirements(false);
   }