@yangdcm/dsh-expert-team 1.3.14 → 1.3.16

package/lib/artifact-redirect-watch.js

@@ -0,0 +1,118 @@
+/**
+ * R1 绕过检测：`bash` / `pwsh` 里"重定向写进 run 工件"的**只报不拦**观测器（2026-09-15）。
+ *
+ * ── 为什么需要它（而不是把它也做成门禁）────────────────────────────────────
+ * R1 硬门禁（`lib/artifact-ownership.js`）只覆盖 **`write` / `edit`** 通道。preset 里
+ * `backend` / `frontend` / `researcher` / `qa` / `dba` / `devops` **持 `bash`**，理论上可以
+ * `cat > SPEC.md` 绕过门禁。**静默绕过**违背本仓纪律（"失败要出声"），但**首版刻意不做阻断**：
+ *   · `bash` 的写目标可以是重定向、`tee`、变量、子命令替换 —— 静态判断**不可靠**；
+ *   · 一旦误判，代价是"把正常命令判成越权"（比漏报更伤，本仓有前车之鉴：门禁变成故障源）。
+ * ⇒ 折中：**只留痕**，用真实运行里的命中频率来决定以后要不要收紧。
+ *
+ * ── 口径（保守，宁可漏报）────────────────────────────────────────────────
+ * 只有同时满足下面三条才算命中：
+ *   ① 工具是 `bash` / `pwsh`；
+ *   ② 命令里出现**明显的写目标**：`>` / `>>` / `tee [-a]` 之后紧跟一个路径 token；
+ *   ③ 该路径解析后**恰好是** `<team 根>/<runId>/<文件名>`（沿用 `runScopedTarget` 的两段口径，
+ *      更深的子目录 / 工作区代码 / `/tmp` / `/dev/null` 一律不命中），且文件名属于**已知工件**。
+ *
+ * 本监听器**绝不**改动结果、**绝不**抛错（沿用 `interception.js` 的纪律：
+ * 监听器一旦抛错会被宿主收敛为工具失败，2026-09-12 出过全工具瘫痪事故）。
+ */
+
+import { resolve, basename } from 'node:path';
+import { runScopedTarget } from './interception.js';
+
+/** shell 类工具（R1 门禁覆盖不到的那些）。 */
+export const SHELL_WRITE_TOOLS = Object.freeze(new Set(['bash', 'pwsh']));
+
+/** 去掉包裹的引号（`"a b"` / `'a b'`），保留原样其余内容。 */
+function unquote(tok) {
+  const s = String(tok || '').trim();
+  if (s.length >= 2 && ((s[0] === '"' && s[s.length - 1] === '"') || (s[0] === "'" && s[s.length - 1] === "'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+/**
+ * 从命令串里提取**候选写目标**（纯函数、保守）。
+ * 只认两种形态：`>` / `>>`（可带 fd 前缀如 `2>`）与 `tee [-a] <path>`。
+ * 变量 / 命令替换 / 通配符**不解析**（拿不准就漏报 —— 这是本文件的既定口径）。
+ */
+export function extractWriteTargets(command) {
+  const cmd = String(command || '');
+  const out = [];
+  const push = (raw) => {
+    const t = unquote(raw);
+    if (!t) return;
+    if (t === '/dev/null' || t === '/dev/stdout' || t === '/dev/stderr') return;
+    if (/[$`*?]/.test(t)) return;      // 含变量/替换/通配 ⇒ 不解析（宁可漏报）
+    if (t.startsWith('&')) return;     // `&>` 的 fd 形式交给下一条规则
+    out.push(t);
+  };
+  // `>` / `>>`（含 `1>`, `2>>`, `&>`），后跟一个 token
+  const redir = /(?:\d?&?>>?|&>>?)\s*("[^"]+"|'[^']+'|[^\s;|&<>()]+)/g;
+  let m;
+  while ((m = redir.exec(cmd)) !== null) push(m[1]);
+  // `tee [-a] <path>`：只取**第一个**路径参数（`tee a b` 少见，且多写不算漏报）
+  const tee = /(?:^|[\s;|&(])tee(?:\s+-[a-zA-Z]+)*\s+("[^"]+"|'[^']+'|[^\s;|&<>()]+)/g;
+  while ((m = tee.exec(cmd)) !== null) push(m[1]);
+  return out;
+}
+
+/**
+ * 判定命令里是否**明显**写向 `<teamRoot>/<runId>/<已知工件>`。
+ * @returns {{abs:string, runId:string, base:string}|null}
+ */
+export function detectArtifactRedirect(command, { cwd, teamRoot, knownArtifacts } = {}) {
+  if (!cwd || !teamRoot) return null;
+  const known = knownArtifacts instanceof Set ? knownArtifacts : new Set(knownArtifacts || []);
+  if (!known.size) return null;
+  for (const raw of extractWriteTargets(command)) {
+    let abs;
+    try { abs = resolve(cwd, raw); } catch { continue; }
+    const scoped = runScopedTarget(abs, teamRoot);   // 只认 `<teamRoot>/<runId>/<文件名>` 两段
+    if (!scoped) continue;
+    const base = basename(abs);
+    if (!known.has(base)) continue;
+    return { abs, runId: scoped.runId, base };
+  }
+  return null;
+}
+
+/**
+ * 创建 `tools/post-execute` 监听器（**纯观测**：不改结果、不阻断、不抛错）。
+ * deps：`knownArtifacts`（已知工件文件名集合，由调用方从**单一真源**传入）、
+ *       `cwdFor(exec)`、`teamRootFor(cwd)`、`onEvent(type, payload)`、可选 `warn(line)`。
+ */
+export function createArtifactRedirectWatcher({ knownArtifacts, cwdFor, teamRootFor, onEvent, warn } = {}) {
+  const known = knownArtifacts instanceof Set ? knownArtifacts : new Set(knownArtifacts || []);
+  const emit = typeof onEvent === 'function' ? onEvent : () => {};
+  const say = typeof warn === 'function' ? warn : (line) => console.warn(line);
+  return async function artifactRedirectWatcher(exec, result, next) {
+    // 与 `interception.js` 同契约：签名是 (exec, result, next)；next 不是函数就降级为不干涉。
+    if (typeof next !== 'function') return { kind: 'accept' };
+    const downstream = await next();
+    try {
+      const name = String((exec && exec.name) || '');
+      if (!SHELL_WRITE_TOOLS.has(name)) return downstream;
+      const args = (exec && exec.arguments) || {};
+      const command = String(args.command || args.cmd || args.script || '');
+      if (!command) return downstream;
+      const cwd = typeof cwdFor === 'function' ? cwdFor(exec) : '';
+      if (!cwd) return downstream;
+      const teamRoot = typeof teamRootFor === 'function' ? teamRootFor(cwd) : '';
+      if (!teamRoot) return downstream;
+      const hit = detectArtifactRedirect(command, { cwd, teamRoot, knownArtifacts: known });
+      if (!hit) return downstream;
+      try {
+        say(`[expert-team] R1 绕过检测：${name} 写入 run 工件 ${hit.abs}（write/edit 门禁覆盖不到；仅留痕，不阻断）`);
+      } catch { /* 打印失败也不能影响工具调用 */ }
+      emit('artifact-redirect-bypass', { tool: name, runId: hit.runId, base: hit.base });
+    } catch (e) {
+      try { emit('artifact-redirect-watch-error', { error: String((e && e.message) || e) }); } catch { /* ignore */ }
+    }
+    return downstream;
+  };
+}

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,8 +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, 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';
@@ -1058,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 */ } }
@@ -1148,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)));
@@ -1684,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 : []) {
@@ -1712,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);
     }
@@ -2690,6 +2782,60 @@ function cwdFromSession(ctx, sessionId) {
   } catch { return undefined; }
 }
 
+/**
+ * 由 `exec` 的**调用者**解析出角色（R1 归属门禁与并发写留痕**共用同一份**解析）。
+ *
+ * 来源：`STATE.members` 的 `<agentSessionId>:<role>` 行 —— 宿主在派工时自动登记
+ *（"派工即登记"），所以这里不需要猜 label/事件流。
+ * **认不出就返回空串**：调用方据此 fail-open（宁可漏拦，不可误伤），绝不臆造角色。
+ * 角色可带后缀（`frontend-F4`、`reviewer-R1`）——原样返回，归一由查表一侧负责。
+ *
+ * @param ctx - 插件 ctx（用 ctx.get('sessions') 反查 cwd）
+ * @param exec - 工具执行记录（`exec.agent.session` 给出调用者会话 id）
+ * @param runId - 目标 run（STATE.json 所在目录名）
+ * @returns {Promise<string>} 角色串；解析不出返回 `''`。
+ */
+async function roleOfAgent(ctx, exec, runId) {
+  const sid = String(exec?.agent?.session?.id || exec?.agent?.session?.header?.id || '');
+  if (!sid || !runId) return '';
+  try {
+    const cwd = cwdFromSession(ctx, exec?.agent?.session?.header?.id || sid)
+      || String(exec?.agent?.session?.header?.cwd || '');
+    if (!cwd) return '';
+    const st = await readJsonSafe(join(teamRoot(cwd), runId, 'STATE.json'));
+    for (const m of (st && Array.isArray(st.members)) ? st.members : []) {
+      const str = String(m || '');
+      const i = str.indexOf(':');
+      if (i > 0 && str.slice(0, i) === sid) return str.slice(i + 1);
+    }
+  } catch { /* 读不到 ⇒ 空串（fail-open） */ }
+  return '';
+}
+
+/**
+ * 目标文件**是否已存在** —— R1 门禁的"创建放行、覆写才拦"就靠这一个判据（不需要读内容）。
+ *
+ * 与读文本同一套纪律：**宿主 fs 优先**（run 目录可能落在宿主虚拟路径体系里），拿不到再退 node。
+ * 返回三态：`true`（在）/ `false`（明确不存在）/ `undefined`（**查不到**）。
+ * 调用方必须把 `undefined` 当"不知道"而放行并留痕 —— 把"查不到"当成"不存在"会让门禁
+ * 在最需要它的时候静默失效（本轮反复强调的"两种零要分得清"）。
+ */
+async function pathExistsFor(ctx, abs) {
+  try {
+    const hostFs = typeof ctx.get === 'function' ? ctx.get('fs') : null;
+    if (hostFs && typeof hostFs.stat === 'function' && typeof hostFs.resolve === 'function') {
+      const resolvedTarget = await hostFs.resolve(abs);
+      try {
+        const st = await hostFs.stat(resolvedTarget);
+        if (st) return true;
+        // 宿主明确说"没有"：再用 node 复核一次（宿主实现语义可能不同，宁可多问一次）
+      } catch { /* 宿主抛错 ⇒ 交给 node */ }
+    }
+  } catch { /* 宿主解析失败 ⇒ 交给 node */ }
+  try { await stat(abs); return true; }
+  catch (e) { return (e && e.code === 'ENOENT') ? false : undefined; }
+}
+
 // Pick the most recently updated run under <cwd>/team.
 async function pickLatestRun(cwd) {
   const root = teamRoot(cwd);
@@ -2764,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;
 }
@@ -3024,6 +3269,9 @@ function _resetSubHeaderMemo() {
 }
 
 async function listSubagentStatusBySession(ctx, sid, knownIds) {
+  // 只认真 id：调用方若传进角色名（历史 bug，见 `memberAgentIds` 的注释），枚举分支会**永久**
+  // 认为"还有人查不到" ⇒ 每请求重枚举。这里再兜一道，防止未来又有人把角色名传进来。
+  const ids = (Array.isArray(knownIds) ? knownIds : []).filter(isAgentIdLike);
   const root = sid ? await rootSessionId(ctx, sid) : '';
   let rows = [];
   if (root) {
@@ -3038,14 +3286,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()];
@@ -3059,7 +3307,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 = [];
@@ -3082,7 +3330,7 @@ async function listSubagentStatusBySession(ctx, sid, knownIds) {
           for (const rec of sessions || []) {
             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 ⇒ 流转图
             // 判为「无创建时间记录，无法分批」，尽管会话日志第一行明明写着
@@ -4984,7 +5232,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, ROLE_READ_LOG_CACHE: SUB_ROLE_LOG_CACHE };
 
 export function apply(ctx, config) {
   // 留一份 config：设置在运行时改变（官方面板 / 浮层）时要**用同一份 config** 重算上限与档位门，
@@ -5034,6 +5282,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',
@@ -5094,20 +5344,12 @@ export function apply(ctx, config) {
         },
         // 并发写留痕（设计稿 §十二 第 3 步）：写者身份 = 会话 id + 从 `STATE.members`
         //（格式就是 `<agentSessionId>:<role>`）解出的角色。**解不出角色就如实退到会话 id，不编造角色。**
+        // 写者身份 = 会话 id + 角色。**角色解析与 R1 门禁共用 `roleOfAgent`**
+        //（两处各写一遍口径迟早漂移：一处认得出、另一处认不出）。
         whoFor: async (exec, target) => {
           const sid = String(exec?.agent?.session?.id || exec?.agent?.session?.header?.id || '');
           if (!sid) return '';
-          let role = '';
-          try {
-            const cwd = cwdFromSession(ctx, exec?.agent?.session?.header?.id || sid)
-              || String(exec?.agent?.session?.header?.cwd || '');
-            const st = cwd ? await readJsonSafe(join(teamRoot(cwd), target.runId, 'STATE.json')) : null;
-            for (const m of (st && Array.isArray(st.members)) ? st.members : []) {
-              const str = String(m || '');
-              const i = str.indexOf(':');
-              if (i > 0 && str.slice(0, i) === sid) { role = str.slice(i + 1); break; }
-            }
-          } catch { /* 读不到就退到会话 id */ }
+          const role = await roleOfAgent(ctx, exec, target.runId);
           return role ? `${role}#${sid.slice(0, 6)}` : `session:${sid.slice(0, 6)}`;
         },
         writeTracer: WRITE_TRACER,
@@ -5121,6 +5363,46 @@ export function apply(ctx, config) {
       });
       ctx.on('tools/post-execute', boundary);
 
+      // ── R1 工件归属**硬门禁**（2026-09-15）：把"工件由产出它的角色自己落盘"从**协议约定**
+      //    升级成**可执行的门禁**。挂在 `tools/pre-execute`（**写盘之前**）而不是 post：
+      //    判据是"**创建放行、覆写才拦**"——只需一次存在性查询、不读内容，因此拦得住；
+      //    而内容级的台账/边界校验依赖已落盘内容，继续留在上面的 post-execute，两者分工。
+      //    语义、表格真源与诚实边界（只覆盖 write/edit 通道；持 bash 的角色仍可能绕过）
+      //    全部写在 `lib/artifact-ownership.js` 的文件头，别在这里复制一份。
+      try {
+        const ownershipGate = createOwnershipGate({
+          cwdFor: (exec) => cwdFromSession(ctx, exec?.agent?.session?.header?.id || exec?.agent?.session?.id),
+          teamRootFor: (cwd) => teamRoot(cwd),
+          statusFor: async (runId, cwd) => {
+            const st = await readJsonSafe(join(teamRoot(cwd), runId, 'STATE.json'));
+            return String((st && st.status) || '');
+          },
+          roleFor: (exec, runId) => roleOfAgent(ctx, exec, runId),
+          existsFor: (abs) => pathExistsFor(ctx, abs),
+          onEvent: (type, payload) => {
+            try { console.warn(`[expert-team] ${type}`, JSON.stringify(payload)); } catch { /* 观测失败不影响工具 */ }
+          },
+        });
+        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 在两方案间来回。
@@ -5349,7 +5631,9 @@ 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 如实显示"正在加载成员"。