dsh-plugin-t-expert 0.3.46 → 0.3.70

package/lib/index.js

@@ -158,14 +158,21 @@ export const SETTINGS_NAMESPACE = NS;
 export const UNKNOWN_SLUG_ERROR_CODE = "tTeam/unknown-slug";
 
 
+/** 「默认全部启用」的当前策略版本；把它 +1 即对所有用户重新播种一次（见 seedDefaultEnabled）。 */
+const ENABLED_SEED_VERSION = 1;
+
 const settingsSchema = schema.object({
   enabled: schema.array(schema.string()).default([]),
+  /** 兼容位：早期实现用的「已播种」布尔标记。幂等判据已改用 enabledSeedVersion，保留它只为不弄坏已写入的旧数据。 */
+  enabledSeeded: schema.boolean().default(false),
   /**
-   * 首次运行是否已把「默认全部启用」写进 enabled。见 seedDefaultEnabled：
-   * 只在「从未播种且名单为空」时把全部可用 slug 写一次，之后用户手动启用/禁用就不再动 ——
-   * 这样默认是「全启用」，但用户显式清空也绝不会被下次启动覆盖。
+   * 「默认全部启用」已按哪一版策略播种过。见 seedDefaultEnabled。
+   *
+   * 为什么用版本号而不是布尔：策略本身会演进，而布尔是一次性的。早期实现是「只在 enabled 为空时播种」
+   * 且播完就把布尔置 true —— 于是「早就手动启用过一部分」的老用户永远拿不到默认值（用户实测报过），
+   * 而且置了 true 之后连改逻辑都救不回来。换成版本号后，+1 就能对所有人重新播种一次。
    */
-  enabledSeeded: schema.boolean().default(false),
+  enabledSeedVersion: schema.number().default(0),
   /** 是否自动显示右上角的任务徽章（界面偏好，关掉后只在输入区浮层里手动查看）。 */
   showTaskBadge: schema.boolean().default(true),
   /**
@@ -410,7 +417,7 @@ export function apply(ctx, config) {
         return;
       }
       scope = settingsService.register(SETTINGS_NAMESPACE, settingsSchema, {
-        base: { enabled: [], enabledSeeded: false, showTaskBadge: true, showScheduleButton: true, showActivePulse: true },
+        base: { enabled: [], enabledSeeded: false, enabledSeedVersion: 0, showTaskBadge: true, showScheduleButton: true, showActivePulse: true },
         applies: "live",
         validate: (value) => {
           const list = value?.enabled;
@@ -571,27 +578,28 @@ export function apply(ctx, config) {
     }
   }
   /**
-   * 首次运行把「默认全部启用」落到 enabled 名单上。
+   * 按当前策略把「默认全部启用」落到 enabled 名单上（同一策略版本对同一用户只做一次）。
    *
-   * enabled 是白名单，缺省 [] 本意是"一个都没启用"，但这让新装用户得逐个开关 323 个专家。
-   * 改成"默认全启用"后，又不能简单地"enabled 为空就回填"——那样用户以后想清空（逐个关掉）
-   * 会被每次启动覆盖。所以用 sentinel 键 enabledSeeded 标记"已播种"：
-   * 只在「从未播种 且 名单为空」时把全部可用 slug 写一次；名单非空说明用户已手动启用过，只补标记。
+   * enabled 是白名单，缺省 [] 本意是"一个都没启用"，这让新装用户得逐个开关 323 个专家。
+   * 现在只要还没按当前策略播种过，就把**全部可用专家**写进 enabled —— 不再看 enabled 是否为空：
+   * "非空"并不等于用户刻意挑过（早期版本留下的部分记录同样非空），拿它当挡箭牌会让老用户永远
+   * 停在部分启用（用户实测报过）。用户之后自己的启用/禁用不会被覆盖 —— 那时版本号已经追上来了。
    */
   async function seedDefaultEnabled() {
     if (settingsService === undefined) return;
     const state = scope?.get?.();
-    if (state === undefined || state.enabledSeeded === true) return;
-    const current = (state.enabled ?? []).filter((value) => typeof value === "string");
-    // 名单非空 = 用户已经手动启用过：不再覆盖，只补 sentinel。
-    const nextEnabled = current.length > 0 ? current : usable().map((expert) => expert.slug);
-    if (nextEnabled.length === 0) return; // 名册残缺（既无名单也无专家），别乱写
+    if (state === undefined || (state.enabledSeedVersion ?? 0) >= ENABLED_SEED_VERSION) return;
+    const nextEnabled = usable().map((expert) => expert.slug);
+    // 名册残缺（例如分区目录暂时读不到）时绝不写：否则等于用一份空名单把用户的启用项抹掉。
+    if (nextEnabled.length === 0) return;
     try {
       await settingsService.mutate(SETTINGS_NAMESPACE, [
         { op: "set", path: ["enabled"], value: nextEnabled },
+        // 老键一并置 true：保持它在语义上的"已播种"，也免得多版本并存时两边打架。
         { op: "set", path: ["enabledSeeded"], value: true },
+        { op: "set", path: ["enabledSeedVersion"], value: ENABLED_SEED_VERSION },
       ], revision());
-      if (current.length === 0) ctx.logger?.info?.("[t-team] 首次运行：已默认启用全部专家");
+      ctx.logger?.info?.(`[t-team] 已按默认策略 v${ENABLED_SEED_VERSION} 启用全部 ${nextEnabled.length} 位专家`);
     } catch (error) {
       // 写不进（并发 / 服务暂不可用）不致命：下次 ensureReady 还会再试。
       ctx.logger?.warn?.(`[t-team] 默认启用全部专家写入失败：${String(error)}`);
@@ -1542,7 +1550,13 @@ export function apply(ctx, config) {
   // 为什么要在这里重挂：解析是异步的，而引擎首挂是同步的 —— 宿主真把符号换成非全局符号时，
   // 首挂那一刻守卫按旧键找不到函数（B-1 硬闸门 → 引擎降级）。解析落地后立刻用权威键重挂一次，
   // 引擎就能起来，用户不必重启 DSH。**只有换了口径才重挂**：常态（键没变）一行都不做。
+  // 审计修复（#2）：这个 promise 是 fire-and-forget，可能晚到「插件已经卸载」之后才落定，
+  // 届时在已死 fiber 上 reloadEngine（ctx.plugin）会重挂一个不受任何 fiber 管辖的引擎。
+  // 用 disposed 守卫让晚到的回调变成 no-op。
+  let disposed = false;
+  ctx.effect(() => () => { disposed = true; }, "t-team: authority-dispose-guard");
   void resolveHarnessAuthority().then((authority) => {
+    if (disposed) return;
     refreshHarnessReport();
     if (authority.changed !== true) return;
     ctx.logger?.warn?.(`[t-team] 宿主投递符号换了口径（权威符号：${String(authority.deliver)}），已改用权威符号并重挂团队引擎。`);
@@ -1577,6 +1591,19 @@ export function apply(ctx, config) {
   });
   ctx.reflect.provide(SQUAD_SERVICE, squads);
 
+  // P0 启动期对账：升级后 teams.json 补进新小队、但 t-team.config.json 是 DERIVED 文件不更新，
+  // 会变成「/t 列得出、引擎建不了」。异步重编译 + 热重载（execFile 不阻塞事件循环），
+  // 失败只告警不打断插件加载。
+  void squads.resync().then((result) => {
+    if (result.rebuilt === true) {
+      ctx.logger?.info?.(`[t-team] 启动期小队对账：${result.detail}`);
+    } else if (result.ok === false) {
+      ctx.logger?.warn?.(`[t-team] 启动期小队对账失败：${result.detail}`);
+    }
+  }).catch((error) => {
+    ctx.logger?.warn?.(`[t-team] 启动期小队对账异常：${error instanceof Error ? error.message : String(error)}`);
+  });
+
   // ---- 团队运行服务（设置页「团队」标签用；复用引擎的快照与停止实现）----
   // 状态目录**只有一个来源**：`config.stateDir`（同时也是挂给引擎的那个值，见上面的 ctx.plugin）。
   // 曾经这里读的是数据文件 `t-team.config.json` 的 stateDir（`agent-teams.config.json` 时代的遗留），

package/lib/remote-schemas.js

@@ -2,7 +2,7 @@
 /**
  * Remote 线格式的**单一 schema 源**（A-2 / A-3）。
  *
- * 为什么要有这个文件：这些 schema 过去在 host（`lib/remote.js`）与客户端（`src/client.jsx`）
+ * 为什么要有这个文件：这些 schema 过去在 host（`lib/remote.js`）与客户端（`src/client/`）
  * 各写了一份，**13 个同名定义逐字重复**。加一个 remote 方法或改一个字段要改两处，漏改一处
  * 不会在加载期报错，只会在调用期炸（或更糟：静默把字段剥掉）。
  *

package/lib/squads.js

@@ -394,8 +394,49 @@ export function createSquadService({ teamsFile, catalog, python = "python3", gen
     return { ...result, lastReload, reloading: reloadTail !== undefined };
   }
 
+  /**
+   * 启动期对账（P0）：升级后 `teams.json` 按 MERGE 补进了新小队，但 `t-team.config.json`
+   * 是 DERIVED 文件（盘上存在就不动），于是「/t 列得出、引擎建不了」。这里检测两队 key
+   * 集合的差集，有差异就重编译并热重载，让升级带来的新小队无需用户手动保存即可用。
+   *
+   * 只补**缺失的 key**：已有 key 的内容差异由 `save()` 负责，启动期不强行覆盖（尊重用户
+   * 可能改过的字段）。编译失败不抛（升级不因小队编译问题打断插件加载），原因进返回值。
+   * @returns `{ ok, rebuilt, detail }`：`rebuilt` 为 true 表示真的重编译并热重载了。
+   */
+  async function resync() {
+    const spec = readSpec();
+    const profiles = spec.profiles !== null && typeof spec.profiles === "object" ? spec.profiles : {};
+    const configPath = ["t-team.config.json", "agent-teams.config.json"]
+      .map((file) => join(dataDir, file))
+      .find((candidate) => existsSync(candidate));
+    if (configPath === undefined) {
+      return { ok: true, rebuilt: false, detail: "" };
+    }
+    let engineProfiles;
+    try {
+      const engineCfg = JSON.parse(readFileSync(configPath, "utf8"));
+      engineProfiles = engineCfg !== null && typeof engineCfg === "object" && !Array.isArray(engineCfg)
+        && engineCfg.profiles !== null && typeof engineCfg.profiles === "object"
+        ? engineCfg.profiles
+        : {};
+    } catch (error) {
+      return { ok: false, rebuilt: false, detail: `引擎配置无法解析（${configPath}）：${error instanceof Error ? error.message : String(error)}` };
+    }
+    const missing = Object.keys(profiles).filter((key) => !Object.hasOwn(engineProfiles, key));
+    if (missing.length === 0) {
+      return { ok: true, rebuilt: false, detail: "" };
+    }
+    const built = await build();
+    if (!built.ok) {
+      return { ok: false, rebuilt: false, detail: `自动重编译失败：${built.output}` };
+    }
+    const settled = scheduleReload();
+    await settled;
+    return { ok: true, rebuilt: true, detail: `重编译补上 ${missing.length} 支小队：${missing.join(", ")}` };
+  }
+
   return {
-    list, save, validate, revision: revisionOf, generator, dataDir,
+    list, save, validate, resync, revision: revisionOf, generator, dataDir,
     // 本服务没有 `dispose()`：它只在 `save()` 调用期间持有状态（重载串行尾由 save() 自己 await
     // 干净），两次调用之间是无状态的，所以宿主卸载时没有需要收尾的异步工作。
     // 让调用方（与自检）看得到「这次编译用的是哪个上限、编译器到底认不认这个参数」。

package/lib/teams/index.js

@@ -163,11 +163,16 @@ export function apply(ctx, config) {
         if (rawWebServer === undefined || workspaceRegistry === undefined)
             return;
         const webServer = authenticatedWebRoutes(rawWebServer, () => ctx.get('connection'));
-        webRegistered = true;
+        // 审计修复（#10）：`webRegistered = true` 过去写在任何注册之前，一旦某条路由
+        // register 抛错（例如 webServer 服务重载后重复路径），布尔已置位，后续
+        // internal/service 事件永不重试，路由永久缺失。改为「收集 disposer + 全部成功
+        // 才置位」，任一失败回滚已注册的路由并重抛，让下次服务绑定事件可以再试一次。
+        const disposers = [];
+        try {
         // Activity panel data route: the browser floater polls this for team
         // snapshots (disk truth + live subagent activity). Mirrors the Claude
         // Code desktop watcher's server-side snapshot pattern.
-        ctx.effect(() => webServer.register({
+        disposers.push(ctx.effect(() => webServer.register({
             kind: 'exact',
             path: '/plugins/t-team/state',
             handler: async (req, res) => {
@@ -187,8 +192,8 @@ export function apply(ctx, config) {
                 });
                 res.end(body);
             },
-        }), 't-team: activity route');
-        ctx.effect(() => webServer.register({
+        }), 't-team: activity route'));
+        disposers.push(ctx.effect(() => webServer.register({
             kind: 'exact',
             path: '/plugins/t-team/halt',
             handler: async (req, res) => {
@@ -243,8 +248,8 @@ export function apply(ctx, config) {
                     res.end(JSON.stringify({ error: 'failed to stop the team' }));
                 }
             },
-        }), 't-team: halt route');
-        ctx.effect(() => webServer.register({
+        }), 't-team: halt route'));
+        disposers.push(ctx.effect(() => webServer.register({
             kind: 'exact',
             path: '/plugins/t-team/plan',
             handler: async (req, res) => {
@@ -389,7 +394,7 @@ export function apply(ctx, config) {
                     res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'plan operation failed' }));
                 }
             },
-        }), 't-team: plan route');
+        }), 't-team: plan route'));
         // Whale mascot artwork: serve the packaged V2 role/action images to the
         // activity panel. An explicit allowlist guards the route (no path
         // traversal); the images ship with the bundle (files: assets/).
@@ -404,7 +409,7 @@ export function apply(ctx, config) {
             'action-reporting-v2.png', 'action-celebrating-v2.png',
             'action-sleeping-v2.png', 'action-sending-v2.png',
         ]);
-        ctx.effect(() => webServer.register({
+        disposers.push(ctx.effect(() => webServer.register({
             kind: 'prefix',
             path: '/plugins/t-team/assets',
             handler: async (req, res) => {
@@ -437,7 +442,16 @@ export function apply(ctx, config) {
                     res.end();
                 }
             },
-        }), 't-team: artwork route');
+        }), 't-team: artwork route'));
+        } catch (error) {
+            // 任一路由注册失败：回滚已经注册成功的，保持 webRegistered=false，让下次
+            // internal/service 绑定事件重试，而不是留下半套路由 + 永久不再重试。
+            for (const dispose of disposers.reverse()) {
+                try { dispose(); } catch { /* 回滚尽力而为，失败只影响清理 */ }
+            }
+            throw error;
+        }
+        webRegistered = true;
     };
     registerWebSurface();
     ctx.on('internal/service', (name) => {

package/lib/teams/members.js

@@ -544,7 +544,10 @@ export async function deliverToMember(ctx, captain, childId, text, signal) {
         return true;
     }
     catch (error) {
-        ctx.logger.warn(`t-team: prompt delivery to member ${childId} failed: ${String(error)}`);
+        // 审计修复（#8）：投递失败过去只记一行 warn，然后任务被静默回滚成 pending，队长
+        // 看起来「重派成功」实则永远唤不醒成员。升级为 error 并保留根因，让宿主契约漂移
+        // 这类系统性问题在日志里可定位，而不是混在普通 warn 里被忽略。
+        ctx.logger.error(`t-team: prompt delivery to member ${childId} failed: ${String(error)}`);
         return false;
     }
 }

package/lib/teams/quality-gates.js

@@ -95,12 +95,24 @@ export function pathMatchesScope(path, pattern) {
     if (normalizedPath === undefined)
         return false;
     const rawPattern = pattern.trim().replaceAll('\\', '/');
-    if (rawPattern.startsWith('~') || rawPattern.startsWith('/') || /^[A-Za-z]:/.test(rawPattern))
+    // 审计修复（#6）：`.`、`./` 与空模式归一化后是空串，旧逻辑在目录分支把它们放行成
+    // 「匹配一切」，等于写域审计整体失效（`inScope: ["."]` 让任意路径都判 in_scope）。
+    // 根路径/盘符/`~` 已是非法；这里把「当前目录」类模式一并在最早期拒绝，绝不当作通配。
+    if (rawPattern === '' || rawPattern === '.' || rawPattern === './'
+        || rawPattern.startsWith('~') || rawPattern.startsWith('/') || /^[A-Za-z]:/.test(rawPattern))
         return false;
     // 审计 N-20：旧实现只在模式**以 `/` 结尾**时才当目录，于是 `inScope: ["src"]` 对 `src/a.ts`
     // 返回 false —— 写域等于没声明，真正该拦的写冲突会被放过。这里补齐两种常见写法：
     //   · `src`  —— 不含扩展名的裸目录名，按目录前缀处理（含 `.` 的仍按文件精确匹配，保住 `src/a.ts` 语义）
     //   · `src/*` / `src/**` —— 单层 / 任意层通配
+    //
+    // ⚠️ 已知且有意的取舍（2026-09-17 复核）：这条启发式只看字符串，无扩展名的**文件**名
+    //    （`Makefile`、`LICENSE`）也会被当成目录，于是 `inScope: ["Makefile"]` 会放行 `Makefile/x`。
+    //    不修的理由是反方向的代价更大：改成「只有 `dir/` 才算目录」就会把 N-20 退回去，让
+    //    `inScope: ["src"]` 对 `src/a.ts` 失效 —— 那是"写域声明形同虚设"（该拦的写冲突被放过），
+    //    比"多放行一个同名子路径"危险得多。而真正的精确判定需要知道工作区里 `Makefile` 是文件
+    //    还是目录，这个函数是**纯函数**（plan-check 与 tools 共用、不碰文件系统），拿不到该信息。
+    //    所以保留现状：宁可偶尔过宽，不可让写域声明失效。
     const directory = rawPattern.endsWith('/');
     const wildcard = rawPattern.includes('*');
     const bareDirectory = !directory && !wildcard && !rawPattern.includes('.') && rawPattern !== '.' && rawPattern !== '';
@@ -217,6 +229,25 @@ function dependencyClosureContains(tasks, dependencies, targetId) {
     }
     return false;
 }
+/**
+ * 判断「把 review 任务交给 `assigneeKey`」是否构成自审。
+ *
+ * 只对**有明确归属**的被审任务成立：被审任务落在共享池（`assignee` 为空）时谁都能审。
+ * `assigneeKey` 与 `reviewedTask.assignee` 都是同一种键（成员名，或队长占位键 CAPTAIN_KEY），
+ * 直接比较即可。审计修复（#5）：此前「不得自审」只写在提示词里，创建/重派都没有硬门禁。
+ * @param team - 团队状态。
+ * @param reviewedTaskId - review 指向的任务 id。
+ * @param assigneeKey - 拟交给的成员名或队长键（空串/undefined = 共享池，永不构成自审）。
+ * @returns 构成自审时为 true。
+ */
+export function isSelfReview(team, reviewedTaskId, assigneeKey) {
+    if (typeof assigneeKey !== 'string' || assigneeKey === '')
+        return false;
+    const reviewed = team.tasks.find((item) => item.id === reviewedTaskId);
+    if (reviewed === undefined || typeof reviewed.assignee !== 'string' || reviewed.assignee === '')
+        return false;
+    return reviewed.assignee === assigneeKey;
+}
 export function validateCreateTask(team, input) {
     const kind = input.kind ?? 'work';
     if (!TASK_KINDS.includes(kind)) {
@@ -251,6 +282,10 @@ export function validateCreateTask(team, input) {
         if (!team.tasks.some((item) => item.id === input.reviewedTaskId)) {
             return { ok: false, error: `reviewed task "${input.reviewedTaskId}" does not exist` };
         }
+        // 审计修复（#5）：不得把 review 明确派给被审任务的实现者本人（自审）。
+        if (isSelfReview(team, input.reviewedTaskId, input.assignee)) {
+            return { ok: false, error: `review must not be assigned to the same member as the reviewed task "${input.reviewedTaskId}" (no self-review)` };
+        }
     }
     if (kind === 'repair') {
         if (!nonemptyString(input.sourceTaskId) || !nonemptyStringList(input.sourceFindingIds)) {
@@ -381,7 +416,16 @@ export function evaluateQualityCompletion(task, update) {
                 return { ok: false, error: `${kind} pass cannot leave unresolved high/blocker findings` };
             }
         }
-        if (nextStatus === 'failed' && (verdict === 'needs_revision' || verdict === 'reject')) {
+        // 非 pass 的 verdict **必须**把任务判成 failed —— 这不只是文案问题，而是循环能不能推进的判据：
+        // 自动补 repair + 下一轮 review 只在 status==='failed' 时生成（tools.js 的 followUp），
+        // 所以旧行为下「给了 needs_revision 却没给 status」既没落成失败、也不会补修，任务停在
+        // in_progress：队长只看到一条卡住的任务，成员那边也没有"下一步要干什么"的信号
+        // （2026-09-17 复核发现：evaluateQualityCompletion 只在 nextStatus==='failed' 分支里
+        //  校验 findings，nextStatus 为 undefined 时直接放行）。
+        if (verdict === 'needs_revision' || verdict === 'reject') {
+            if (nextStatus !== 'failed') {
+                return { ok: false, error: `${kind} with verdict=${verdict} must fail the task (status=failed)`, requiredStatus: 'failed' };
+            }
             if ((findings ?? []).length < 1) {
                 return { ok: false, error: `${kind} ${verdict} requires at least one finding` };
             }
@@ -536,6 +580,17 @@ export function buildCoverageMatrix(goalItems, tasks) {
 }
 export function canDeclareDelivery(team) {
     const blockers = [];
+    // 审计修复（#7）：`quality` 过滤掉非质量类任务后，纯 `work` 团队（或零任务团队）的
+    // `quality` 为空 → blockers 恒为空 → 被误报成「所有质量门禁已通过、可以交付」，哪怕
+    // 所有任务都还是 pending。交付要求**所有任务**（含 work）都到达终态，而不只是质量类。
+    if (team.tasks.length === 0) {
+        blockers.push('no tasks have been planned; there is nothing to deliver');
+    }
+    for (const item of team.tasks) {
+        if (!isQualityKind(taskKindOf(item)) && OPEN_STATUSES.includes(item.status)) {
+            blockers.push(`${item.id} (${taskKindOf(item)}) is still ${item.status}; all work must reach a terminal state before delivery`);
+        }
+    }
     const quality = team.tasks.filter((item) => isQualityKind(taskKindOf(item)));
     const implementations = quality.filter((item) => taskKindOf(item) === 'implementation' || taskKindOf(item) === 'repair');
     const reviews = quality.filter((item) => taskKindOf(item) === 'review');

package/lib/teams/scheduler.js

@@ -114,8 +114,20 @@ function nextReadyTask(tasks, memberName) {
     const ready = tasks.filter(task => task.status === 'pending'
         && task.reassigning !== true
         && unsatisfiedDependencies([...tasks], task.dependencies).length === 0);
-    return ready.find(task => task.assignee === memberName)
-        ?? ready.find(task => task.assignee === undefined);
+    const assigned = ready.find(task => task.assignee === memberName);
+    if (assigned !== undefined)
+        return assigned;
+    // 审计修复（#5 调度侧）：共享池里的 review 任务不得分给被审任务的实现者本人
+    // （自审）。显式 assignee 已在创建/reassign 两道闸门挡住，这里挡住「调度器自动
+    // 把 review 派回实现者」这条剩余路径。
+    return ready.find(task => {
+        if (task.assignee !== undefined)
+            return false;
+        if ((task.kind ?? 'work') !== 'review')
+            return true;
+        const reviewed = tasks.find(candidate => candidate.id === task.reviewedTaskId);
+        return reviewed?.assignee !== memberName;
+    });
 }
 export function assignmentPrompt(ticket, stateDir, teamId) {
     const description = ticket.description === undefined ? '' : `\n\n${ticket.description}`;
@@ -320,7 +332,7 @@ export function installTeamScheduler(ctx, config) {
                     return;
                 const accepted = await deliverToMember(ctx, captain, ticket.memberId, assignmentPrompt(ticket, config.stateDir, team.id), new AbortController().signal);
                 if (accepted)
-                    return;
+                    return { dispatched: true };
                 // Roll back only our exact failed dispatch. A concurrent captain
                 // handoff has already changed the capability and wins.
                 await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
@@ -354,6 +366,9 @@ export function installTeamScheduler(ctx, config) {
                         currentMember.status = 'idle';
                     await writeTeam(stateRoot, fresh);
                 });
+                // 审计修复（#8）：把投递失败传回调用方（同步的 create/reassign 会把它带进工具
+                // 结果），而不是只让任务静默回滚成 pending。后台 idle-edge 调用方忽略该返回值。
+                return { dispatched: false, deliveryError: 'prompt delivery to member failed; see host logs' };
             });
         },
     };

package/lib/teams/tools.js

@@ -1253,6 +1253,13 @@ export function registerTTeamTools(ctx, config) {
                     throw new Error(`completed task ${task.id} is immutable and cannot be reassigned`);
                 if (task.reassigning === true)
                     throw new Error(`task ${task.id} is already being reassigned`);
+                // 审计修复（#5 重派侧）：不得把 review 重派给被审任务的实现者本人（自审）。
+                if ((task.kind ?? 'work') === 'review') {
+                    const reviewed = fresh.tasks.find((candidate) => candidate.id === task.reviewedTaskId);
+                    if (reviewed !== undefined && reviewed.assignee === target) {
+                        throw new Error(`cannot reassign review ${task.id} to ${target}: it reviews ${target}'s own task (no self-review)`);
+                    }
+                }
                 const targetMember = target === CAPTAIN_KEY ? undefined : requireMember(fresh, target);
                 if (target === CAPTAIN_KEY) {
                     const busy = captainOpenTask(fresh, task.id);
@@ -1318,8 +1325,13 @@ export function registerTTeamTools(ctx, config) {
             });
             if (quiescenceError !== undefined)
                 throw quiescenceError;
-            if (target !== CAPTAIN_KEY)
-                await scheduler.kickMember(workspace, team.id, target, captain);
+            let deliveryWarning;
+            if (target !== CAPTAIN_KEY) {
+                const kicked = await scheduler.kickMember(workspace, team.id, target, captain);
+                if (kicked?.dispatched === false) {
+                    deliveryWarning = kicked.deliveryError ?? 'prompt delivery to member failed';
+                }
+            }
             const current = await readTeam(stateRoot, team.id);
             const task = current === undefined ? undefined : requireTask(current, args.task_id);
             if (task === undefined)
@@ -1331,6 +1343,7 @@ export function registerTTeamTools(ctx, config) {
                 status: task.status,
                 attempt: task.attempt ?? 0,
                 ...task.attemptId === undefined ? {} : { attempt_id: task.attemptId },
+                ...deliveryWarning === undefined ? {} : { delivery_warning: deliveryWarning },
             };
         },
     }));
@@ -1386,6 +1399,13 @@ export function registerTTeamTools(ctx, config) {
                         throw new Error(`task ${task.id} is assigned to "${assignee}", not you`);
                     }
                     assignee = identity.name;
+                    // 审计修复（#5 认领侧）：成员不得认领「审自己实现」的 review 任务。
+                    if ((task.kind ?? 'work') === 'review') {
+                        const reviewed = fresh.tasks.find((candidate) => candidate.id === task.reviewedTaskId);
+                        if (reviewed?.assignee === identity.name) {
+                            throw new Error(`cannot claim review ${task.id}: it reviews your own task (no self-review)`);
+                        }
+                    }
                 }
                 // Authorization must happen before the idempotent return: another
                 // member must not receive a false success for somebody else's task.
@@ -2110,7 +2130,7 @@ function parseFindings(value) {
         return undefined;
     if (!Array.isArray(value))
         throw new Error('findings must be an array');
-    return value.map((item, index) => {
+    const parsed = value.map((item, index) => {
         if (typeof item !== 'object' || item === null || Array.isArray(item)) {
             throw new Error(`findings[${index}] must be an object`);
         }
@@ -2136,6 +2156,15 @@ function parseFindings(value) {
             ...typeof raw['resolved'] === 'boolean' ? { resolved: raw['resolved'] } : {},
         };
     });
+    // 审计修复（#9）：写侧过去不校验 id 唯一，读侧 hasValidQualityTaskFields 却要求唯一，
+    // 于是两个同名 finding 能过工具入参、却在 writeTeam 处卡死在误导性错误上（文案列举的
+    // 原因里根本没有 findings）。这里在最早可解析点报出可定位的错误。
+    const ids = parsed.map((finding) => finding.id);
+    const duplicate = ids.find((id, index) => ids.indexOf(id) !== index);
+    if (duplicate !== undefined) {
+        throw new Error(`findings ids must be unique; duplicate id "${duplicate}"`);
+    }
+    return parsed;
 }
 function parseAcceptanceResults(value) {
     if (value === undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-t-expert",
-  "version": "0.3.46",
+  "version": "0.3.70",
   "type": "module",
   "description": "T Expert — a 323-expert, 22-division roster with full Chinese translations, as a standalone DeepSeek Harness plugin, with a built-in multi-agent team engine (T Team).",
   "license": "MIT",
@@ -41,7 +41,13 @@
   },
   "files": [
     "lib",
-    "data",
+    "data/experts",
+    "data/zh",
+    "data/source.json",
+    "data/team-profiles.py",
+    "data/teams.json",
+    "data/teams.resolved.json",
+    "data/t-team.config.json",
     "skills/dsh-harness-project",
     "skills/dsh-harness-languages",
     "cordis.patch.yml",
@@ -60,6 +66,7 @@
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-api-session-controller",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-input-trigger",
         "@deepseek-ai/dsh-client-ui-primitives"
@@ -70,9 +77,11 @@
   "scripts": {
     "typecheck": "tsc -p tsconfig.json",
     "build": "node tools/build-client.mjs",
+    "check-client": "node tools/check-client-refs.mjs",
+    "render-smoke": "node tools/render-smoke.mjs",
     "verify": "node tools/verify.mjs",
     "sync-data": "node tools/sync-data.mjs",
-    "prepublishOnly": "npm run typecheck && npm run build && npm run verify && npm run invariants && node tools/sync-data.mjs --check",
+    "prepublishOnly": "npm run typecheck && npm run check-client && npm run render-smoke && npm run build && npm run verify && npm run invariants && node tools/sync-data.mjs --check",
     "invariants": "node tools/invariants.mjs"
   },
   "peerDependencies": {
@@ -80,6 +89,7 @@
     "@deepseek-ai/dsh": "0.1.5-rc.1 || 0.1.5-rc.2",
     "@deepseek-ai/dsh-agent": "0.1.5-rc.1 || 0.1.5-rc.2",
     "@deepseek-ai/dsh-api-remotes": "0.1.5-rc.1 || 0.1.5-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "0.1.5-rc.1 || 0.1.5-rc.2",
     "@deepseek-ai/dsh-client-connection": "0.1.5-rc.1 || 0.1.5-rc.2",
     "@deepseek-ai/dsh-client-locale": "0.1.5-rc.1 || 0.1.5-rc.2",
     "@deepseek-ai/dsh-client-ui-input-trigger": "0.1.5-rc.1 || 0.1.5-rc.2",
@@ -106,6 +116,9 @@
     "@deepseek-ai/dsh-api-remotes": {
       "optional": true
     },
+    "@deepseek-ai/dsh-api-session-controller": {
+      "optional": true
+    },
     "@deepseek-ai/dsh-client-connection": {
       "optional": true
     },

package/data/.t-team-snapshot.json

@@ -1,10 +0,0 @@
-{
-  "version": "0.3.24",
-  "at": "2026-09-15T12:15:59.731Z",
-  "scanned": 660,
-  "copied": 0,
-  "updated": 0,
-  "merged": 0,
-  "kept": 0,
-  "stale": 0
-}