magic-agent 2.1.5 → 2.3.0

package/client-ui-mobile/reqs.css

@@ -0,0 +1,39 @@
+/* ══════════ 需求页（「需求」tab 子页面）══════════
+   从 index.html 拆出：选择器只服务这一页（别的页面不引用）。
+   一级目录（空间 → 模块）、二级模块需求列表、组头「整理」按钮。
+   CSS 变量（--ink / --muted / --subtle / --border / --faint / --primary-action /
+   --warning / --tint-wait）仍由 index.html 的 :root 统一提供。 */
+
+/* 空间规模（几模块 · 几条）：紧跟在空间名后面，中性色 —— 不是状态，别用徽标色。
+   需求页专属：空间名改成自适应宽度，meta 才会贴在名字后面；meta 的 margin-right:auto
+   把「待整理」徽标和箭头推到行尾。 */
+.wsrow__open--req .wsrow__l{flex:0 1 auto}
+.wsrow__open--req .wsrow__meta{margin-right:auto}
+.wsrow__meta{flex:0 1 auto;min-width:0;font-size:12px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+/* 每个空间自己的「整理」：需求页会同时列出多个空间，顶部那一枚只认当前会话的空间。
+   把入口放到组头，用户点哪个空间就初始化/增量哪个空间，不再猜「当前空间」是谁。 */
+.wsrow__sync{flex:0 0 auto;height:32px;padding:0 10px;border-radius:var(--r-full);
+  font-size:12px;font-weight:500;color:var(--primary-action);background:var(--subtle);white-space:nowrap}
+.wsrow__sync:active{opacity:.7}
+.wsrow__sync:disabled{color:var(--muted);opacity:.6}
+/* 「未初始化」与「待整理」同形不同色：前者是「还没按目录生成过基线」，
+   后者是「有对话等着归纳」，两种提示不能混成一个数字。 */
+.wsrow__badge--init{color:var(--warning);background:var(--tint-wait)}
+
+/* ══════════ 需求页：两级（空间→模块 → 需求列表）══════════
+   一级是**目录**：空间是行，模块缩进挂在空间下（树形），功能点一律不画在这里 ——
+   需求一多，一级就会被功能点撑成长列表，什么结构都看不出来。
+   二级才是内容：点某个模块进去，**只看这个模块**的需求列表。 */
+.reqtree__mod{position:relative;display:flex;align-items:center;gap:8px;width:100%;
+  padding:9px 10px 9px 30px;background:none;border:0;text-align:left;color:var(--ink)}
+.reqtree__mod:active{background:var(--subtle)}
+/* 连接线：从空间名垂下来的细线 + 每个模块前的一小截横线 —— 归属关系靠线说话，不靠缩进猜 */
+.reqtree__mod::before{content:"";position:absolute;left:14px;top:0;bottom:0;width:1px;background:var(--border)}
+.reqtree__mod::after{content:"";position:absolute;left:14px;top:50%;width:10px;height:1px;background:var(--border)}
+.reqtree__modname{flex:1;min-width:0;font-size:14px;font-weight:500;color:var(--ink);
+  overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.reqtree__modcount{flex:0 0 auto;font-size:12px;color:var(--muted);font-variant-numeric:tabular-nums}
+.reqtree__modgo{flex:0 0 auto;color:var(--faint);display:flex;align-items:center}
+/* 二级视图的分组小节：只画当前模块，故这一节恒为高亮态 */
+.reqdetail__sec--cur .sechead{color:var(--primary-action)}
+.reqdetail__sec--cur .sechead__t{font-weight:800}

package/client-ui-mobile/reqs.js

@@ -0,0 +1,507 @@
+/* 需求页（移动端「需求」tab）—— 独立子页面模块。
+ *
+ * 为什么单独一个文件：这一页的 DOM、样式、渲染与「整理」动作原本全混在
+ * index.html 的主 IIFE 里（约 500 行），改需求页要在 5600 行的文件里翻半天。
+ * 现在 index 只留两个空容器（#reqs / #reqDetail）+ 一次 mount，本文件自包含：
+ *   · 一级：空间目录（空间 → 模块，功能点不画）；
+ *   · 二级：点模块进去，**只看这个模块**的需求列表；
+ *   · 「整理」：POST /desk/requirements/consolidate（全量 / 单空间 / 二级页单空间）。
+ *
+ * 与宿主（index.html）的边界：只通过 mount(host) 注入的能力交互 ——
+ *   getBase / getToken（切环境后是活的，必须 getter，不能传快照）、
+ *   getRootDirs / getCustomSpaces / getRunPref、isRealSpaceDir / topLevelSessions、
+ *   hEl / elSpan / svgUse / toast / openReader / hideAll / setActive /
+ *   showTabbar / hideTabbar。
+ * 数据形状见 CLIENT-CONTRACT §3.4.1：
+ *   {ok, root, workspaces[{id,dir,name,pending,memory,
+ *    modules:[{name,features:[{module,name,file,desc,points,conclusions,conclusion,
+ *    sources,has_final,final_preview,updated_at}]}],feature_count,
+ *    last_consolidated_at,last_error}]}
+ */
+(function () {
+  'use strict';
+
+  var H = null;                // 宿主（index.html 注入）
+  var els = {};                // 需求页内部元素
+  var REQ_DATA = null;         // 最近一次清单（重画用，避免每次点都重新拉）
+  var REQ_BUSY = false;        // 「整理」进行中（防重复点击）
+  var REQ_BUSY_LABEL = '全部整理'; // 顶栏按钮的进行中文案（重渲染后要能恢复）
+  var REQ_OPEN = {};           // 工作区展开状态（key = 工作区 id），与会话列表的 WS_OPEN 同构
+  var REQ_ALIVE = null;        // 仍有会话的空间路径集合；null = 拿不到会话清单（不筛）
+  var REQ_DETAIL = null;       // 二级视图：{key: 工作区 key, mod: 模块名, ws: 工作区对象}
+
+  /* 一级 / 二级两个容器的内容都在这里渲染 —— index.html 里只留空壳。 */
+  var ROOT_HTML =
+    '<div class="history__top">' +
+      '<span class="history__title">需求</span>' +
+      '<button class="history__disconnect" id="btnReqSync" type="button">全部整理</button>' +
+    '</div>' +
+    '<div class="history__list" id="reqList"></div>';
+  var DETAIL_HTML =
+    '<div class="history__top">' +
+      '<button class="topbar__icon" id="btnReqDetailBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>' +
+      '<span class="history__title" id="reqDetailTitle">需求</span>' +
+      '<button class="history__disconnect" id="btnReqDetailSync" type="button">整理</button>' +
+    '</div>' +
+    '<div class="history__list" id="reqDetailList"></div>';
+
+  /* 路径归一：只去尾部斜杠，不做 realpath —— 与 core 登记表里的 workspace 同一口径。 */
+  function reqNormDir(p) { return String(p || '').replace(/\/+$/, ''); }
+  /* 宿主能力的短名（函数体里沿用原 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) {
+    /* 一行 = 一个功能点，**照会话行的排布**做（图标 + 标题 / 副标题 / 右侧时间）：
+       标题（功能点名称）→ 归纳结论 / 需求描述 → 「N 需求点 · M 结论 · 来源 K」。
+       为什么优先结论：这一页要回答的是「这个功能定了什么」，不是「记录了多少条」。 */
+    var b = hEl('button', 'srow srow--req');
+    b.type = 'button';
+    var ico = hEl('span', 'srow__ico srow__ico--idle');
+    ico.appendChild(svgUse('#i-doc', 20));
+    b.appendChild(ico);
+    var col = hEl('span', 'srow__col');
+    col.appendChild(hEl('span', 'srow__t', f.name || '(未命名)'));
+    /* 先结论，再一句话描述，最后才是定稿预览。定稿预览是 markdown（可能带 `**目标**：`），
+       直接塞进这一行会把星号原样显示出来；有 desc 时它更适合当副标题。 */
+    var sub = f.conclusion || f.desc || f.final_preview || '';
+    if (sub) col.appendChild(hEl('span', 'srow__s', sub));
+    var meta = [];
+    if (f.points) meta.push(f.points + ' 需求点');
+    if (f.conclusions) meta.push(f.conclusions + ' 结论');
+    if (f.sources) meta.push('来源 ' + f.sources);
+    if (!f.has_final) meta.push('未定稿');
+    if (meta.length) col.appendChild(hEl('span', 'srow__s', meta.join(' · ')));
+    b.appendChild(col);
+    if (f.updated_at) {
+      var d = new Date(Number(f.updated_at) || 0);
+      if (!isNaN(d.getTime())) {
+        b.appendChild(hEl('span', 'srow__time',
+          (d.getMonth() + 1) + '-' + ('0' + d.getDate()).slice(-2)));
+      }
+    }
+    b.onclick = function () { H.openReader(f.file); };
+    return b;
+  }
+
+  /* 一级：空间目录。空间是行，模块缩进挂在空间下（树形），**功能点一律不画在这里**。
+     一级只回答「这个空间有哪几块、每块多少条」—— 需求一多时画功能点会把目录撑成长列表，
+     结构反而看不见了（2026-10-22 用户定稿：两级，一级只显示空间和模块）。
+     idx = 排序后的位次（0 = 需求条数最多的那个）。 */
+  function reqWorkspaceBlock(w, idx) {
+    var wrap = hEl('div', '');
+    var head = hEl('div', 'wsrow__head');
+    var key = w.id || w.dir || w.name || '';
+    var count = Number(w.feature_count) || 0;
+    /* 默认只展开**第一个**（需求条数最多的那个），其余折叠（用户 2026-10-22）：
+       空间一多，全展开就是一屏拉到底的长列表，什么结构都看不出来。
+       用户手动点过谁就按用户的来（REQ_OPEN 里有记录就不动它）。 */
+    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));
+    /* 模块数 + 功能点数：一行说清这个空间有多大，比只写空间名有用。
+       用**中性色**（不是 wsrow__badge 那枚 queued 紫）—— 那是「等待中」的语义色，
+       空间规模不是状态，套上会让人误以为这个空间在排队。 */
+    var mods = (w.modules || []).filter(function (m) { return (m.features || []).length; });
+    tog.appendChild(elSpan('wsrow__meta', mods.length + ' 模块 · ' + count + ' 条'));
+    /* 待整理条数做成徽标（与「等待中」同款）：折叠起来也看得见这个空间在长新需求。 */
+    if (w.pending > 0) tog.appendChild(elSpan('wsrow__badge', w.pending + ' 待整理'));
+    /* 未初始化 = 还没按空间目录生成过基线。老 core 不带 initialized 字段（undefined），
+       此时不提示 —— 不能把「不知道」画成「未初始化」。 */
+    if (w.initialized === false) tog.appendChild(elSpan('wsrow__badge wsrow__badge--init', '未初始化'));
+    var chev = elSpan('wsrow__chev' + (open ? ' is-open' : ''));
+    chev.appendChild(svgUse('#i-chev-r', 16));
+    tog.appendChild(chev);
+    tog.onclick = function () { REQ_OPEN[key] = !open; renderRequirements(); };
+    head.appendChild(tog);
+    /* 组头右侧的「整理」：只作用于这个空间（初始化它 / 归纳它的新会话）。 */
+    var sync = document.createElement('button');
+    sync.type = 'button'; sync.className = 'wsrow__sync'; sync.textContent = '整理';
+    sync.setAttribute('data-ws', key);
+    sync.onclick = function (ev) {
+      if (ev && ev.stopPropagation) ev.stopPropagation();
+      consolidateRequirements(w);
+    };
+    head.appendChild(sync);
+    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);
+    }
+    var shown = 0;
+    (w.modules || []).forEach(function (m) {
+      var fs = (m.features || []);
+      if (!fs.length) return;
+      shown += fs.length;
+      /* 模块 = 目录里的一行（缩进 + 连接线归属到空间），点它进二级看需求列表。
+         未归类（name 为空）的老数据没有模块名可写 —— 这种情况直接不画这一行，
+         功能点仍能在二级里看到（core 把空 module 排在最后）。 */
+      if (!m.name) return;
+      var row = document.createElement('button');
+      row.type = 'button'; row.className = 'reqtree__mod';
+      row.appendChild(elSpan('reqtree__modname', m.name));
+      row.appendChild(elSpan('reqtree__modcount', String(fs.length)));
+      var go = elSpan('reqtree__modgo');
+      go.appendChild(svgUse('#i-chev-r', 16));
+      row.appendChild(go);
+      row.onclick = function () { openReqDetail(w, m.name); };
+      wrap.appendChild(row);
+    });
+    /* 空间还在但还没有文档：别画成一片空白，给出这一组的下一步（整理）。 */
+    if (!shown) {
+      var tip = Number(w.pending) > 0
+        ? '有 ' + w.pending + ' 条对话待整理'
+        : (w.initialized === false ? '还没有需求文档，点右侧「整理」按空间生成' : '还没有需求文档');
+      var hint = hEl('div', 'history__hint', tip);
+      hint.style.padding = '6px 12px 12px';
+      wrap.appendChild(hint);
+    }
+    return wrap;
+  }
+
+  /* 二级：**只看当前模块**的需求列表（2026-10-22 用户定稿：点哪个模块进来就只看哪个模块，
+     别把同空间其他模块的需求也倒进来）。模块名是这一页唯一的筛子；找不到（刚被删 / 改名）
+     时如实说这个模块没有，不退化成整空间 —— 否则用户会以为点错了。 */
+  function reqDetailBlock(d) {
+    var w = d.ws;
+    var frag = document.createDocumentFragment();
+    (w.modules || []).forEach(function (m) {
+      if (m.name !== d.mod) return;
+      var fs = (m.features || []);
+      if (!fs.length) return;
+      var sec = hEl('div', 'reqdetail__sec reqdetail__sec--cur');
+      var mh = hEl('div', 'sechead');
+      mh.style.paddingLeft = '16px';
+      mh.appendChild(elSpan('sechead__t', m.name + ' (' + fs.length + ')'));
+      sec.appendChild(mh);
+      fs.forEach(function (f) { sec.appendChild(reqFeatureRow(f)); });
+      frag.appendChild(sec);
+    });
+    if (!frag.childNodes.length) {
+      frag.appendChild(hEl('div', 'history__hint', '这个模块还没有需求文档'));
+    }
+    return frag;
+  }
+
+  /* 进二级：记下是哪个空间的哪个模块，只画这个模块的需求。 */
+  function openReqDetail(w, mod) {
+    var key = w.id || w.dir || w.name || '';
+    REQ_DETAIL = { key: key, mod: mod, ws: w };
+    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.detailList) els.detailList.scrollTop = 0;
+  }
+
+  /* 退二级回一级目录。 */
+  function closeReqDetail() {
+    REQ_DETAIL = null;
+    H.showRoot();
+    renderRequirements();
+  }
+
+  function renderRequirements() {
+    if (!els.list) return;
+    var data = REQ_DATA;
+    if (!data) return;
+    /* 空间清单与任务页对齐：**用与 collectSpaceKeys 同一套空间键过滤**
+       （用户 2026-10-22：「4个空间需求里显示的不一样」「会话中全部删除后需求中的空间还在
+       也要联动删除」）。没有文档的空间不再整块藏掉，而是留一个组头 + 「整理」按钮 ——
+       这样两页的空间数一致，也给了「这个空间还没生成需求」的入口。
+       拿不到会话/目录清单时（REQ_ALIVE=null）不筛。 */
+    var all = (data && data.workspaces) || [];
+    var list = all.filter(function (w) {
+      var dir = reqNormDir(w && w.dir);
+      /* 根目录 / 归一后是空串 —— 「!dir 就放行」的老写法会把它漏进来，
+         需求页于是出现一个叫「/」的假空间（用户 2026-10-22：「没有空间的不需要」）。
+         这里先卡一道：不是真空间目录的直接不画。 */
+      if (!H.isRealSpaceDir(dir)) return false;
+      return !REQ_ALIVE || !dir || !!REQ_ALIVE[dir];
+    });
+    /* 排序：**需求条数多的排前面**（用户 2026-10-22）。
+       core 给的顺序是「最后归纳时间倒序」，但那是给「最近在动的」用的；
+       需求页要回答的是「哪块需求最多」，条数多的才是用户要先看的那个。
+       条数一样时按名字排 —— 同一条数下顺序要稳定，不能每次刷新都在跳。 */
+    list.sort(function (a, b) {
+      var ca = Number(a && a.feature_count) || 0;
+      var cb = Number(b && b.feature_count) || 0;
+      if (ca !== cb) return cb - ca;
+      return String((a && a.name) || '').localeCompare(String((b && b.name) || ''));
+    });
+    /* 二级视图：只画这个模块的需求列表。空间可能已被会话删除联动掉
+       （list 里没有它）—— 那就退回一级目录，不要留一页空白。 */
+    if (REQ_DETAIL) {
+      var hit = null;
+      for (var i = 0; i < list.length; i++) {
+        if ((list[i].id || list[i].dir || list[i].name || '') === REQ_DETAIL.key) { hit = list[i]; break; }
+      }
+      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.detailList) els.detailList.replaceChildren(reqDetailBlock(REQ_DETAIL));
+        if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
+        return;
+      }
+    }
+    var frag = document.createDocumentFragment();
+    if (!list.length) {
+      /* 一个空间都没有（会话全删了 / 还没聊过）。 */
+      frag.appendChild(hEl('div', 'history__hint',
+        REQ_ALIVE
+          ? '还没有任何空间。在任务里聊几句，这里会按空间整理出功能点文档。'
+          : '还没有任何需求。在任务里聊几句，这里会自动整理出功能点文档。'));
+      els.list.replaceChildren(frag);
+      return;
+    }
+    /* 工作区顺序：上面已按需求条数排好（多的在前）。默认只展开第一个 ——
+       见 reqWorkspaceBlock 的 open 判定。 */
+    list.forEach(function (w, i) { frag.appendChild(reqWorkspaceBlock(w, i)); });
+    els.list.replaceChildren(frag);
+    /* 整理进行中切走再回来：新 DOM 的按钮默认是可点的，这里按当前状态重新置忙。 */
+    if (REQ_BUSY) reqSetBusy(true, REQ_BUSY_LABEL);
+  }
+
+  function loadRequirements(quiet) {
+    if (!els.list) return;
+    if (!quiet && !REQ_DATA) els.list.innerHTML = '<div class="history__hint">读取中…</div>';
+    var hdr = H.getToken() ? { 'X-Magic-Token': H.getToken() } : {};
+    var pReq = fetch(H.getBase() + '/desk/requirements', { headers: hdr })
+      .then(function (r) {
+        if (r.status === 501) {
+          /* 老 core 没有这个能力位：**说清楚**，不要给一页空白
+             （空白看起来像「没有需求」，是最难查的一种）。 */
+          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();
+      });
+    /* 会话清单与空间目录：用来判断「这个空间在任务页还在不在」。
+       两者都允许失败 —— 拿不到就不筛空间（见 renderRequirements）。 */
+    var pSess = fetch(H.getBase() + '/desk/sessions', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
+    var pDirs = fetch(H.getBase() + '/desk/dirs', { headers: hdr })
+      .then(function (r) { return r.ok ? r.json() : null; }).catch(function () { return null; });
+    Promise.all([pReq, pSess, pDirs])
+      .then(function (a) {
+        var sess = a[1], dirs = (a[2] && a[2].dirs) || null;
+        if (Array.isArray(sess) || Array.isArray(dirs)) {
+          /* 与任务页**同一套空间键**（用户 2026-10-22：「4个空间需求里显示的不一样」
+             「会话中全部删除后需求中的空间还在 也要联动删除」「没有空间的不需要」）：
+               ① 根目录下的 magic-*   ② 自定义空间   ③ **顶层会话**的工作目录。
+             ⚠️ ③ 只能取**顶层**会话的 workspace：团队子代理的会话挂在父会话下面，
+              它们的工作目录是 /…/run-xxx/a1 这种临时目录 —— 任务页不把它们列成空间，
+              需求页照收就会多出一堆 a1/t1/tmp 假空间。
+             ⚠️ 根目录 / 与 /tmp 这类系统目录不是空间，哪怕历史上有会话在那儿跑过。 */
+          var alive = {};
+          (H.getRootDirs() || []).forEach(function (d) { if (d && d.path) alive[reqNormDir(d.path)] = 1; });
+          (dirs || []).forEach(function (d) {
+            if (d && d.path && String(d.name || '').indexOf('magic-') === 0) alive[reqNormDir(d.path)] = 1;
+          });
+          (H.getCustomSpaces() || []).forEach(function (p) { if (p) alive[reqNormDir(p)] = 1; });
+          H.topLevelSessions(sess).forEach(function (s) {
+            if (s && s.workspace && H.isRealSpaceDir(s.workspace)) alive[reqNormDir(s.workspace)] = 1;
+          });
+          REQ_ALIVE = alive;
+        } else {
+          REQ_ALIVE = null;   // 清单没拿到：不筛，宁可多显示
+        }
+        REQ_DATA = a[0] || { workspaces: [] };
+        renderRequirements();
+      })
+      .catch(function (e) {
+        if (quiet && REQ_DATA) return;      // 后台刷新失败不覆盖已有画面
+        els.list.innerHTML = '';
+        els.list.appendChild(hEl('div', 'history__hint', '读取需求失败：' + ((e && e.message) || e)));
+      });
+  }
+
+  /* 「整理」：手动触发一轮（POST /desk/requirements/consolidate）。
+     服务端按 state 判断走哪条路：
+       · 没初始化过 → 先按空间目录反推需求基线（首次可能跑几分钟，按钮要能等）；
+       · 已初始化   → 只消费上次整理之后的新会话。
+     入口有两个：
+       · 每个空间组头的「整理」——只整理这个空间（用户点哪个就是哪个，不猜）；
+       · 右上角「全部整理」——按空间逐个串行跑一遍，汇总结果（一键触发全部）。
+     两个入口都带「我的 → 默认引擎/模型」，服务端不再自动替换引擎。 */
+  function reqPostConsolidate(ws) {
+    var hdr = { 'Content-Type': 'application/json' };
+    if (H.getToken()) hdr['X-Magic-Token'] = H.getToken();
+    return fetch(H.getBase() + '/desk/requirements/consolidate', {
+      method: 'POST', headers: hdr,
+      body: JSON.stringify({
+        workspace: ws || '',
+        engine: H.getRunPref().engine || '',
+        model: (H.getRunPref().engine && H.getRunPref().model) || ''
+      })
+    })
+      .then(function (r) { return r.json().then(function (d) { return { ok: r.ok, d: d }; }); })
+      .then(function (x) {
+        var d = x.d || {};
+        if (!x.ok) throw new Error(d.error || ('HTTP ' + (x.d && x.d.status)));
+        if (d.error) throw new Error(d.error);
+        return d;
+      });
+  }
+
+  /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用。
+     label 只改顶部；组头统一显示「整理中…」/「整理」，不各自变文案。
+     二级页那枚「整理」也跟着禁用 —— 归纳期间它和组头一样不能重复点。 */
+  function reqSetBusy(on, label) {
+    if (on) { if (label !== undefined) REQ_BUSY_LABEL = label; }
+    else REQ_BUSY_LABEL = '全部整理';
+    var btn = els.sync;
+    if (btn) {
+      btn.disabled = !!on;
+      if (label !== undefined) btn.textContent = label;
+    }
+    var dbtn = els.detailSync;
+    if (dbtn) {
+      dbtn.disabled = !!on;
+      dbtn.textContent = on ? '整理中…' : '整理';
+    }
+    Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
+      b.disabled = !!on;
+      b.textContent = on ? '整理中…' : '整理';
+    });
+  }
+
+  function consolidateRequirements(target) {
+    if (REQ_BUSY || !target) return;
+    var ws = target.dir || target.id || '';
+    if (!ws) return;
+    var firstTime = target.initialized === false;
+    REQ_BUSY = true;
+    reqSetBusy(true, firstTime ? '初始化中…' : '整理中…');
+    var targetKey = target.id || target.dir || '';
+    var groupBtn = null;
+    Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
+      if (!groupBtn && targetKey && b.getAttribute('data-ws') === targetKey) groupBtn = b;
+    });
+    /* 点的是哪个空间，就只让哪个组头显示「初始化中…」；其它组头保持「整理中…」。 */
+    if (groupBtn) groupBtn.textContent = firstTime ? '初始化中…' : '整理中…';
+    reqPostConsolidate(ws)
+      .then(function (d) {
+        if (d.bootstrap) {
+          if (d.created || d.updated) toast('已按空间目录生成需求：新建 ' + (d.created || 0) + ' · 更新 ' + (d.updated || 0));
+          else toast('已按空间目录初始化：暂未识别到功能点');
+        }
+        else if (d.noop) toast('没有新的对话需要整理');
+        else if (d.updated || d.created) toast('整理完成：更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0));
+        else toast('整理完成');
+        loadRequirements(true);   // 后台刷新（不闪「读取中」）
+      })
+      .catch(function (e) { toast('整理失败：' + ((e && e.message) || e)); })
+      .then(function () {
+        REQ_BUSY = false;
+        reqSetBusy(false, '全部整理');
+      });
+  }
+
+  /* 全部整理：按空间串行跑，避免多个初始化同时读目录把机器拖垮。
+     顺序 = 有待整理的 → 未初始化的 → 其它（最近动过的仍在前），先做便宜/该做的。
+     每个空间单独一次 HTTP（各自 10 分钟超时）；某个失败不影响后面的。 */
+  function reqAllWorkspaces() {
+    var seen = {};
+    var list = ((REQ_DATA && REQ_DATA.workspaces) || []).filter(function (w) {
+      var key = w.dir || w.id || '';
+      if (!key || seen[key]) return false;
+      /* 会话已全部删除的空间不参与「全部整理」：否则又会把它重新生成出来。 */
+      var dir = reqNormDir(w.dir);
+      if (REQ_ALIVE && dir && !REQ_ALIVE[dir]) return false;
+      seen[key] = true;
+      return true;
+    });
+    function rank(w) {
+      if (Number(w.pending) > 0) return 0;
+      if (w.initialized === false) return 1;
+      return 2;
+    }
+    return list.sort(function (a, b) { return rank(a) - rank(b); });
+  }
+
+  function consolidateAllRequirements() {
+    if (REQ_BUSY) return;
+    var list = reqAllWorkspaces();
+    if (!list.length) {
+      toast('还没有可整理的空间');
+      return;
+    }
+    REQ_BUSY = true;
+    reqSetBusy(true, '整理中 0/' + list.length);
+    var i = 0, ok = 0, fail = 0, created = 0, updated = 0, firstErr = '';
+    function done() {
+      REQ_BUSY = false;
+      reqSetBusy(false, '全部整理');
+      loadRequirements(true);
+      if (fail) {
+        toast('全部整理完成：成功 ' + ok + ' · 失败 ' + fail + (firstErr ? '（' + firstErr + '）' : ''));
+      } else {
+        toast('全部整理完成：' + ok + ' 个空间 · 新建 ' + created + ' · 更新 ' + updated);
+      }
+    }
+    function step() {
+      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;
+      reqPostConsolidate(w.dir || w.id || '')
+        .then(function (d) {
+          ok++;
+          created += Number(d.created) || 0;
+          updated += Number(d.updated) || 0;
+        })
+        .catch(function (e) {
+          fail++;
+          if (!firstErr) firstErr = (e && e.message) || String(e);
+        })
+        .then(step);
+    }
+    step();
+  }
+
+  /* 挂载：index.html 在 DOM 就绪后调用一次。
+     host 里的 getter 必须保持为函数 —— 切环境后 BASE/TOKEN/空间清单会变。 */
+  function mount(host) {
+    H = host;
+    var root = H.rootEl, detail = H.detailEl;
+    if (!root || !detail) return;
+    root.innerHTML = ROOT_HTML;
+    detail.innerHTML = DETAIL_HTML;
+    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');
+    /* 两个动作：全部整理 / 返回一级；二级页的「整理」只作用于当前空间
+       （不是全部空间 —— 二级页的作用域就是这个空间，标成「全部整理」会让人以为还是全局动作）。 */
+    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);
+    };
+  }
+
+  /* 进入「需求」tab：每次进来都回到一级目录并拉一次清单（只读，不触发归纳）。 */
+  function show() {
+    REQ_DETAIL = null;
+    loadRequirements(false);
+  }
+
+  window.MagicReqs = { mount: mount, show: show };
+})();

package/cmd/magic-client/main.go

@@ -126,7 +126,7 @@ func main() {
 	if strings.TrimSpace(*uiDir) != "" || strings.TrimSpace(*mobileDir) != "" {
 		fmt.Fprintf(os.Stderr, "magic-client: 移动端界面（远程 HTML，改界面免重打 APK）  http://127.0.0.1:%d/m/?token=%s\n", port, tok)
 	}
-	fmt.Fprintf(os.Stderr, "magic-client: 接口 /desk/{health,contract,engines,modules,sessions,profile,asks,ask,ask/{id}/control} + 业务转发 /api/*（都要 X-Magic-Token）\n")
+	fmt.Fprintf(os.Stderr, "magic-client: 接口 /desk/{health,contract,engines,modules,sessions,profile,suggest,asks,ask,ask/{id}/control} + 业务转发 /api/*（都要 X-Magic-Token）\n")
 	var lanAddrs []string
 	if *lan {
 		// 绑到局域网就把可用地址全打出来：一台机器常有多个网卡，猜错比多打两行麻烦。

package/internal/cli/ask.go

@@ -126,6 +126,11 @@ type askOptions struct {
 	titleForce     bool   // --title-force：已有覆盖也重新归纳
 	titleEngine    string // --title-engine：归纳用哪个引擎（默认 llm）
 
+	// 下一轮建议（2026-10-23；见 internal/suggest）。
+	// 一轮结束后生成 0-3 条「用户下一句」的快捷回复；一次性旁路调用，不续接会话。
+	// 值 = 请求 JSON 的文件路径（"-" = stdin）。
+	suggestInput string // --suggest-followups <file|->：{"user":"…","reply":"…"}
+
 	// 四档权限模型（见 internal/agent/permission.go）。仅 claude / codebuddy 接线。
 	permission     string   // 档位：manual | accept-edits | auto | full
 	sandboxExclude []string // 始终在沙箱外执行的命令（sandbox.excludedCommands）
@@ -209,6 +214,7 @@ func bindAskFlags(cmd *cobra.Command, opts *askOptions) {
 	f.StringVar(&opts.sessionTitle, "session-title", "", "读一条会话**已存**的标题（JSON：{id,title}），不调 LLM。没有覆盖时回落到 prompt_head。列表页取标题走这条，别逐行调 --summarize-title")
 	f.BoolVar(&opts.titleForce, "title-force", false, "配合 --summarize-title：已有标题也重新归纳（默认命中缓存就直接返回，省一次 LLM 调用）")
 	f.StringVar(&opts.titleEngine, "title-engine", "llm", "--summarize-title 用哪个引擎归纳（默认 llm：纯文本、不带工具）")
+	f.StringVar(&opts.suggestInput, "suggest-followups", "", "生成下一轮快捷回复：传请求 JSON 的文件路径（\"-\" = stdin）：{\"user\":\"…\",\"reply\":\"…\"}。旁路调用，不续接当前会话；引擎走 -e（默认 llm）")
 	f.Uint64Var(&opts.logAfter, "after", 0, "配合 --session-log：增量续读，只回 seq > N 的事件（另附 count/after/lastSeq/snapshotRequired）")
 	f.Uint64Var(&opts.logBefore, "before", 0, "配合 --session-log：向上翻更早的历史，从文件尾跳过 N 条已画事件再取一页（0 = 最新一页；下一页把返回的 nextBefore 传回来。另附 count/before/nextBefore/firstSeq/more；与 --after 互斥）")
 	f.IntVar(&opts.logLimit, "limit", 200, "配合 --before：每页最多返回多少条事件（默认 200）")

package/internal/cli/root.go

@@ -368,6 +368,8 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
   一端删了处处都看不到。与插件的 DELETE /desk/session/{id} 是同一份实现
   （internal/session/delete.go），两条路可互换。
     magic-agent --delete-session <session_id>      # 删掉这条会话（含历史）
+  团队主会话还会沿父指针级联删掉挂在它下面的全部子任务会话（JSON 里
+  child_sessions_removed 是连带删掉的子会话条数）；只删子会话不会带走主会话。
   幂等：id 不认识 / 文件本来就不在 → 退出码 0，JSON 里 records_removed=0。
   ⚠️ 是**物理删除**：删完历史就回放不了了。客户端把它当成「删除」的唯一实现，
      只在本地藏起来（记墓碑）的话，别的客户端照样列着（2026-10-19 用户报的
@@ -477,6 +479,9 @@ codebuddy-gateway 引擎（CodeBuddy Code HTTP 网关，走 webhook + SSE；凭
 				return runSummarizeTitle(cmd, opts)
 			case flagChanged(cmd, "session-title"):
 				return runSessionTitle(cmd, opts)
+			case flagChanged(cmd, "suggest-followups"):
+				// 值可以是 "-"（stdin），所以用「传过没有」判，而不是「值非空」。
+				return runSuggestFollowups(cmd, opts)
 			case flagChanged(cmd, "title-force"):
 				// --title-force 只在 --summarize-title 下成立：单给它必然是调用方误解了
 				// （想要「强制重新归纳」却没给 id）。明说，不静默忽略。

package/internal/cli/session.go

@@ -646,24 +646,26 @@ func runDeleteSession(cmd *cobra.Command, opts *askOptions) error {
 	}
 	if opts.output == "text" {
 		_, _ = fmt.Fprintf(cmd.OutOrStdout(),
-			"magic-agent: 已删除会话 %s（登记记录 %d 条 / 历史 %d 份 / 标题 %d 条 / 状态 %d 条）\n",
-			res.ID, res.RecordsRemoved, res.LogsRemoved, res.TitlesRemoved, res.StatusesRemoved)
+			"magic-agent: 已删除会话 %s（登记记录 %d 条 / 历史 %d 份 / 标题 %d 条 / 状态 %d 条 / 子会话 %d 条）\n",
+			res.ID, res.RecordsRemoved, res.LogsRemoved, res.TitlesRemoved, res.StatusesRemoved, res.ChildSessionsRemoved)
 		return nil
 	}
 	out := struct {
-		Type            string `json:"type"`
-		ID              string `json:"id"`
-		RecordsRemoved  int    `json:"records_removed"`
-		LogsRemoved     int    `json:"logs_removed"`
-		TitlesRemoved   int    `json:"titles_removed"`
-		StatusesRemoved int    `json:"statuses_removed"`
+		Type                 string `json:"type"`
+		ID                   string `json:"id"`
+		RecordsRemoved       int    `json:"records_removed"`
+		LogsRemoved          int    `json:"logs_removed"`
+		TitlesRemoved        int    `json:"titles_removed"`
+		StatusesRemoved      int    `json:"statuses_removed"`
+		ChildSessionsRemoved int    `json:"child_sessions_removed"`
 	}{
-		Type:            "delete",
-		ID:              res.ID,
-		RecordsRemoved:  res.RecordsRemoved,
-		LogsRemoved:     res.LogsRemoved,
-		TitlesRemoved:   res.TitlesRemoved,
-		StatusesRemoved: res.StatusesRemoved,
+		Type:                 "delete",
+		ID:                   res.ID,
+		RecordsRemoved:       res.RecordsRemoved,
+		LogsRemoved:          res.LogsRemoved,
+		TitlesRemoved:        res.TitlesRemoved,
+		StatusesRemoved:      res.StatusesRemoved,
+		ChildSessionsRemoved: res.ChildSessionsRemoved,
 	}
 	return writeJSONLine(cmd.OutOrStdout(), out)
 }