@yangdcm/dsh-expert-team 1.3.15 → 1.3.17

package/lib/command.js

@@ -14,7 +14,7 @@
 
 import { randomUUID } from 'node:crypto';
 import { execFile as execFileCb } from 'node:child_process';
-import { mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { promisify } from 'node:util';
 import { homedir } from 'node:os';
@@ -22,9 +22,19 @@ import { join, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createArtifactWriter, nodeFsPort, cordisFsPort, DEFAULT_SCHEMA_GUARDS } from './artifact-writer.js';
 import { createBoundaryInterceptor } from './interception.js';
-import { createOwnershipGate } from './artifact-ownership.js';
+import { createOwnershipGate, ARTIFACT_OWNERS } from './artifact-ownership.js';
+
+/**
+ * **run 模板文件清单**（单一真源）。
+ * 谁在用：① 建 run 时按它复制 `skills/expert-team/assets/templates/`；② R1 绕过检测
+ * （`bash` 里重定向写 run 工件 ⇒ 只留痕）需要"已知工件名"集合。**不要再复制一份** ——
+ * 本仓为"同一事实多份定义"专门有 `vocab-consistency` / `artifact-ownership` 断言。
+ */
+export const ARTIFACT_TEMPLATES = Object.freeze(['TASK.md', 'ROSTER.json', 'STATE.json', '任务看板.md', 'SPEC.md', 'PLAN.md', 'RESEARCH.md', 'TASKS.json', 'REVIEW.md', 'TEST.md', 'SUMMARY.md', 'RETRO.md', 'AUTHORITY.md']);
 // 设计稿 §十二 第 3 步：并发写留痕（只记录、只告警，绝不阻断）。
 import { createWriteTracer, formatConflict } from './write-tracer.js';
+import { createEffortPreflight, effortPreflightPlan, declaredEffortsFromPresetSource, EFFORT_PROBE_DELAYS_MS } from './effort-preflight.js';
+import { createArtifactRedirectWatcher } from './artifact-redirect-watch.js';
 import { createLoopGuard } from './loop-guard.js';
 // C 线第 17 项：派工即回写（派工成功后由**代码**把任务置 in_progress + owner，不靠模型记得改）。
 import { createDispatchLedger } from './dispatch-ledger.js';
@@ -1059,6 +1069,46 @@ function scheduleOptionalPluginCheck(ctx, delays) {
   }
   return timers;
 }
+// ── 会话模型 effort 预检（2026-09-15，D 项）────────────────────────────────────
+// 只告警、不阻断：宿主在**任何网络 I/O 之前**就会因"模型未声明 reasoningEfforts"拒绝带 effort 的
+// 角色派工（`dsh-llm` 的 resolveCallWithInfo）。插件改不了宿主行为，只能**提前说清** + 给出修法。
+// 纪律：读不到 ⇒ 静默；一次加载最多一行；服务晚挂则就绪后重探（同 OPTIONAL_* 那套）。
+let EFFORT_PREFLIGHT = null;
+let EFFORT_TIMERS = [];
+function scheduleEffortPreflight(ctx, delays) {
+  const plan = Array.isArray(delays) ? delays : EFFORT_PROBE_DELAYS_MS;
+  // 实例**按 ctx 创建**（不搞模块级 ctx 全局）：读模型能力的入口在闭包里直接捕获 ctx。
+  EFFORT_PREFLIGHT = createEffortPreflight({
+    readPresetSource: async () => readFile(new URL('../presets/expert-team/agent.cordis.yml', import.meta.url), 'utf8'),
+    readSelection: (c) => {
+      const svc = c && typeof c.get === 'function' ? c.get('agentDefaultModel') : null;
+      const sel = svc && typeof svc.currentSelection === 'function' ? svc.currentSelection() : null;
+      return sel && sel.provider && sel.model ? { provider: String(sel.provider), model: String(sel.model) } : null;
+    },
+    readModelInfo: async (provider, model) => {
+      const llm = ctx && typeof ctx.get === 'function' ? ctx.get('llm') : null;
+      if (!llm || typeof llm.resolveModelInfo !== 'function') throw new Error('llm.resolveModelInfo 不可用');
+      return llm.resolveModelInfo(provider, model);
+    },
+    onEvent: (type, payload) => {
+      try { console.warn('[expert-team] ' + type, JSON.stringify(payload)); } catch { /* 观测失败不影响加载 */ }
+    },
+  });
+  plan.forEach((ms, i) => {
+    const t = setTimeout(() => { void EFFORT_PREFLIGHT(ctx, { isLast: i === plan.length - 1 }); }, ms);
+    if (t && typeof t.unref === 'function') t.unref();
+    EFFORT_TIMERS.push(t);
+  });
+  // 事件驱动兜底：llm / agentDefaultModel 任一晚挂，服务一出现就立刻重探（不出现则永不触发）。
+  for (const svc of ['llm', 'agentDefaultModel']) {
+    try { if (ctx && typeof ctx.inject === 'function') ctx.inject([svc], () => { void EFFORT_PREFLIGHT(ctx, { isLast: true }); }); } catch { /* best-effort */ }
+  }
+  return EFFORT_TIMERS;
+}
+function _resetEffortPreflight() {
+  for (const t of EFFORT_TIMERS) { try { clearTimeout(t); } catch { /* ignore */ } }
+  EFFORT_TIMERS = [];
+}
 function _resetOptionalHintOnce() {
   OPTIONAL_HINT_DONE = false;
   for (const t of OPTIONAL_PROBE_TIMERS) { try { clearTimeout(t); } catch { /* ignore */ } }
@@ -1149,7 +1199,7 @@ async function scaffoldRun(cwd, mode) {
   // 测试里的 14 项）**不是同一个集合**：那边多一个 `RUN.log.md`（由 run log 写入器创建）、这边就是
   // 模板全集。两者关系由 `artifact-ownership.test.mjs` 的「工件清单一致」断言钉住，避免下次又被
   // 当成同一件事去"对齐"（2026-09-15 阶段 C 的口径核查）。
-  const templates = ['TASK.md', 'ROSTER.json', 'STATE.json', '任务看板.md', 'SPEC.md', 'PLAN.md', 'RESEARCH.md', 'TASKS.json', 'REVIEW.md', 'TEST.md', 'SUMMARY.md', 'RETRO.md', 'AUTHORITY.md'];
+  const templates = ARTIFACT_TEMPLATES;
   for (const t of templates) {
     try {
       await ARTIFACT.must(join(runDir, t), await readFile(new URL(t, TEMPLATES_SRC)));
@@ -1685,6 +1735,44 @@ function deriveMemberEntries(subById, existing) {
   }
   return { entries: out, changed };
 }
+/**
+ * "这串东西像不像 session id"的判据 —— **按角色名精确排除**，不按长度猜。
+ *
+ * 为什么不用长度：可读性好的测试/宿主可能用短 id（`ended-x`、`live-1`），长度阈值会**误伤它们**
+ * ⇒ 把真 id 过滤掉，那才是真丢数据。而"角色名"是可以精确判定的：
+ *   · 等于某个角色 id（`backend`）⇒ 排除；
+ *   · 首个 `-` 段就是角色 id（`frontend-F4` / `reviewer-R1`，角色名带轮次后缀）⇒ 排除。
+ * 真实 session id 是 UUID（首段 8 位十六进制）或任意非角色名 ⇒ 保留。
+ * 只用于"过滤出真 id"，**不**用于判定归属（归属看 `STATE.members` 与 `artifact-ownership`）。
+ */
+const ROLE_NAME_SET = new Set(DEFAULT_ROLES.map((r) => String(r).toLowerCase()));
+export function isAgentIdLike(v) {
+  const s = String(v || '').trim();
+  if (!s || /\s/.test(s)) return false;
+  const lower = s.toLowerCase();
+  if (ROLE_NAME_SET.has(lower)) return false;
+  const head = lower.split('-')[0];
+  if (head && ROLE_NAME_SET.has(head)) return false;
+  return true;
+}
+
+/**
+ * `STATE.members` → **只含 agent id** 的清单。
+ *
+ * 为什么必须单独有它（2026-09-15 性能修复 #5，真机 profile 定位）：`membersFromState().byRole`
+ * 这个 Map **同时**塞了 `role→agentId` 与 `agentId→role` 两种键 ⇒ 直接取 `.values()` 会**混进角色名**
+ * （`backend` / `reviewer` …）。而角色名永远不可能是某个会话 header 的 id ⇒
+ * `missingIds` **永久非空** ⇒ `/state` 每次都认为"还有人查不到" ⇒ **每个请求都重新枚举
+ * 475 个 artifact**（真机 subs 段实测 2.4 s），`SUB_HEADER_MEMO` 因此形同虚设。
+ *
+ * ⇒ 需要 id 的地方一律走这里，**不要**再对 `byRole` 取 `.values()`。
+ */
+export function memberAgentIds(members) {
+  const { byRole } = membersFromState(members);
+  const out = [];
+  for (const k of byRole.keys()) if (isAgentIdLike(k)) out.push(k);
+  return out;
+}
 function membersFromState(members) {
   const byRole = new Map(), names = new Map();
   for (const item of Array.isArray(members) ? members : []) {
@@ -1713,6 +1801,9 @@ function buildRoleSubMap(subs, stateMembers, wfLabels) {
   if (precise.byRole.size) {
     const m = new Map();
     for (const [role, id] of precise.byRole) {
+      // ⚠️ byRole 是**双键** Map（role→id 与 id→role 都在）⇒ 这里必须跳过 id 形态的键，
+      // 否则会把 "agentId→sub" 也当成一条角色映射塞进去（2026-09-15 与 subs 段同一根因）。
+      if (isAgentIdLike(role)) continue;
       const hit = subs.find((s) => String(s.id || '') === id);
       if (hit) m.set(role, hit);
     }
@@ -2819,24 +2910,123 @@ async function registeredWorkspaces() {
 }
 
 // List runs under a single workspace; each has a `workspace`.
+// ── run 列表的**逐 run 戳缓存**（2026-09-15 性能修复 #6：冷启动）────────────────────
+// 实测：重启后**第一次** `?section=summary` 的 `runs+select` 段 = 876 ms（每个 run 都要读
+// STATE.json + TASKS.json 再算 health/violations/owner）。而这段数据在"run 目录没动"时**完全可复用**。
+//
+// 失效键 = **每个 run 自己的** `STATE.json` 与 `TASKS.json` 的 `(mtimeMs, size)`：
+//   · 改一次 STATE（阶段推进/任务回写）⇒ 该 run 的戳变 ⇒ 只重算**那一个** run；
+//   · 新增 run ⇒ 缓存里没有 ⇒ 计算并写入（**新 run 一律可见**，这是功能不是可牺牲项）；
+//   · 删 run ⇒ readdir 里没有 ⇒ 不会被读出（顺带在保存时剪掉）。
+// ⚠️ 为什么**不能**只戳 run 目录：改文件**不会**改父目录 mtime（只有增删条目会）⇒ 那样会读到旧
+// 阶段/旧 done 数。戳到文件本身才是"看到的就是真的"。
+// 落盘（$DSH_HOME/expert-team/runs-index.json）是为了**重启后第一次**也不必从零算：本进程只需
+// stat 校验 + 命中；没有索引文件的那一次仍要算一遍（这是它的性质，如实记档）。
+const RUNS_INDEX_MAX = 500;
+let RUNS_INDEX = null;           // Map<absRunDir, {stamp, row}>
+let RUNS_INDEX_LOAD = null;      // 载入中的 promise（同刻只读一次盘）
+let RUNS_INDEX_SAVE_TIMER = null;
+const RUNS_INDEX_STATS = { hits: 0, misses: 0, loads: 0, saves: 0, saveErrors: 0, computes: 0 };
+/**
+ * 索引文件位置。可用 `DSH_EXPERT_TEAM_RUNS_INDEX` 覆盖 —— 两个用途：
+ *   ① 测试（沙箱里 `~/.dsh` 可能不可写，指到临时目录即可做完整往返验证）；
+ *   ② 运维（把索引放到更快的盘/容器可写卷）。
+ */
+function runsIndexPath() {
+  const override = String((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_RUNS_INDEX) || '').trim();
+  return override || join(dshHome(), 'expert-team', 'runs-index.json');
+}
+async function loadRunsIndex() {
+  if (RUNS_INDEX) return RUNS_INDEX;
+  if (RUNS_INDEX_LOAD) return RUNS_INDEX_LOAD;
+  RUNS_INDEX_STATS.loads += 1;
+  RUNS_INDEX_LOAD = (async () => {
+    let entries = {};
+    try {
+      const raw = await readFile(runsIndexPath(), 'utf8');
+      const j = JSON.parse(raw);
+      if (j && typeof j === 'object' && j.entries && typeof j.entries === 'object') entries = j.entries;
+    } catch { /* 没有索引 / 坏了 ⇒ 空表（下次保存自愈）*/ }
+    RUNS_INDEX = new Map(Object.entries(entries).filter(([, v]) => v && typeof v.stamp === 'string' && v.row && typeof v.row === 'object'));
+    return RUNS_INDEX;
+  })();
+  try { return await RUNS_INDEX_LOAD; } finally { RUNS_INDEX_LOAD = null; }
+}
+function scheduleRunsIndexSave() {
+  if (RUNS_INDEX_SAVE_TIMER) return;
+  RUNS_INDEX_SAVE_TIMER = setTimeout(() => {
+    RUNS_INDEX_SAVE_TIMER = null;
+    (async () => {
+      try {
+        const map = RUNS_INDEX || new Map();
+        // 剪枝：按 map 的插入顺序保留最近 RUNS_INDEX_MAX 条（Map 保序 ⇒ 旧的先丢）
+        const entries = {};
+        const keys = [...map.keys()];
+        for (const k of keys.slice(Math.max(0, keys.length - RUNS_INDEX_MAX))) entries[k] = map.get(k);
+        const tmp = runsIndexPath() + '.tmp';
+        await mkdir(dirname(runsIndexPath()), { recursive: true });
+        await writeFile(tmp, JSON.stringify({ version: 1, entries }), 'utf8');
+        await rename(tmp, runsIndexPath());
+        RUNS_INDEX_STATS.saves += 1;
+      } catch { RUNS_INDEX_STATS.saveErrors += 1; /* 索引写不进去只是下次多算一遍，绝不影响功能 */ }
+    })();
+  }, 1500);
+  if (RUNS_INDEX_SAVE_TIMER && typeof RUNS_INDEX_SAVE_TIMER.unref === 'function') RUNS_INDEX_SAVE_TIMER.unref();
+}
+/** 仅供测试：丢内存索引并复位计数（不清盘上的索引文件）。 */
+function _resetRunsIndex() {
+  RUNS_INDEX = null; RUNS_INDEX_LOAD = null;
+  if (RUNS_INDEX_SAVE_TIMER) { clearTimeout(RUNS_INDEX_SAVE_TIMER); RUNS_INDEX_SAVE_TIMER = null; }
+  RUNS_INDEX_STATS.hits = 0; RUNS_INDEX_STATS.misses = 0; RUNS_INDEX_STATS.loads = 0;
+  RUNS_INDEX_STATS.saves = 0; RUNS_INDEX_STATS.saveErrors = 0; RUNS_INDEX_STATS.computes = 0;
+}
+async function fileStampOf(p) {
+  try { const st = await stat(p); return Math.round(Number(st.mtimeMs) || 0) + ':' + (Number(st.size) || 0); }
+  catch { return null; }
+}
+/** 单个 run 的列表行：戳没变就复用缓存（落盘索引 ⇒ 重启后第一次也能命中）。 */
+async function cachedRunRow(ws, dir, n) {
+  await loadRunsIndex();
+  const statePath = join(dir, 'STATE.json');
+  const stampState = await fileStampOf(statePath);
+  const stampTasks = await fileStampOf(join(dir, 'TASKS.json'));
+  const stamp = stampState + '|' + stampTasks;
+  const rec = RUNS_INDEX.get(dir);
+  // 缺 STATE.json 时（stampState === null）**不进缓存**：坏 run 每次如实重算，代价是一次失败的读。
+  if (rec && stampState !== null && rec.stamp === stamp) { RUNS_INDEX_STATS.hits += 1; return { ...rec.row }; }
+  RUNS_INDEX_STATS.misses += 1;
+  const st0 = stampState === null ? null : await readJsonSafe(statePath);
+  let row;
+  if (st0) {
+    const tasks0 = taskList(stampTasks === null ? null : await readJsonSafe(join(dir, 'TASKS.json')));
+    const done0 = tasks0.filter((t) => ['completed', 'done'].includes(t.status)).length;
+    const owners = new Set((tasks0.map((t) => t.owner)).filter(Boolean));
+    const h0 = runHealth(st0);
+    row = { runId: n, workspace: ws, phase: st0.phase, status: st0.status, updatedAt: st0.updatedAt, goal: '', done: done0, total: tasks0.length, members: owners.size, violations: checkTasks(tasks0, st0.phase, st0).length, health: h0.health, healthReason: h0.reason, ownerSession: String(st0.ownerSession || ''), ownerResolved: !!st0.ownerSession };
+  } else {
+    // B1：面板的 run 下拉过去同样静默跳过没有 STATE.json 的目录 —— 用户在界面上
+    // **完全看不到**这些遗留/损坏的 run。现在如实列出并标 `health: 'broken'`。
+    row = { runId: n, workspace: ws, phase: '', status: '', updatedAt: '', goal: '', done: 0, total: 0, members: 0, violations: 0, health: 'broken', healthReason: '缺 STATE.json（或不可解析）' };
+  }
+  if (stampState !== null) {
+    RUNS_INDEX_STATS.computes += 1;
+    RUNS_INDEX.set(dir, { stamp, row });
+    scheduleRunsIndexSave();
+  }
+  return { ...row };
+}
 async function listRunsInWorkspace(ws) {
   const root0 = teamRoot(ws);
-  let names0 = [];
-  try { names0 = await readdir(root0); } catch { return []; }
+  let ents0 = [];
+  // ⚠️ 只要**目录**：`team/` 根下还住着普通文件（`CODEINDEX.json`、`LEARNINGS.md`、`REPOWIKI.md`…），
+  // 旧实现把它们也当 run 名去读 `<name>/STATE.json` ⇒ 必然失败 ⇒ 面板的 run 下拉里出现
+  // 一串"broken run"（画布上真能看到这种条目）。run 是目录，这个判据才是对的。
+  try { ents0 = await readdir(root0, { withFileTypes: true }); } catch { return []; }
   const out0 = [];
-  for (const n of names0) {
-    const st0 = await readJsonSafe(join(root0, n, 'STATE.json'));
-    if (st0) {
-      const tasks0 = taskList(await readJsonSafe(join(root0, n, 'TASKS.json')));
-      const done0 = tasks0.filter((t) => ['completed', 'done'].includes(t.status)).length;
-      const owners = new Set((tasks0.map((t) => t.owner)).filter(Boolean));
-      const h0 = runHealth(st0);
-      out0.push({ runId: n, workspace: ws, phase: st0.phase, status: st0.status, updatedAt: st0.updatedAt, goal: '', done: done0, total: tasks0.length, members: owners.size, violations: checkTasks(tasks0, st0.phase, st0).length, health: h0.health, healthReason: h0.reason, ownerSession: String(st0.ownerSession || ''), ownerResolved: !!st0.ownerSession });
-    } else {
-      // B1：面板的 run 下拉过去同样静默跳过没有 STATE.json 的目录 —— 用户在界面上
-      // **完全看不到**这些遗留/损坏的 run。现在如实列出并标 `health: 'broken'`。
-      out0.push({ runId: n, workspace: ws, phase: '', status: '', updatedAt: '', goal: '', done: 0, total: 0, members: 0, violations: 0, health: 'broken', healthReason: '缺 STATE.json（或不可解析）' });
-    }
+  for (const ent of ents0) {
+    if (!ent || ent.isDirectory?.() !== true) continue;
+    const n = ent.name;
+    out0.push(await cachedRunRow(ws, join(root0, n), n));
   }
   return out0;
 }
@@ -3070,15 +3260,27 @@ function _resetListSessionsCache() { LIST_SESSIONS_CACHE = { at: 0, stamp: null,
 // 旧实现每请求都要枚举 475 个 artifact 才能回答"这些人是何时建的、谁派工的"——
 // 有了备忘，第二个请求起直接查表。
 const SUB_HEADER_MEMO = new Map();
-const SUB_HEADER_STATS = { memoHits: 0, memoWrites: 0, enumCalls: 0 };
+// `cut`（2026-09-15 有界化）如实记录这一段被截断/节流的原因，供调用方进 `degraded`：
+//   '' = 未截断｜'throttled' = 本轮在节流窗口内、未枚举｜'deadline' = 枚举到期限被截断
+const SUB_HEADER_STATS = { memoHits: 0, memoWrites: 0, enumCalls: 0, cut: '' };
 function _resetSubHeaderMemo() {
   SUB_HEADER_MEMO.clear();
   SUB_HEADER_STATS.memoHits = 0;
   SUB_HEADER_STATS.memoWrites = 0;
   SUB_HEADER_STATS.enumCalls = 0;
-}
-
-async function listSubagentStatusBySession(ctx, sid, knownIds) {
+  SUB_HEADER_STATS.cut = '';
+}
+
+async function listSubagentStatusBySession(ctx, sid, knownIds, opts) {
+  // 只认真 id：调用方若传进角色名（历史 bug，见 `memberAgentIds` 的注释），枚举分支会**永久**
+  // 认为"还有人查不到" ⇒ 每请求重枚举。这里再兜一道，防止未来又有人把角色名传进来。
+  const ids = (Array.isArray(knownIds) ? knownIds : []).filter(isAgentIdLike);
+  // 有界化（2026-09-15）：枚举整棵 sessions 树是最贵的一步（真机实测 2.4–3.6 s，且它是
+  // **全库**扫描）。调用方可以（a）在节流窗口内**禁止枚举**、（b）给一个期限。两者都不命中时
+  // 保持原行为（默认允许 + 无期限）。被挡住/截断时**不丢成员**：那些 id 只是没有 header ⇒
+  // 既有口径已如实显示为"细节不可得"（`hasTimestamp:false`），不假装 0。
+  const allowEnum = !(opts && opts.allowEnum === false);
+  const enumDeadlineAt = (opts && Number.isFinite(opts.enumDeadlineAt)) ? opts.enumDeadlineAt : Infinity;
   const root = sid ? await rootSessionId(ctx, sid) : '';
   let rows = [];
   if (root) {
@@ -3093,14 +3295,14 @@ async function listSubagentStatusBySession(ctx, sid, knownIds) {
   // Cross-session enrich: the run's registered agent ids may belong to a
   // DIFFERENT session (viewing run A from session B) — the live `agents`
   // registry still reports their status/model keyed by session id.
-  if (knownIds && knownIds.length) {
+  if (ids && ids.length) {
     try {
       const reg = (ctx && typeof ctx.get === 'function') ? ctx.get('agents') : null;
       if (reg && typeof reg.list === 'function') {
         const byId = new Map(rows.map((r) => [r.id, r]));
         for (const ag of reg.list() || []) {
           const aid = ag?.session?.header?.id;
-          if (!aid || byId.has(aid) || !knownIds.includes(aid)) continue;
+          if (!aid || byId.has(aid) || !ids.includes(aid)) continue;
           byId.set(aid, { id: aid, mode: 'continuable', label: '', activity: ag.status === 'running' ? 'running' : 'idle', model: ag?.options?.model || '' });
         }
         rows = [...byId.values()];
@@ -3114,7 +3316,7 @@ async function listSubagentStatusBySession(ctx, sid, knownIds) {
   //   第一轮：只有**真的缺人**才花这笔钱（旧实现无条件 listSessions()）；
   //   第二轮：缺的那些**先查 `SUB_HEADER_MEMO`**（已结束会话的 header 不可变 ⇒ 永久备忘），
   //           只有仍然未知的才去枚举 ⇒ 第二个请求起通常**零枚举**。
-  const missingIds = (knownIds || []).filter((id) => !rows.some((r) => r.id === id));
+  const missingIds = (ids || []).filter((id) => !rows.some((r) => r.id === id));
   if (missingIds.length) {
     const memoById = new Map(rows.map((r) => [r.id, r]));
     const stillUnknown = [];
@@ -3129,15 +3331,18 @@ async function listSubagentStatusBySession(ctx, sid, knownIds) {
     }
     rows = [...memoById.values()];
     if (stillUnknown.length) {
-      try {
+      if (!allowEnum) {
+        SUB_HEADER_STATS.cut = SUB_HEADER_STATS.cut || 'throttled';
+      } else try {
         const q = (ctx && typeof ctx.get === 'function') ? ctx.get('sessionQuery') : null;
         if (q && typeof q.listSessions === 'function') {
           const sessions = await cachedListSessions(q, await sessionsRootStamp());
           const byId = new Map(rows.map((r) => [r.id, r]));
           for (const rec of sessions || []) {
+            if (Date.now() > enumDeadlineAt) { SUB_HEADER_STATS.cut = 'deadline'; break; }
             const h = rec?.header || rec;
             const aid = h?.id;
-            if (!aid || byId.has(aid) || !knownIds.includes(aid)) continue;
+            if (!aid || byId.has(aid) || !ids.includes(aid)) continue;
             // ⚠️ header 里的 createdAt / parentSession / delegationDepth **必须带出来**。
             // 旧实现只取 id，把它们丢掉，导致面板上每个成员都是 createdAt=0 ⇒ 流转图
             // 判为「无创建时间记录，无法分批」，尽管会话日志第一行明明写着
@@ -3241,6 +3446,28 @@ const ROLE_READ_BUDGET_PER_REQUEST = 4;
 let ROLE_READS_LEFT = ROLE_READ_BUDGET_PER_REQUEST;
 /** 待解析队列（跨请求保留进度）：元素是子会话 id。 */
 let ROLE_PENDING = [];
+
+// ── 有界化策略（2026-09-15 第三轮）─────────────────────────────────────────────
+// 真机基线（30+ 子代理的重会话）：`people,feed` 单发 5.4–9.2 s，其中 subs 2.9–3.7 s、roles 2.4–5.5 s，
+// **两段都没有上限**。本轮的目标不是"更快"，而是"**有界**"：
+//   · subs  ：枚举整棵 sessions 树很贵 ⇒ 两次之间至少 N 秒（默认 30 s），窗口内不枚举；
+//   · roles ：读 MB 级子会话日志很贵且**不紧急** ⇒ 实时路径默认**不读**，未知角色如实显示为
+//             "待解析"（`rolesPending`），解析交给低频后台（每轮 ≤N 条、两次间隔 ≥N 秒）；
+//             已解析结果**永久缓存**（已结束会话的角色不可变）⇒ pending 单调下降并收敛到 0。
+// 纪律不变：截断一律进 `degraded`；"还没解析"（pending）与"解析不出来"（unresolved）仍是两个数。
+const SUBS_ENUM_MIN_INTERVAL_MS = Math.max(0, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_SUBS_ENUM_MIN_INTERVAL_MS) || 0) || 30000);
+const SUBS_ENUM_DEADLINE_MS = Math.max(50, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_SUBS_DEADLINE_MS) || 0) || 800);
+const ROLES_READ_MIN_INTERVAL_MS = Math.max(0, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_ROLES_MIN_INTERVAL_MS) || 0) || 30000);
+const ROLES_READ_PER_BURST = Math.max(1, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_ROLES_PER_BURST) || 0) || 1);
+const ROLES_READ_DEADLINE_MS = Math.max(50, Number((typeof process !== 'undefined' && process.env && process.env.DSH_EXPERT_TEAM_ROLES_DEADLINE_MS) || 0) || 600);
+let SUBS_ENUM_LAST_AT = 0;
+let ROLES_READ_LAST_AT = 0;
+const ROLE_READ_STATS = { cut: '' };
+/** 本轮允许枚举吗（节流窗口）？ */
+function subsEnumAllowed(now) { return (Number(now) - SUBS_ENUM_LAST_AT) >= SUBS_ENUM_MIN_INTERVAL_MS; }
+/** 本轮允许读几条角色日志（低频后台；0 = 如实显示"待解析"）。 */
+function roleReadAllowance(now) { return (Number(now) - ROLES_READ_LAST_AT) >= ROLES_READ_MIN_INTERVAL_MS ? ROLES_READ_PER_BURST : 0; }
+function _resetBoundedState() { SUBS_ENUM_LAST_AT = 0; ROLES_READ_LAST_AT = 0; ROLE_READ_STATS.cut = ''; SUB_HEADER_STATS.cut = ''; }
 /** /state 每次进来复位**本请求的读取额度**（队列进度**不**复位）。 */
 function resetRoleReadBudget() { ROLE_READS_LEFT = ROLE_READ_BUDGET_PER_REQUEST; }
 /**
@@ -3438,7 +3665,11 @@ async function workflowRuns(ctx, sid, subs) {
  * 结果是**恰好反了**——能解析的全部留空，解析不出的那批反而被下一段子会话日志兜底填上。
  * （2026-09-11 真实踩到：30 个子代理里只有 5 个有角色，正是 wfLabels 解析不出的那 5 个。）
  */
-async function resolveSubRoles(ctx, subs, wfLabels) {
+async function resolveSubRoles(ctx, subs, wfLabels, opts) {
+  // 有界化：调用方决定本轮最多读几条（0 = 只查便宜来源与缓存，缺的如实显示为"待解析"）
+  // 以及墙上期限；不传则保持原行为（每请求 ROLE_READ_BUDGET_PER_REQUEST 条、无期限）。
+  const maxReads = (opts && Number.isFinite(opts.maxReads)) ? opts.maxReads : ROLE_READ_BUDGET_PER_REQUEST;
+  const deadlineAt = (opts && Number.isFinite(opts.deadlineAt)) ? opts.deadlineAt : Infinity;
   const byId = new Map();
   for (const s of subs || []) { const id = String((s && s.id) || ''); if (id) byId.set(id, s); }
   // ① 便宜来源（自带 label / 父会话事件流 label）与已缓存结果 —— **不花预算、不读日志**
@@ -3458,14 +3689,18 @@ async function resolveSubRoles(ctx, subs, wfLabels) {
   //    这样 `deferred`（队列长度）只减不增，除非真的又新派了人 —— 旧实现每请求从零重算，
   //    预算永远喂给队首同几条，新派的人永远轮不到（实测 deferred 16 → 40）。
   syncRolePending(subs);
-  while (ROLE_READS_LEFT > 0 && ROLE_PENDING.length) {
+  let reads = 0;
+  while (reads < maxReads && ROLE_READS_LEFT > 0 && ROLE_PENDING.length) {
+    if (Date.now() > deadlineAt) { ROLE_READ_STATS.cut = 'deadline'; break; }
     const id = ROLE_PENDING.shift();
     if (SUB_ROLE_LOG_CACHE.has(id)) continue;
     const r = await roleFromChildLog(ctx, id);
     if (!SUB_ROLE_LOG_CACHE.has(id)) { ROLE_PENDING.unshift(id); break; } // 预算耗尽（未写缓存）⇒ 放回队首，下一轮继续
     const s = byId.get(id);
     if (s && r && !s.role) s.role = r;
+    reads += 1;
   }
+  if (reads) ROLES_READ_LAST_AT = Date.now();   // 本轮流过日志 ⇒ 进入节流窗口（下次至少 N 秒后）
   return subs;
 }
 // sub rows → Map<role, sub> (first match wins; unknown labels map to '' and
@@ -5039,7 +5274,7 @@ function warnLeadToolFaceOnce(status, detail) {
   LEAD_TOOLFACE_WARNED.add(status);
   console.warn(`[expert-team] lead 工具面**未**收窄（${status}）：${detail}`);
 }
-export const _live = { pushActivity, phaseAccountingViolations, loggedPhases, authorityViolations, WRITE_TRACER, createWriteTracer, formatConflict, summarizeTool, parseLogLine, roleOfSub, mapRoleToSub, membersFromState, buildRoleSubMap, resolveSubRoles, childSessionTiming, subHeaderIndex, sessionExists, SUB_HEADER_CACHE, workflowEventIndex, workflowChildLabels, workflowChildMeta, workflowRuns, WF_EVENT_CACHE, rememberSessionRun, sessionRunFor, runOwnerSession, SESSION_RUNS, parseTeamCommand, deriveMemberEntries, schemaViolations, runHealth, RUN_STALL_MS, scaffoldFingerprint, SCAFFOLD_REQUIRED, strandedTasks, settleStranded, IN_FLIGHT_STATUSES, normalizeCoverage, SCHEMA_WARN_SEEN, pushActivityEvent, DEFAULT_LIMITS, LIMITS, resolveLimits, capacityViolations, DEFAULT_ROUND_LIMITS, ROUND_LIMITS, ROUND_LIMIT_ENV, resolveRoundLimits, ROUND_LIMIT_OF_KIND, roundOf, isQualityTask, normTitle, roundLimitViolations, reworkLoopWriteGuard, mutateTasks, readStandingRules, appendStandingRule, rulesRun, scopeOverlapWarnings, applyTaskStatus, waitRun, eventFamily, verdictFromToken, normalizeRoleName, truncateCodepoints, filterRunScopedSubs, runCreatedAtMs, runLogTail, liveFiles, LIVE_FILES_CACHE, DEFAULT_ROLES, resolveTierGate, TIER_GATE_ENV, snapshotRun, parseStateSections, settingsPath, loadSettingsSync, currentSettings, limitsBaseFromSettings, roundLimitsBaseFromSettings, effectiveTierGate: () => TIER_GATE, ensureSkillInstalled, ensurePresetInstalled, uninstallInstalled, buildSkillRegistration, parseSkillMarkdown, PLUGIN_VERSION, INSTALL_STAMP, runtimeSkillRegistered: () => RUNTIME_SKILL_REGISTERED, agentScopedToolNames, warnLeadToolFaceOnce, resolveLeadToolFace, LEAD_TOOLFACE_ENV, effectiveLeadToolFace: () => LEAD_TOOLFACE, resolveLoopGuard, LOOP_GUARD_ENV, effectiveLoopGuard: () => LOOP_GUARD_ENABLED, resolveRosterDefaults, rosterSettings, createRun, watchScript, canvasPollMs, installHostSettings, hostValues, hostScope, hostSettingsNote, updateHostSettings, pickFileOnly, pickHostExpressible, buildHostSchema, hostBase, hostSchemaPaths, reapplySettingsDerived, currentSettings, mergeSettings, detectOptionalPlugins, OPTIONAL_PLUGINS, hintOptionalPluginsOnce, _resetOptionalHintOnce, scheduleOptionalPluginCheck, recheckOptionalPlugins, OPTIONAL_PROBE_DELAYS_MS, loaderEntryNames, hindsightToolReady, costMeterReady, listSubagentStatusBySession, cachedListSessions, _resetListSessionsCache, LIST_SESSIONS_TTL_MS, SUB_HEADER_MEMO, SUB_HEADER_STATS, _resetSubHeaderMemo, sessionsRootStamp, resetRoleReadBudget, roleReadBudgetSnapshot, syncRolePending, _resetRolePending, ROLE_READ_BUDGET_PER_REQUEST, ROLE_READ_LOG_CACHE: SUB_ROLE_LOG_CACHE };
+export const _live = { pushActivity, phaseAccountingViolations, loggedPhases, authorityViolations, WRITE_TRACER, createWriteTracer, formatConflict, summarizeTool, parseLogLine, roleOfSub, mapRoleToSub, membersFromState, memberAgentIds, isAgentIdLike, buildRoleSubMap, resolveSubRoles, childSessionTiming, subHeaderIndex, sessionExists, SUB_HEADER_CACHE, workflowEventIndex, workflowChildLabels, workflowChildMeta, workflowRuns, WF_EVENT_CACHE, rememberSessionRun, sessionRunFor, runOwnerSession, SESSION_RUNS, parseTeamCommand, deriveMemberEntries, schemaViolations, runHealth, RUN_STALL_MS, scaffoldFingerprint, SCAFFOLD_REQUIRED, strandedTasks, settleStranded, IN_FLIGHT_STATUSES, normalizeCoverage, SCHEMA_WARN_SEEN, pushActivityEvent, DEFAULT_LIMITS, LIMITS, resolveLimits, capacityViolations, DEFAULT_ROUND_LIMITS, ROUND_LIMITS, ROUND_LIMIT_ENV, resolveRoundLimits, ROUND_LIMIT_OF_KIND, roundOf, isQualityTask, normTitle, roundLimitViolations, reworkLoopWriteGuard, mutateTasks, readStandingRules, appendStandingRule, rulesRun, scopeOverlapWarnings, applyTaskStatus, waitRun, eventFamily, verdictFromToken, normalizeRoleName, truncateCodepoints, filterRunScopedSubs, runCreatedAtMs, runLogTail, liveFiles, LIVE_FILES_CACHE, DEFAULT_ROLES, resolveTierGate, TIER_GATE_ENV, snapshotRun, parseStateSections, listRunsInWorkspace, runsIndexPath, RUNS_INDEX_STATS, _resetRunsIndex, settingsPath, loadSettingsSync, currentSettings, limitsBaseFromSettings, roundLimitsBaseFromSettings, effectiveTierGate: () => TIER_GATE, ensureSkillInstalled, ensurePresetInstalled, uninstallInstalled, buildSkillRegistration, parseSkillMarkdown, PLUGIN_VERSION, INSTALL_STAMP, runtimeSkillRegistered: () => RUNTIME_SKILL_REGISTERED, agentScopedToolNames, warnLeadToolFaceOnce, resolveLeadToolFace, LEAD_TOOLFACE_ENV, effectiveLeadToolFace: () => LEAD_TOOLFACE, resolveLoopGuard, LOOP_GUARD_ENV, effectiveLoopGuard: () => LOOP_GUARD_ENABLED, resolveRosterDefaults, rosterSettings, createRun, watchScript, canvasPollMs, installHostSettings, hostValues, hostScope, hostSettingsNote, updateHostSettings, pickFileOnly, pickHostExpressible, buildHostSchema, hostBase, hostSchemaPaths, reapplySettingsDerived, currentSettings, mergeSettings, detectOptionalPlugins, OPTIONAL_PLUGINS, scheduleEffortPreflight, _resetEffortPreflight, effortPreflightPlan, declaredEffortsFromPresetSource, hintOptionalPluginsOnce, _resetOptionalHintOnce, scheduleOptionalPluginCheck, recheckOptionalPlugins, OPTIONAL_PROBE_DELAYS_MS, loaderEntryNames, hindsightToolReady, costMeterReady, listSubagentStatusBySession, cachedListSessions, _resetListSessionsCache, LIST_SESSIONS_TTL_MS, SUB_HEADER_MEMO, SUB_HEADER_STATS, _resetSubHeaderMemo, sessionsRootStamp, resetRoleReadBudget, roleReadBudgetSnapshot, syncRolePending, _resetRolePending, ROLE_READ_BUDGET_PER_REQUEST, SUBS_ENUM_MIN_INTERVAL_MS, SUBS_ENUM_DEADLINE_MS, ROLES_READ_MIN_INTERVAL_MS, ROLES_READ_PER_BURST, ROLES_READ_DEADLINE_MS, subsEnumAllowed, roleReadAllowance, ROLE_READ_STATS, _resetBoundedState, ROLE_READ_LOG_CACHE: SUB_ROLE_LOG_CACHE };
 
 export function apply(ctx, config) {
   // 留一份 config：设置在运行时改变（官方面板 / 浮层）时要**用同一份 config** 重算上限与档位门，
@@ -5089,6 +5324,8 @@ export function apply(ctx, config) {
   // 里还没有它们 ⇒ 已装且可用的插件会被误判成"已安装但当前未就绪"（2026-09-15 真实假警报）。
   // 现在改为**就绪后重探**（有界延迟 + `ctx.inject` 事件驱动，见 scheduleOptionalPluginCheck）。
   scheduleOptionalPluginCheck(ctx);
+  // D 项：会话模型 effort 预检（缺 reasoningEfforts ⇒ 提前一行告警，不阻断）
+  scheduleEffortPreflight(ctx);
   void loadSessionRuns(); // session→run memory for overlay auto-select
   ctx.commands.register({
     name: 'team',
@@ -5191,6 +5428,23 @@ export function apply(ctx, config) {
         ctx.on('tools/pre-execute', ownershipGate);
       } catch { /* 门禁挂不上 ⇒ 退回纯协议；绝不让它影响插件加载或工具调用 */ }
 
+      // ── R1 绕过检测（2026-09-15）：**只报不拦**。R1 门禁只覆盖 write/edit；持 bash 的角色
+      //    可以 `cat > SPEC.md` 绕过 —— 静默绕过违背本仓纪律，但静态判断 bash 写目标不可靠
+      //    （重定向/变量/子命令），一旦误判就是把正常命令判成越权。⇒ 折中：**留痕**，用真实命中
+      //    频率决定以后是否收紧。口径与"宁可漏报"的理由写在 `lib/artifact-redirect-watch.js` 文件头。
+      try {
+        const knownArtifacts = new Set([...ARTIFACT_TEMPLATES, ...Object.keys(ARTIFACT_OWNERS)]);
+        const redirectWatch = createArtifactRedirectWatcher({
+          knownArtifacts,
+          cwdFor: (exec) => cwdFromSession(ctx, exec?.agent?.session?.header?.id || exec?.agent?.session?.id),
+          teamRootFor: (cwd) => teamRoot(cwd),
+          onEvent: (type, payload) => {
+            try { console.warn('[expert-team] ' + type, JSON.stringify(payload)); } catch { /* 观测失败不影响工具 */ }
+          },
+        });
+        ctx.on('tools/post-execute', redirectWatch);
+      } catch { /* 观测器挂不上 ⇒ 只是少一条留痕；绝不影响插件加载或工具调用 */ }
+
       // ── C 线第 16 项（收窄版）：**振荡检测**。同工具重复调用由宿主
       //    `@deepseek-ai/dsh-repeat-tool-reminder` 负责（dsh-base 已启用，thresholds [3,5,8]），
       //    不重写；这里只补它明确声明不覆盖的那一种 —— A→B→A→B 在两方案间来回。
@@ -5419,19 +5673,36 @@ export function apply(ctx, config) {
                   ? { sid: sel.stateOwnerSession, ownerResolved: true }
                   : runOwnerSession(sel.runId);
                 let peopleSid = owner.sid || sid;
-                const knownIds = [...membersFromState(sel.stateMembers).byRole.values()];
+                // ⚠️ **只能用 id**（`memberAgentIds`，不是 `byRole` 的 values 视图）：后者混着角色名，
+                // 会让"还有谁查不到"永久非空 ⇒ 每请求重枚举 475 个 artifact（2026-09-15 真机定位）。
+                const knownIds = memberAgentIds(sel.stateMembers);
                 // 只有 people 分节才解析人员：这一步要枚举子会话 durable 清单（重会话里这是整条链上
                 // 最大的一块）。首屏用 summary 时不付这个成本 —— `agents` 返回空数组，
                 // 由客户端 `sections` 字段知道自己拿的是"摘要"，UI 如实显示"正在加载成员"。
                 // `feed` 也必须先有 subs（它按子会话遍历活动缓存）。若只想要 feed 却跳过枚举，
                 // feed 会**静默变空** —— 那正是本仓最忌讳的"两种零分不清"（缺块 ≠ 空数据）。
                 const needSubs = want('people') || want('feed');
-                let subs = needSubs ? await listSubagentStatusBySession(ctx, peopleSid, knownIds) : [];
+                // 有界化：本轮是否允许枚举（节流窗口）+ 枚举期限；结果经 SUB_HEADER_STATS.cut 上报。
+                const subsStartedAt = Date.now();
+                const allowEnumNow = subsEnumAllowed(subsStartedAt);
+                SUB_HEADER_STATS.cut = '';
+                const subsOpts = { allowEnum: allowEnumNow, enumDeadlineAt: subsStartedAt + SUBS_ENUM_DEADLINE_MS };
+                let subs = needSubs ? await listSubagentStatusBySession(ctx, peopleSid, knownIds, subsOpts) : [];
                 // 归属会话拿不到人时退回请求会话（否则面板整块空掉），但**如实标注**这不是归属会话的人。
                 if (needSubs && !subs.length && peopleSid !== sid) {
-                  const fallback = await listSubagentStatusBySession(ctx, sid, knownIds);
+                  const fallback = await listSubagentStatusBySession(ctx, sid, knownIds, subsOpts);
                   if (fallback.length) { subs = fallback; peopleSid = sid; }
                 }
+                // 有界化上报：本轮流过枚举 ⇒ 进入节流窗口；被节流/被期限截断一律**如实**进 degraded
+                // （缺块 ≠ 空数据：被挡住的 id 只是没有 header，成员本身不丢）。
+                if (needSubs && allowEnumNow) SUBS_ENUM_LAST_AT = Date.now();
+                // ⚠️ 噪声纪律：**节流不是失败**，不能每轮都进 `degraded`（节流窗口内每次轮询都会命中
+                // ⇒ 面板会长期挂一个降级标记，把真告警一起降权）。"某些成员细节不可得"这一事实由
+                // `subsPending` 诚实表达（与 `rolesPending` 对称）；只有"开始枚举却被期限截断"算
+                // **部分结果**，才进 `degraded`。
+                const idsReal = (Array.isArray(knownIds) ? knownIds : []).filter(isAgentIdLike);
+                const subsPending = needSubs ? idsReal.filter((id) => !subs.some((r) => r.id === id)).length : 0;
+                if (needSubs && SUB_HEADER_STATS.cut === 'deadline') degraded.push('subs:deadline');
                 // 供面板如实提示：resolve=false 时人员名单可能来自错误的会话
                 sel.peopleSession = peopleSid;
                 sel.peopleSessionIsOwner = peopleSid === (owner.sid || '');
@@ -5456,13 +5727,21 @@ export function apply(ctx, config) {
                 //   ① 只在 people 分节里做；② 硬上限 `MAX_ROLE_SUBS`（超限只解析前 N 条）。
                 // 被上限挡住的条数**如实进 `degraded`**；"还没解析"（rolesDeferred，队列长度）与
                 // "解析不出来"（unresolved）仍然分得开（两种零可区分）。
+                // 有界化：角色解析移出实时路径 —— 默认**不读**（缺的如实显示为"待解析"），
+                // 只在节流窗口到点后读 ≤ROLES_READ_PER_BURST 条，并给墙上期限。
+                const rolesAllowance = roleReadAllowance(Date.now());
+                const rolesOpts = { maxReads: rolesAllowance, deadlineAt: Date.now() + ROLES_READ_DEADLINE_MS };
+                ROLE_READ_STATS.cut = '';
                 if (want('people')) {
                   if (subs.length > MAX_ROLE_SUBS) {
-                    await resolveSubRoles(ctx, subs.slice(0, MAX_ROLE_SUBS), wfLabels);
+                    await resolveSubRoles(ctx, subs.slice(0, MAX_ROLE_SUBS), wfLabels, rolesOpts);
                     degraded.push('roles:' + (subs.length - MAX_ROLE_SUBS));
                   } else {
-                    await resolveSubRoles(ctx, subs, wfLabels);
+                    await resolveSubRoles(ctx, subs, wfLabels, rolesOpts);
                   }
+                  // 期限截断如实上报；**节流不报 degraded** —— 它不是失败，而是"待解析"这一诚实
+                  // 状态，由 `rolesPending` 表达（否则每请求都刷 degraded，把告警变成噪声）。
+                  if (ROLE_READ_STATS.cut === 'deadline') degraded.push('roles:deadline');
                 }
                 mark('roles');
                 // R12 + R13 + R17（F-1 · P0 跨 run 成员串号）：**显示与写盘都只吃过滤后的 `subById`**。
@@ -5663,11 +5942,11 @@ export function apply(ctx, config) {
                 persistSessionRuns();
                 mark('tail');
                 // profile 只在 DSH_EXPERT_TEAM_STATE_PROFILE=1 时出现（默认不含该字段，
-                // 线上响应体不变）；rolesDeferred = 本轮因预算被推迟的子会话日志读取条数，
+                // 线上响应体不变）；rolesPending = "**还没解析**"的子会话条数（与本轮是否节流无关），
                 // 让调用方能把"还没解析"与"解析不出来"分开（两种零可区分）。
                 const budget = roleReadBudgetSnapshot();
                 json(200, Object.assign(
-                  { ok: true, runs, workspaces, cwd, agents: sel.agents, rolesDeferred: budget.deferred },
+                  { ok: true, runs, workspaces, cwd, agents: sel.agents, rolesPending: budget.deferred, subsPending },
                   sel,
                   // 新增字段（只在相关时出现，默认负载与老客户端保持不变）：
                   //   sections —— 显式要了分节时，告诉调用方"这份负载包含哪些块"（缺的块 ≠ 空数据，