dsh-plugin-t-expert 0.2.6 → 0.2.9

package/lib/command.js

@@ -175,8 +175,11 @@ export function registerTeamCommand(ctx, options) {
     handler(invocation) {
       if (hasEngine() !== true) {
         const detail = typeof options.engineError === "function" ? options.engineError() : "";
+        // 中性表述：不指路日志。旧文案让用户去看 `[t-team]` error 行，但「引擎已调度、工具却没注册」
+        // 这条路径下那句话**永远不会打印**（lib/index.js 的 engineReady 探到假只会补 warn），
+        // 于是指引恒定失效（N-5）。
         const text = detail === ""
-          ? "团队引擎未就绪：T专家 内置的团队引擎没有挂载成功（查看 DSH 日志里的 [t-team] 行）。"
+          ? "团队引擎未就绪：T专家 内置的团队引擎没有注册成功（它的工具没有出现在工具表里）。"
           : `团队引擎挂载失败：${detail}`;
         // 命令结果行在部分 DSH 版本不渲染，所以连错误也交给队长转述一次。
         invocation.agent.followup(createUserMessage({

package/lib/i18n.js

@@ -20,6 +20,7 @@ const ZH = {
   "error.specsTooMany": "一次最多召唤 {limit} 位专家",
   "error.specInvalid": "experts[{index}] 需要 expert 与 task 两个字段",
   "error.settingsMissing": "T专家 设置段尚未注册",
+  "error.customUnknownSlug": "未知专家 slug：{slugs}（这些 slug 不在当前名册里；先用 list_t_experts 取准确的 slug）",
   "error.customSlugInvalid": "slug 只能用 a-z、0-9 与连字符，且以字母或数字开头：\"{slug}\"",
   "error.customSlugTaken": "slug「{slug}」已被内置或自建专家占用",
   "error.customDivisionInvalid": "分类目录名只能用 a-z、0-9、连字符与点，且以字母或数字开头（中文请填在「显示名」里）：\"{division}\"",
@@ -65,6 +66,7 @@ const EN = {
   "error.specsTooMany": "At most {limit} experts per call",
   "error.specInvalid": "experts[{index}] requires both expert and task",
   "error.settingsMissing": "T Expert settings section is not registered yet",
+  "error.customUnknownSlug": "Unknown expert slug(s): {slugs} (not in the current roster; call list_t_experts for exact slugs)",
   "error.customSlugInvalid": "slug may only use a-z, 0-9 and hyphens, starting with a letter or digit: \"{slug}\"",
   "error.categoryOfficial": "\"{division}\" is an official division: its name and existence follow the built-in roster sync, so only custom divisions can be changed",
   "error.categoryExists": "Division \"{division}\" already exists",
@@ -128,8 +130,49 @@ export function localized(expert, locale) {
   };
 }
 
-/** list_t_experts 的文本渲染。 */
-export function renderList(locale, { query, groups, total, allDivisions }) {
+/**
+ * 把执行期名册分组投影成渲染期就绪的形状。
+ *
+ * 为什么在这里做：`output.render(args, value)` 必须是 `(args, value)` 的纯函数
+ * ——同一个 canonical value 在会话日志里回放时必须渲染出同一段文本。而「用哪种语言」
+ * 是**执行期**才知道的事实（读宿主 locale 设置），所以它必须和分组一起进 canonical value，
+ * 不能在 render 里再读一次宿主。
+ *
+ * @param groups - `groupByDivision()` 的分组（带 label/labelEn 与 expert 条目）。
+ * @param locale - 执行期语言（"zh" | "en"）。
+ * @returns 只含渲染所需字段的分组数组。
+ */
+export function toRenderableGroups(groups, locale) {
+  return (Array.isArray(groups) ? groups : []).map((group) => ({
+    division: group.division,
+    label: locale === "en" ? (group.labelEn ?? group.label ?? group.division) : (group.label ?? group.division),
+    count: group.count ?? (group.experts ?? []).length,
+    experts: (group.experts ?? []).map((expert) => {
+      const { name, description } = localized(expert, locale);
+      return {
+        slug: expert.slug,
+        emoji: expert.emoji ?? "",
+        // 渲染期不再读侧车译文：名字与简介在执行期就按 locale 定好。
+        name,
+        description,
+      };
+    }),
+  }));
+}
+
+/**
+ * list_t_experts 的文本渲染（纯函数）。
+ *
+ * 语言只从 `value.locale` 取，不读宿主设置：同一个 `value` 永远渲染出同一段文本。
+ * @param args - 工具入参（只用来取 division 过滤词）。
+ * @param value - `list_t_experts.execute` 返回的 canonical value。
+ */
+export function renderList(_args, value) {
+  const query = typeof value.query === "string" ? value.query : "";
+  const locale = value.locale === "en" ? "en" : "zh";
+  const groups = Array.isArray(value.divisions) ? value.divisions : [];
+  const total = typeof value.total === "number" ? value.total : 0;
+  const allDivisions = Array.isArray(value.allDivisions) ? value.allDivisions : [];
   if (query !== "" && groups.length === 0) {
     return t(locale, "list.unknownDivision", { query, divisions: allDivisions.join(", ") });
   }
@@ -146,23 +189,44 @@ export function renderList(locale, { query, groups, total, allDivisions }) {
   } else {
     const group = groups[0];
     lines.push(t(locale, "list.headerOne", { division: `${group.label} (${group.division})`, count: group.count }));
-    for (const expert of group.experts) {
-      const { name, description } = localized(expert, locale);
+    for (const expert of group.experts ?? []) {
       // 带上 slug：模型可以直接拿它当召唤参数，避免只靠名字解析
-      lines.push(`- ${expert.emoji} ${name} (${expert.slug}) — ${description}`);
+      lines.push(`- ${expert.emoji} ${expert.name} (${expert.slug}) — ${expert.description}`);
     }
   }
   return lines.join("\n");
 }
 
-/** summon_experts 的文本渲染。 */
-export function renderSummonResults(locale, results) {
-  const ok = results.filter((r) => r.ok).length;
+/**
+ * 把一批召唤结果投影成渲染期就绪的形状。
+ * @param results - `summon_t_experts` 的结果项；`expert` 已是**执行期按 locale 定好的显示名**
+ *   （`summon_t_experts.execute` 负责解析，render 不再碰名册）。
+ * @param locale - 执行期语言（写进 value，供 render 取文案）。
+ */
+export function toRenderableSummonResults(results, locale) {
+  return (Array.isArray(results) ? results : []).map((item) => ({
+    expert: typeof item?.expert === "string" ? item.expert : "",
+    ok: item?.ok === true,
+    answer: item?.answer ?? "",
+    error: item?.error ?? "",
+  }));
+}
+
+/**
+ * summon_t_experts 的文本渲染（纯函数）。
+ * 语言只从 `value.locale` 取，专家名来自 `value.results[].expert`（执行期已本地化）。
+ * @param args - 工具入参（未使用）。
+ * @param value - `summon_t_experts.execute` 返回的 canonical value。
+ */
+export function renderSummonResults(_args, value) {
+  const locale = value.locale === "en" ? "en" : "zh";
+  const results = Array.isArray(value.results) ? value.results : [];
+  const ok = results.filter((item) => item.ok === true).length;
   const lines = [t(locale, "summon.batchHeader", { total: results.length, ok, failed: results.length - ok })];
   for (const item of results) {
-    lines.push(item.ok
-      ? t(locale, "summon.itemOk", { expert: item.expert, answer: item.answer })
-      : t(locale, "summon.itemFail", { expert: item.expert, error: item.error ?? "" }));
+    lines.push(item.ok === true
+      ? t(locale, "summon.itemOk", { expert: item.expert ?? "", answer: item.answer ?? "" })
+      : t(locale, "summon.itemFail", { expert: item.expert ?? "", error: item.error ?? "" }));
   }
   return lines.join("\n\n");
 }

package/lib/index.js

@@ -38,8 +38,9 @@ import {
   truncate,
   writeFileAtomic,
 } from "./catalog.js";
-import { localized, NS, readLocale, renderList, renderSummonResults, t } from "./i18n.js";
+import { localized, NS, readLocale, renderList, renderSummonResults, t, toRenderableGroups, toRenderableSummonResults } from "./i18n.js";
 import { seedData } from "./bootstrap.js";
+import { installBundledSkills } from "./skill.js";
 import { registerTeamCommand } from "./command.js";
 import { createSquadService } from "./squads.js";
 import { SNAPSHOT_DIR } from "./bootstrap.js";
@@ -110,6 +111,15 @@ export const TEAM_SERVICE = "tTeamTeams";
 /** 设置命名空间（= 插件名）。 */
 export const SETTINGS_NAMESPACE = NS;
 
+/**
+ * 「未知专家 slug」的稳定错误码（与 `lib/remote.js` 共用）。
+ *
+ * 为什么要有它：remote 侧过去靠 `message.includes("未知专家")` 判断这是不是「未知专家」，
+ * 而 message 是**显示文案**（随 locale 变，也会被改写）——用它做错误身份，等于把分类建在
+ * 会漂移的字符串上。这里给出稳定码，remote 只认码（D-3）。
+ */
+export const UNKNOWN_SLUG_ERROR_CODE = "tTeam/unknown-slug";
+
 
 const settingsSchema = schema.object({
   enabled: schema.array(schema.string()).default([]),
@@ -160,6 +170,12 @@ export function apply(ctx, config) {
   let loading = null;
   let stamp = "";
   let loadError = null;
+  /** 中文侧车目录是否存在（D-5：缺了要能被面板/日志看见，而不是静默变英文名册）。 */
+  let sidecarPresent = true;
+  /** 加载期被跳过的专家文件数（缺 frontmatter / 读不到 / 冲突，见 lib/catalog.js）。 */
+  let skippedFiles = 0;
+  /** 加载期读不动的分区目录（该分区专家整批缺席，D-18）。 */
+  let unreadableDivisions = [];
 
   /**
    * 名册指纹：source.json、各分区目录、以及中文侧车文件的 mtime。
@@ -200,8 +216,13 @@ export function apply(ctx, config) {
       const catalog = await loadCatalog(config.root, config.divisions, {
         zhRoot: config.zhRoot,
         customRoot: config.customRoot,
+        // 名册加载的诊断必须走宿主日志通道，而不是 console（N-3）：桌面/Web 里 stderr 用户看不到。
+        logger: ctx.logger,
       });
       entries = [...catalog.values()];
+      sidecarPresent = catalog.sidecarPresent !== false;
+      skippedFiles = typeof catalog.skippedFiles === "number" ? catalog.skippedFiles : 0;
+      unreadableDivisions = Array.isArray(catalog.unreadableDivisions) ? catalog.unreadableDivisions : [];
       const discovered = catalogDivisions(catalog);
       if (catalog.customDivisions !== undefined) customDivisions = catalog.customDivisions;
       if (catalog.rosterDivisions !== undefined) rosterDivisions = catalog.rosterDivisions;
@@ -232,6 +253,22 @@ export function apply(ctx, config) {
   /** 可召唤/可展示的专家（排除重名冲突项）。 */
   const usable = () => entries.filter((expert) => expert.conflict !== true);
 
+  /**
+   * 把一次召唤目标（中文名 / 英文名 / slug 都行）解析成**该语言下的显示名**。
+   * 解析不到就原样返回：失败项也要让模型看清它请求的是谁。
+   * @param query - 模型给的召唤目标。
+   * @param current - 执行期语言。
+   */
+  function displayNameOf(query, current) {
+    const text = String(query ?? "").trim();
+    if (text === "") return "";
+    try {
+      return localized(resolveExpert(usable(), text, current), current).name;
+    } catch {
+      return text;
+    }
+  }
+
   // ---- 设置段修订号与写入 ----
   const revision = () => {
     const descriptor = ctx.settings.describe().find((item) => item.ns === SETTINGS_NAMESPACE);
@@ -242,8 +279,7 @@ export function apply(ctx, config) {
   /** 客户端面板用的名册快照。 */
   async function snapshot() {
     await ensureReady();
-    const enabled = enabledSet();
-    const experts = await Promise.all(usable().map(async (expert) => ({
+    const enabled = enabledSet();    const experts = await Promise.all(usable().map(async (expert) => ({
       // 面板按 locale 取字段：name/description 为中文（缺译回退英文），nameEn/descriptionEn 恒为英文。
       slug: expert.slug,
       name: expert.nameZh ?? expert.name,
@@ -263,6 +299,14 @@ export function apply(ctx, config) {
       experts,
       enabled: [...enabled],
       revision: revision(),
+      // 名册健康状态：面板可以据此提示「中文侧车没找到 / 有 N 个专家文件被跳过」，
+      // 而不是让用户对着一个静默变全英文的名册猜。
+      sidecar: {
+        zhRoot: config.zhRoot,
+        present: sidecarPresent,
+        skippedFiles,
+        unreadableDivisions,
+      },
       // 自建专家固定落在这个分区；连同中文标签一起给面板，省得两端各写一份常量。
       customDivision: CUSTOM_DIVISION,
       customDivisionLabel: divisionOf(CUSTOM_DIVISION, divisionLabels).zh,
@@ -516,7 +560,15 @@ export function apply(ctx, config) {
     const list = (Array.isArray(next) ? next : []).filter((item) => typeof item === "string");
     const known = new Set(usable().map((expert) => expert.slug));
     const unknown = list.filter((slug) => !known.has(slug));
-    if (unknown.length > 0) throw new Error(`未知专家 slug：${unknown.slice(0, 5).join(", ")}`);
+    if (unknown.length > 0) {
+      // 稳定 code（不是显示文案）：remote 侧按它分类成 tTeam/unknown-expert，与 locale 无关（D-3）。
+      // 文案走正确的 t() 通道（过去这里也是硬编码中文，非中文 locale 下会中英混排）。
+      const slugs = unknown.slice(0, 5);
+      const error = new Error(t(locale(), "error.customUnknownSlug", { slugs: slugs.join(", ") }));
+      error.code = UNKNOWN_SLUG_ERROR_CODE;
+      error.details = { slugs };
+      throw error;
+    }
     await ctx.settings.mutate(SETTINGS_NAMESPACE, [{ op: "set", path: ["enabled"], value: list }], expectedRevision);
     return { enabled: [...enabledSet()], revision: revision() };
   }
@@ -627,57 +679,50 @@ export function apply(ctx, config) {
         properties: {
           divisions: { type: "array", required: true, items: { type: "json" } },
           total: { type: "number", required: true },
+          // 渲染期事实：语言与过滤词进 canonical value，render 才能是纯函数（D-11）。
+          locale: { type: "string", required: true },
+          query: { type: "string", required: true },
+          allDivisions: { type: "array", required: true, items: { type: "string" } },
         },
       },
-      render: (args, value) => [{
-        type: "text",
-        text: renderList(locale(), {
-          query: args.division === undefined ? "" : String(args.division).trim(),
-          groups: value.divisions,
-          total: value.total,
-          allDivisions: effectiveDivisions,
-        }),
-      }],
+      // render 只读 (args, value)：同一个 value 在日志里回放时渲染出同一段文本。
+      render: (args, value) => [{ type: "text", text: renderList(args, value) }],
     },
     async execute(args) {
       await ensureReady();
+      const current = locale();
       const query = args.division === undefined ? "" : String(args.division).trim();
       const enabled = enabledSet();
       const groups = groupByDivision(usable(), enabled);
+      // 简介截断是**执行期**的可配项（Config.descriptionLimit），所以在投影时一次做完，
+      // render 拿到的就是最终文本（纯函数，不再读 config）。
+      const projection = (list) => toRenderableGroups(list, current).map((group) => ({
+        ...group,
+        experts: group.experts.map((expert) => ({
+          ...expert,
+          description: truncate(expert.description, config.descriptionLimit),
+        })),
+      }));
       if (query === "") {
         return {
-          divisions: groups.map((group) => ({
-            division: group.division,
-            label: group.label,
-            labelEn: group.labelEn,
-            count: group.count,
-          })),
+          divisions: projection(groups),
           total: enabled.size,
+          locale: current,
+          query,
+          allDivisions: effectiveDivisions.slice(),
         };
       }
       const needle = query.toLowerCase();
       const matched = groups
         .filter((group) => group.division.toLowerCase() === needle
           || group.label.toLowerCase() === needle
-          || group.labelEn.toLowerCase() === needle)
-        .map((group) => ({
-          division: group.division,
-          label: group.label,
-          labelEn: group.labelEn,
-          count: group.count,
-          experts: group.experts.map((expert) => {
-            const { name, description } = localized(expert, locale());
-            return {
-              slug: expert.slug,
-              name,
-              emoji: expert.emoji,
-              description: truncate(description, config.descriptionLimit),
-            };
-          }),
-        }));
+          || group.labelEn.toLowerCase() === needle);
       return {
-        divisions: matched,
+        divisions: projection(matched),
         total: matched.reduce((sum, group) => sum + group.count, 0),
+        locale: current,
+        query,
+        allDivisions: effectiveDivisions.slice(),
       };
     },
   }));
@@ -728,12 +773,13 @@ export function apply(ctx, config) {
       schema: {
         type: "object",
         additionalProperties: false,
-        properties: { results: { type: "array", required: true, items: { type: "json" } } },
+        properties: {
+          results: { type: "array", required: true, items: { type: "json" } },
+          // 渲染期事实（D-11）：语言进 canonical value，render 才不需要读宿主。
+          locale: { type: "string", required: true },
+        },
       },
-      render: (_args, value) => [{
-        type: "text",
-        text: renderSummonResults(locale(), value.results),
-      }],
+      render: (args, value) => [{ type: "text", text: renderSummonResults(args, value) }],
     },
     async execute(args, exec) {
       await ensureReady();
@@ -754,14 +800,19 @@ export function apply(ctx, config) {
           return { expert: result.expert, ok: true, answer: result.answer };
         } catch (error) {
           return {
-            expert: spec.expert,
+            // 失败项也要在**执行期**定好显示名：否则 render 得自己去解析名册才说得清是谁失败了
+            // （D-11：render 必须是 (args,value) 的纯函数，不能读名册/宿主 locale）。
+            expert: displayNameOf(spec.expert, current),
             ok: false,
             answer: "",
             error: error instanceof Error ? error.message : String(error),
           };
         }
       });
-      return { results };
+      return {
+        results: toRenderableSummonResults(results, current),
+        locale: current,
+      };
     },
   }));
 
@@ -800,6 +851,41 @@ export function apply(ctx, config) {
   // T专家 的专家名册、@ 召唤、/t 列表仍然可用，只是团队功能不可用。
   // 这是**已声明的降级**，不是静默跳过：原因会写进日志、经 /t 报出，并进系统提示段。
   const engineState = { ok: false, detail: engineConfigDetail };
+  /** 首次探到「调度成功但工具没注册」时的告警只打一次（此后每轮都探，但不再刷日志）。 */
+  let engineNotReadyWarned = false;
+  const NOT_READY_DETAIL = "内置团队引擎的工具没有注册成功（引擎可能还在等待它声明的宿主服务）";
+  /**
+   * 引擎是否**真的**就绪 —— 必须真机探测，不能只看 `ctx.plugin()` 有没有抛错。
+   *
+   * cordis 的 `ctx.plugin()` 只**构造并调度** fiber，不等子插件 `apply` 跑完；而引擎声明的
+   * `inject`（lib/teams/index.js:39 的 tools/llm/subagents/systemPrompt/agents）只要缺一个，
+   * cordis 就会**静默挂起它的 fiber**：不抛错、不告警，13 个 t_team_* 工具一个都不会注册。
+   * 所以唯一可靠的判据是「工具真在注册表里」：`engineState.ok` 只说明调度成功，
+   * `ctx.tools.get("t_team_create")` 才说明引擎跑起来了。
+   *
+   * **探测时机很关键**：宿主里子插件的 fiber 可能在同一同步段末尾、也可能更晚才激活，
+   * 所以**不在 mount 的那一刻探**（那一刻必然探空，会把每次正常启动都误报成降级）。
+   * 探测发生在所有真实读取点（系统提示段 / `/t` 命令），那时引擎早已定局；且每一轮都重新探，
+   * 只在**第一次**探到假时补一条 warn，避免刷日志。两处可见面共用它，不会再分叉。
+   * @returns 引擎工具是否已注册。
+   */
+  const engineReady = () => {
+    if (engineState.ok !== true) return false;
+    let present = false;
+    try {
+      present = ctx.tools.get("t_team_create") !== undefined;
+    } catch {
+      present = false;
+    }
+    if (!present && !engineNotReadyWarned) {
+      engineNotReadyWarned = true;
+      // 「工具没注册」这件事必须在日志里留下一条：否则提示段、/t、日志三处都没有信号。
+      ctx.logger?.warn?.(`[t-team] 团队引擎已调度但工具未注册（引擎声明的 inject 服务可能不齐）：${NOT_READY_DETAIL}`);
+    }
+    return present;
+  };
+  /** 给用户/模型的原因：挂载明明抛错就报那个错，否则报「工具没注册」。 */
+  const engineUnreadyDetail = () => (engineState.detail === "" ? NOT_READY_DETAIL : engineState.detail);
   if (engineConfigDetail === "") {
     try {
       ctx.plugin(teamsEngine, {
@@ -815,6 +901,9 @@ export function apply(ctx, config) {
       });
       // 复用引擎导出的手势边界：把 `/t --profile <小队> <目标>` 这条用户消息翻成队长协议指令。
       installTTeamGestureBoundary(ctx, () => engineConfig.profiles ?? {});
+      // 只记录「调度成功」。**不要**在这里同步探测工具是否已注册：cordis 的子插件 fiber
+      // 尚未激活，此刻必然探空 → 会把每一次正常启动都误报成降级（本改动实测踩到过）。
+      // 真机探测推迟到读取点（engineReady()）。
       engineState.ok = true;
     } catch (error) {
       engineState.detail = error instanceof Error ? error.message : String(error);
@@ -826,15 +915,16 @@ export function apply(ctx, config) {
 
   // 已声明的降级也要**对模型可见**：否则"团队功能没了"这件事只留在日志里，
   // 用户问起来模型只能说不知道 —— 那正是规范禁止的"静默跳过缺失的引用对象"。
+  // 门槛用 engineReady()（真机探测）而不是 engineState.ok：两者在「引擎 fiber 被挂起」时不同。
   ctx.systemPrompt.section({
     name: "t-team:engine-status",
     order: 120,
     text: (context) => {
       if (context.agent?.session?.header?.parentSession !== undefined) return "";
-      if (engineState.ok === true) return "";
+      if (engineReady()) return "";
       return [
         "## T专家 团队引擎当前不可用",
-        `团队功能（/t 建队、t_team_* 工具）现在不可用。原因：${engineState.detail}`,
+        `团队功能（/t 建队、t_team_* 工具）现在不可用。原因：${engineUnreadyDetail()}`,
         "专家名册、@ 召唤与 summon_t_expert 不受影响。用户需要团队功能时，请原样转述上面的原因，不要假装能建队。",
       ].join("\n");
     },
@@ -849,11 +939,19 @@ export function apply(ctx, config) {
     generator: existsSync(join(SNAPSHOT_DIR, "team-profiles.py"))
       ? join(SNAPSHOT_DIR, "team-profiles.py")
       : undefined,
+    // 成员上限**只有一个真源**：Config.maxMembers。它同时喂给引擎（成员上限）与小队编译器
+    // （--max-members）。过去编译器把上限写死 8、这里又没透传，于是把 maxMembers 改大后保存小队
+    // 必然编译失败并回滚（D-14）。编译器不认这个参数时由 squads.js 记 warn 并退回它内置默认值。
+    maxMembers: config.maxMembers,
   });
   ctx.reflect.provide(SQUAD_SERVICE, squads);
 
   // ---- 团队运行服务（设置页「团队」标签用；复用引擎的快照与停止实现）----
-  const engineStateDir = typeof engineConfig.stateDir === "string" ? engineConfig.stateDir : ".agent-teams";
+  // 状态目录**只有一个来源**：`config.stateDir`（同时也是挂给引擎的那个值，见上面的 ctx.plugin）。
+  // 曾经这里读的是数据文件 `t-team.config.json` 的 stateDir（`agent-teams.config.json` 时代的遗留），
+  // 于是「引擎挂到 config.stateDir、面板与 t_team_plan_check 却去数据文件那个目录找」——
+  // 改开 stateDir 的部署会两边失明且没有任何报错（D-1）。
+  const engineStateDir = config.stateDir;
   const teamRoots = () => {
     const registry = ctx.get("workspaceRegistry") ?? ctx.get("workspace");
     const list = typeof registry?.list === "function" ? registry.list() : [];
@@ -920,11 +1018,17 @@ export function apply(ctx, config) {
     },
     async stop(teamId) {
       const roots = teamRoots();
+      // 逐 root 读取失败时**留住根因**：过去 `catch { continue; }` 把 EACCES 之类换成
+      // 下面那句「没找到团队 …（它可能已被归档）」，用户按提示去查归档永远查不到（N-4）。
+      const failures = [];
       for (const root of roots) {
         let snapshots;
         try {
           snapshots = await collectTeamsActivity(ctx, [root]);
-        } catch {
+        } catch (error) {
+          const reason = error instanceof Error ? `${error.message}` : String(error);
+          failures.push(`${root.stateRoot}：${reason}`);
+          ctx.logger?.warn?.(`[t-team] 读取团队活动失败：${root.stateRoot}（${reason}）`);
           continue;
         }
         const team = snapshots.find((item) => item.teamId === teamId);
@@ -936,22 +1040,21 @@ export function apply(ctx, config) {
         const result = await haltTeamWork({ ctx, stateRoot: root.stateRoot, teamId, captain });
         return { teamName: result.teamName, cancelledTasks: result.cancelledTasks, alreadyHalted: result.alreadyHalted === true };
       }
-      throw new Error(`没找到团队 ${teamId} 的状态目录（它可能已被归档）。`);
+      // 读不到任何 root 时不要用「可能已归档」这种猜测掩盖根因：把真实失败原因一并报出来。
+      throw new Error(failures.length > 0
+        ? `没找到团队 ${teamId}：${roots.length} 个工作区里${failures.length} 个读取失败（${failures.join("；")}）。`
+        : `没找到团队 ${teamId} 的状态目录（它可能已被归档）。`);
     },
   });
 
   // ---- `/t` 小队短命令（把 /t <小队> <目标> 转成引擎认得的 /t --profile <key> <目标> 用户消息）----
   registerTeamCommand(ctx, {
     teamsFile,
-    hasEngine: () => {
-      if (engineState.ok !== true) return false;
-      try {
-        return ctx.tools.get("t_team_create") !== undefined;
-      } catch {
-        return false;
-      }
-    },
-    engineError: () => engineState.detail,
+    // 与系统提示段共用同一个真机探测（engineReady），两条可见面不会再次分叉。
+    hasEngine: () => engineReady(),
+    // 报给用户的原因用 engineUnreadyDetail()：它区分「调度都没成功」与「调度成功但工具没注册」，
+    // 后者在旧文案里会指向一条永远不存在的 [t-team] error 行（N-5）。
+    engineError: () => engineUnreadyDetail(),
   });
 
   // ---- DAG 预检工具（只读）：把整套拟建任务一次跑完引擎校验，避免"边建边撞"留下半成品 ----
@@ -1042,7 +1145,7 @@ export function apply(ctx, config) {
       if (context.agent?.session?.header?.parentSession !== undefined) return "";
       return [
         "## T专家 (T Expert) expert mode",
-        "The parent session has T专家 — a 314-expert, 22-division roster with full Chinese translations, exposed as summonable domain experts.",
+        "The parent session has T专家 — a 316-expert, 22-division roster with full Chinese translations, exposed as summonable domain experts.",
         "Experts are individually enabled/disabled in the T专家 settings tab; ALL are disabled by default and a disabled expert cannot be summoned.",
         "A composer selection inserts one enabled expert as a native reference chip; the remaining draft text is that expert's task.",
         "In the parent session, call `list_t_experts()` for enabled division names and counts, then `list_t_experts(division)` to pick a unique expert name, then `summon_t_expert(expert, task)` — or `summon_t_experts` for a small parallel team (at most 8; partial results when some fail).",
@@ -1050,4 +1153,12 @@ export function apply(ctx, config) {
       ].join("\n");
     },
   });
+
+  // ---- 随包 skill（运维入口 + DeepSeek Harness 项目知识）----
+  // 都只对特定任务有用，所以不占常驻提示段，改成按需加载的 skill：
+  //   · t-expert-manager      维护这个插件的人：名册 / 小队 / 装机 / 发布
+  //   · dsh-harness-project   在 deepseek-harness 检出里读写代码：架构、启动模型、扩展点、门禁
+  //   · dsh-harness-languages 同一个仓库里的各语言面规则与工具链
+  // 可选依赖：宿主没有 skill 注册表时静默跳过，不影响上面任何功能。
+  installBundledSkills(ctx, config);
 }

package/lib/plan-check.js

@@ -7,6 +7,7 @@
  * `validateStagedGraph`（未导出）里做的引用与环检查，全部在内存里模拟、不写任何状态。
  */
 import { CAPTAIN_KEY, readTeam } from "./teams/state.js";
+import { normalizeAssigneeForCreate } from "./teams/assignee-contract.js";
 import { validateCreateTask } from "./teams/quality-gates.js";
 
 /** 与引擎 `validateStagedGraph` 对齐的引用/环检查（该函数未导出，这里按同规则复刻）。 */
@@ -104,9 +105,19 @@ export function checkPlan(team, tasks) {
       (dependency) => !taken.has(dependency) && !existing.some((task) => task.id === dependency),
     );
     if (unknown.length > 0) local.push(`依赖不存在的任务：${unknown.join(", ")}`);
-    const assignee = typeof raw?.assignee === "string" && raw.assignee.trim() !== "" ? raw.assignee.trim() : undefined;
-    if (assignee !== undefined && assignee !== CAPTAIN_KEY && !memberNames.has(assignee)) {
-      local.push(`assignee「${assignee}」不是当前成员（用 t_team_status 看成员名，或先 add_member）`);
+    const rawAssignee = typeof raw?.assignee === "string" && raw.assignee.trim() !== "" ? raw.assignee.trim() : undefined;
+    let assignee = rawAssignee;
+    if (rawAssignee !== undefined) {
+      // 预检必须与引擎的 create_task **同规**：captain 不能在这里被"通过"，
+      // 否则预检说 ok、真建任务却被拒 —— 而预检的全部意义就是提前发现这种岔路。
+      try {
+        assignee = normalizeAssigneeForCreate(rawAssignee) ?? rawAssignee;
+      } catch (error) {
+        local.push(error instanceof Error ? error.message : String(error));
+      }
+      if (local.length === 0 && assignee !== undefined && !memberNames.has(assignee)) {
+        local.push(`assignee「${assignee}」不是当前成员（用 t_team_status 看成员名，或先 add_member）`);
+      }
     }
 
     // 引擎的契约/写域/质量门槛校验