@yangdcm/dsh-expert-team 1.3.13 → 1.3.14

package/CHANGELOG.md

@@ -3,6 +3,42 @@
 本包遵循[语义化版本](https://semver.org/lang/zh-CN/)。dsh 宿主版本线的对应关系写在
 `package.json` 的 `engines.dsh` 与 `dsh.compatibility` 里，插件市场按它判断"这个插件跟你的宿主兼不兼容"。
 
+## 1.3.14
+
+**性能收尾：同一时刻至多一条重活 + profile 补账**（性能修复 #4）
+
+- **真相换了一次**：上一版（1.3.13）把首屏从 3.4 s 打到 9–16 ms ✓，但真机连续采样发现
+  **重分节单次 4 805 ms、每 ≥6 s 一次**，而且**重活在飞时 summary 被拖到 772 ms**。
+  本轮先补账、再按数据改。
+- **profile 补账（`DSH_EXPERT_TEAM_STATE_PROFILE=1`）**：原先只有 `runs+select / subs / wfLabels / roles / tail`
+  五个点，其中 `tail` 把"从角色解析之后到回响应"的**全部**工作都吞进一段（真机上那段约 2 s 无账）。
+  现按执行顺序补齐：`people-enrich`（过滤/映射/登记/workflow 元数据/enrich）、`agents`（agents 映射 + 实时投影）、
+  `assemble`（违规/schema 校验/告警）、`artifacts`（`RUN.log` 尾 + git）、`tail`（持久化 + 序列化）
+  ⇒ **账目逐段对齐，不再有"无账的 2 秒"**。
+- **`feed` 也依赖 subs**：原先只有 `want('people')` 才算 subs，于是单独请求 `section=feed` 会**静默返回空 feed**
+  —— 典型的"两种零分不清"。现在 `needSubs = want('people') || want('feed')`，该花的一次枚举照花。
+- **新增两道上限（都带如实降级）**：
+  - `DSH_EXPERT_TEAM_ARTIFACTS_DEADLINE_MS`（默认 2 500 ms）：artifacts 段要读 `RUN.log` 尾、还要跑 `git`，
+    是**全链最不可控**的一段。超期限就跳过，并如实记 `artifacts:deadline`（读完日志再超就记 `files:deadline`），
+    跳过时**不写**那些键 —— 缺块 ≠ 空数据。
+  - `DSH_EXPERT_TEAM_MAX_FEED_AGENTS`（默认 60）：feed 按子代理条数封顶，被挡住的条数记 `feed:<n>`。
+- **客户端：重分节改为"只拉当前可见子标签那一块"**（此前无条件每 ≥6 s 拉 `people,feed,artifacts`）：
+  - `team`（人）→ `people,feed`；`tasks`（事）→ `people,feed`；`info`（料）→ `artifacts`；
+    **`board`（盘）→ 不拉任何重分节**（它只渲染 `runs[]`，而 runs 在 `summary` 里就有）；
+  - 「事」点开任务详情（需要 `files`/`logTail`）时才**一次性**补拉 `artifacts`，不常驻；
+  - 映射收敛成**只有两个 canonical 重分节 URL**（`people,feed` / `artifacts`）⇒ `stateHub` 的同 URL 在飞合并
+    能把面板、画布、徽章压成**同一条**。
+- **徽章不再与「料」标签并发两条重活**：徽章原先一直自己订阅 `people,feed`（2.5 s 一拍 ⇒ 重活常驻）。现在
+  面板/画布开着时由它们**发布**同一份 payload（`publishToLive`，发布时**合并**：缺块 ≠ 空数据），
+  徽章只在**无人发布**时才自己轮询，且节奏放宽到 **10 s**（子代理出现时另有 `liveTick()` 主动催一次）。
+- **真机数字的解释（诚实标注口径）**：`4 805 ms ≈ 2 × 2 400 ms` —— 当时画布同时订阅了 `people,feed` 与
+  `people,feed,artifacts` 两条**不同 URL** 的重活，服务端在同一事件循环上串行处理 ⇒ 各自看着慢一倍，
+  并把 `summary` 拖到 772 ms。本轮把重活收敛成"同一时刻至多一条"，这类并发在结构上不再可能。
+- 本机可复现的旁证（真实 run、进程内计时）：`snapshotRun` **1.3 ms**、`runLogTail` **0.3 ms**、
+  `liveFiles`（git）**0.3 ms 冷 / 0.0 ms 命中缓存** ⇒ artifacts 段**不是**那 2 s 的来源，
+  与"并发才是主因"的判断一致。
+- 端到端复测仍归用户（本机装不进运行中的宿主）：预期**同一时刻只有一条重活**、
+  `summary` 在重活在飞时仍为**十毫秒级**（此前 772 ms）、停留在某标签时后台不再出现不相干分节。
 ## 1.3.13
 
 **渐进式状态：`/state` 支持 `?section=`，首屏与会话体量解耦**（性能修复 #3）

package/client.js

@@ -1245,6 +1245,21 @@ window.__ModuleLoader__.load({
         h('div', { style: { display: 'flex', flexWrap: 'wrap', gap: 6 } }, options))
     }
 
+    // ── 标签 → 重分节映射（性能收尾批次：把"后台一直在拉三块"变成"只拉当前可见的那一块"）──
+    // 依据是各标签**实际渲染所用的字段**（读代码得出，不是猜）：
+    //   `team`（人）：agents/members/roles/wfRuns（people）+ 每个成员的实时操作流（feed）
+    //   `tasks`（事）：依赖图的人员标签来自 people；任务本身在 summary 里（便宜）；
+    //                  任务详情要 files/logTail（artifacts）⇒ 选中时**一次性**补拉（见下）
+    //   `info`（料）：违规/覆盖率在 summary 里；实时日志（logTail）需要 artifacts
+    //   `board`（盘）：只渲染 runs[]（summary 里已有）⇒ **不需要任何重分节**
+    // 这条映射是单一真源：订阅与"选中任务补拉"都读它，护栏测试也钉它。
+    function heavySectionsForTab(tb) {
+      if (tb === 'info') return 'artifacts'
+      if (tb === 'tasks') return 'people,feed' // feed 是内存切片（近乎免费），与徽章同 URL ⇒ 合并成一条
+      if (tb === 'board') return ''
+      return 'people,feed' // team（默认）与人相关视图
+    }
+
     function Panel(props) {
       var sidProp = (props && props.sessionId) || ''
       var viewMode = (props && props.mode) === 'view'
@@ -1373,6 +1388,7 @@ window.__ModuleLoader__.load({
       function onState(d) {
           if (d && d.ok) {
             setData(function (prev) { return mergeStatePayload(prev, d) }); setErr(''); reschedule(d)
+            try { publishToLive(d) } catch (e) {}
             // N2: keep the composer takeover in sync with pendingDecision
             // 批 0-2：把 /state 已经返回的 runId/workspace 一并传出，供横幅拍板时回传给 /decide
             try { if (exports._syncPending) exports._syncPending(d.pendingDecision, sessionId, d.runId, d.workspace) } catch (e) {}
@@ -1407,19 +1423,35 @@ window.__ModuleLoader__.load({
       }
       useEffect(function () {
         if (!isOpen && !viewMode) return undefined // panel closed & not canvas → no polling
+        setLivePublisher(true)   // 面板/画布开着 ⇒ 接管徽章的数据（见 publishToLive 的注释）
         // **双订阅**（性能修复 #3）：`summary` 便宜（阶段/进度/计数）⇒ 按 `pollMs` 快拉，
         // 首屏立刻有内容；`people,feed,artifacts` 贵（成员解析/事件流/日志尾+git）⇒ 至少 6 秒一次，
         // 到达后由 `mergeStatePayload` 合并进同一份 data（**不会**把摘要拍掉的字段抹掉）。
         // stateHub 按 URL 各自计时（per-URL due），所以"一快一慢"不会互相拖。
         var off = stateHubSubscribe(stateUrl('summary'), dispCfg.pollMs, onState)
-        var offDetail = stateHubSubscribe(stateUrl('people,feed,artifacts'), Math.max(dispCfg.pollMs, 6000), onState)
+        // 重分节**按当前可见子标签**订阅（不再无条件拉 people,feed,artifacts）：切标签时旧的 URL
+        // 随卸载退订、新的立即拉一次 ⇒ 后台只保留"你正在看的那一块"。
+        var heavy = heavySectionsForTab(tab)
+        var offDetail = heavy ? stateHubSubscribe(stateUrl(heavy), Math.max(dispCfg.pollMs, 6000), onState) : function () {}
         // catch up instantly when the user returns to the tab / window（只补便宜那一份）
         var onVis = function () { if (document.visibilityState === 'visible') stateHubFetch(stateUrl('summary'), onState) }
         var onFocus = function () { stateHubFetch(stateUrl('summary'), onState) }
         document.addEventListener('visibilitychange', onVis)
         window.addEventListener('focus', onFocus)
-        return function () { off(); offDetail(); document.removeEventListener('visibilitychange', onVis); window.removeEventListener('focus', onFocus) }
-      }, [sessionId, selRunV, isOpen, viewMode, dispCfg.pollMs])
+        return function () {
+          off(); offDetail()
+          setLivePublisher(false)
+          document.removeEventListener('visibilitychange', onVis); window.removeEventListener('focus', onFocus)
+        }
+      }, [sessionId, selRunV, isOpen, viewMode, dispCfg.pollMs, tab])
+
+      // 任务详情（files / logTail）属于 artifacts 分节：**只在真的点开任务时补拉一次**，
+      // 不在后台常驻（否则等于把 artifacts 又变回常驻重分节）。切换选中任务会重新拉一次。
+      useEffect(function () {
+        if (!selTaskV) return
+        if (tab !== 'tasks') return   // 任务详情（files/logTail）只在「事」标签渲染
+        try { stateHubFetch(stateUrl('artifacts'), onState) } catch (e) {}
+      }, [selTaskV && selTaskV.id])
 
       // Make the docked panel reserve space (shift the shell frame) instead of
       // covering the workspace; clears when closed or floating (md-preview trick).
@@ -2442,7 +2474,11 @@ window.__ModuleLoader__.load({
 
     // ── 共享 state 轮询（HeaderButton / LiveCapsule 复用，单例；无订阅者即停）──
     var liveStore = { data: null, sid: '', off: null, subs: new Set() }
-    var LIVE_BASE_MS = 2500   // 徽章/画布的基础节奏（与面板的 dispCfg.pollMs 取更小者由 hub 统一决定）
+    // 徽章/胶囊的基础节奏：它订阅的是 `people,feed`（重分节）。原先 2.5 s 等于**让重活常驻**
+    // （即使没开面板也在拉），实测那正是"重请求在飞时 summary 被拖到 772 ms"的来源之一。
+    // 徽章是环境状态（有没有人在跑／有没有待决策），10 s 的延迟可以接受；
+    // 需要立刻刷新时另有 `liveTick()`（子代理出现时主动催一次），不靠高频轮询。
+    var LIVE_BASE_MS = 10000
     function liveUrl(sid) { return '/plugins/dsh-expert-team/state?sessionId=' + encodeURIComponent(sid) + '&section=people,feed' }
     // 手动催一次（子代理刚出现时立刻刷新一次徽章，不必等下一个 tick）
     function liveTick() {
@@ -2461,20 +2497,45 @@ window.__ModuleLoader__.load({
       var m = (d && d.members) || {}
       return Object.keys(m).some(function (k) { var v = m[k]; return v && typeof v === 'object' && (v.activity === 'running' || v.shortStatus === 'running') })
     }
+    // ── 面板/画布 → 徽章的**发布**路径（性能收尾批次）────────────────────────────
+    // 为什么需要：徽章订阅的是 `people,feed`（重分节）。若它一直自己轮询，而当前标签是「料」
+    // （重分节 = `artifacts`），同一时刻就有**两条重活并发** —— 真机上那正是单发从 2.4 s 变
+    // 4.8 s 的原因（同一事件循环上串行，各自看着都慢一倍），连带把 9 ms 的 summary 拖到 772 ms。
+    // 现在：面板/画布开着时由它们**发布**同一份 payload（零额外请求）；都没开时徽章才自己轮询。
+    var livePublishers = 0
+    function publishToLive(d) {
+      if (!d || typeof d !== 'object') return
+      // 合并而不是替换：面板按标签只发一部分块（缺块 ≠ 空数据），合并后徽章不会因为
+      // 收到一份只有 summary 的负载就把已知的成员/活动抹掉。
+      liveStore.data = Object.assign({}, liveStore.data || {}, d)
+      try { harvestActivity(liveStore.data) } catch (e) {}
+      try { stateHub.busy = teamBusy(liveStore.data) } catch (e) {}
+      liveStore.subs.forEach(function (f) { try { f(liveStore.data) } catch (e) {} })
+    }
+    function setLivePublisher(on) {
+      livePublishers += on ? 1 : -1
+      if (livePublishers < 0) livePublishers = 0
+      notify()
+    }
+    function useLivePublishers() { return useExternal(function () { return livePublishers }) }
+
     function useLiveState(sid) {
       var st = useState(liveStore.data); var data = st[0], setData = st[1]
+      var pubs = useLivePublishers()
       useEffect(function () {
         if (!sid) return undefined
         liveStore.sid = sid
         var fn = function (d) { setData(d) }
         liveStore.subs.add(fn)
+        // 有人发布（面板/画布开着）⇒ 徽章**不再另开一条重分节**，靠发布的数据保持新鲜。
+        if (pubs > 0) return function () { liveStore.subs.delete(fn) }
         // 经 hub 订阅：与面板/画布共用同一个时钟与在飞守卫（这里**不再**自己 setInterval）
         var off = stateHubSubscribe(liveUrl(sid), LIVE_BASE_MS, liveDeliver)
         return function () {
           liveStore.subs.delete(fn)
           off()
         }
-      }, [sid])
+      }, [sid, pubs])
       return data
     }
     // 头部徽章文案：让「并排面板」入口自带团队实时状态（与画布标签职责区分）

package/lib/command.js

@@ -5291,6 +5291,13 @@ export function apply(ctx, config) {
                 const MAX_ROLE_SUBS = Math.max(1, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_MAX_ROLE_SUBS) || 0) || 60);
                 // people 分节的软期限：超时后跳过更贵的可选增强（workflow 元数据），同样如实标注。
                 const PEOPLE_DEADLINE_MS = Math.max(200, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_PEOPLE_DEADLINE_MS) || 0) || 2500);
+                // artifacts 分节的软期限：它要读 RUN.log 尾、还要跑 git（liveFiles）——后者在大工作区
+                // 里是最不可控的一段。超过就从**请求开始**算起跳过，并**如实进 degraded**（缺块 ≠ 空数据：
+                // 跳过时键不存在，客户端据 degraded 知道"不是没有，是没来得及"）。
+                const ARTIFACTS_DEADLINE_MS = Math.max(200, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_ARTIFACTS_DEADLINE_MS) || 0) || 2500);
+                // feed 分节的硬上限：每 agent 只嵌最近 12 条事件，但 agent 数本身要封顶（重会话里
+                // subs 可能几十上百条），超出的条数**如实进 degraded**。
+                const MAX_FEED_AGENTS = Math.max(1, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_MAX_FEED_AGENTS) || 0) || 60);
                 const peopleStartedAt = Date.now();
                 const degraded = [];
                 const reg = (await registeredWorkspaces()).filter(Boolean);
@@ -5346,9 +5353,12 @@ export function apply(ctx, config) {
                 // 只有 people 分节才解析人员：这一步要枚举子会话 durable 清单（重会话里这是整条链上
                 // 最大的一块）。首屏用 summary 时不付这个成本 —— `agents` 返回空数组，
                 // 由客户端 `sections` 字段知道自己拿的是"摘要"，UI 如实显示"正在加载成员"。
-                let subs = want('people') ? await listSubagentStatusBySession(ctx, peopleSid, knownIds) : [];
+                // `feed` 也必须先有 subs（它按子会话遍历活动缓存）。若只想要 feed 却跳过枚举，
+                // feed 会**静默变空** —— 那正是本仓最忌讳的"两种零分不清"（缺块 ≠ 空数据）。
+                const needSubs = want('people') || want('feed');
+                let subs = needSubs ? await listSubagentStatusBySession(ctx, peopleSid, knownIds) : [];
                 // 归属会话拿不到人时退回请求会话（否则面板整块空掉），但**如实标注**这不是归属会话的人。
-                if (want('people') && !subs.length && peopleSid !== sid) {
+                if (needSubs && !subs.length && peopleSid !== sid) {
                   const fallback = await listSubagentStatusBySession(ctx, sid, knownIds);
                   if (fallback.length) { subs = fallback; peopleSid = sid; }
                 }
@@ -5463,6 +5473,7 @@ export function apply(ctx, config) {
                 if (want('people')) sel.members = enrichMembers(sel.runId, sel.roles, sel.members, subById, sel.agents);
                 // cost/model plan: expose each role's planned model so the overlay
                 // shows the scheme even before dispatch (live model wins once running).
+                mark('people-enrich');
                 const modelPlan = sel.models || modelPlanFor(sel.roles || []);
                 for (const role of Object.keys(sel.members)) {
                   const m = sel.members[role];
@@ -5514,13 +5525,19 @@ export function apply(ctx, config) {
                   }));
                   sel.tasksEmpty = true;
                 }
+                mark('agents');
                 // Live per-agent activity feed (Qoder-style): last tool events
                 // per subagent session, keyed by agent id.
                 // 只在 feed 分节里收集（它按子会话遍历活动缓存；summary 首屏不需要）。
+                // 上限：agent 数封顶 MAX_FEED_AGENTS，被截断的条数如实进 degraded。
                 const feed = {};
-                if (want('feed')) for (const s of subs) {
-                  const arr = ACTIVITY.get(s.id);
-                  if (arr && arr.length) feed[s.id] = arr.slice(-12);
+                if (want('feed')) {
+                  const feedTargets = subs.slice(0, MAX_FEED_AGENTS);
+                  if (subs.length > MAX_FEED_AGENTS) degraded.push('feed:' + (subs.length - MAX_FEED_AGENTS));
+                  for (const s of feedTargets) {
+                    const arr = ACTIVITY.get(s.id);
+                    if (arr && arr.length) feed[s.id] = arr.slice(-12);
+                  }
                 }
                 sel.feed = feed;
                 // 用同一批 feed 事件回填 lastEventAt（不额外读日志）
@@ -5549,13 +5566,20 @@ export function apply(ctx, config) {
                   if (fp.selfBuilt) sel.violations = sel.violations.concat([`非脚手架 run（疑似绕过 /team 手写）：缺 ${fp.missing.join('、')}`]);
                 } catch { /* best-effort */ }
                 try { sel.warnings = checkKindWarnings(taskList(sel.tasks)); } catch { sel.warnings = []; }
+                mark('assemble');
                 // Live monitoring: RUN.log feed (what just happened) + git
                 // changed files (what is being touched right now).
                 // 只在 artifacts 分节里读（`liveFiles` 要跑 git、`runLogTail` 要读日志尾部）。
                 if (want('artifacts')) {
-                  try { sel.logTail = await runLogTail(join(sel.workspace, 'team', sel.runId)); } catch { sel.logTail = ''; }
-                  try { sel.files = await liveFiles(sel.workspace, sel.runId); } catch { sel.files = []; }
+                  const withinArtifacts = () => (Date.now() - peopleStartedAt) < ARTIFACTS_DEADLINE_MS;
+                  if (!withinArtifacts()) degraded.push('artifacts:deadline');
+                  else {
+                    try { sel.logTail = await runLogTail(join(sel.workspace, 'team', sel.runId)); } catch { sel.logTail = ''; }
+                    if (!withinArtifacts()) degraded.push('files:deadline');
+                    else { try { sel.files = await liveFiles(sel.workspace, sel.runId); } catch { sel.files = []; } }
+                  }
                 }
+                mark('artifacts');
                 // **GET 不写 run 工件**（2026-09-13 修）：这里原先每 ≤5 分钟触发一次
                 // `autoAggregate`（`Date.now() - lastAggAt > 5*60*1000`），于是浮层每 3 秒的轮询
                 // 会**周期性改写 `team/METRICS.md` 与 `team/LEARNINGS.md`** —— 而 `LEARNINGS.md`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yangdcm/dsh-expert-team",
-  "version": "1.3.13",
+  "version": "1.3.14",
   "description": "dsh「专家团」bundle：一句自然语言自动组建/持久化一支 12 角色多智能体团队，共享工作区协议 + 阶段门控编排 + 结构化交接 + 质量门禁/自动调度，实现者直接改代码并产出持久工件；带 live 团队浮层（质量门禁/覆盖率/工件预览）。 · Role-based multi-agent expert team for DeepSeek Harness: one sentence in, a staged and gated team delivery out.",
   "type": "module",
   "license": "MIT",