dsh-plugin-t-expert 0.3.84 → 0.3.89

package/lib/squads.js

@@ -1,446 +0,0 @@
-// @ts-check
-/**
- * T专家 小队数据层：读写 `teams.json`，并把改动编译成引擎配置。
- *
- * 职责边界：本文件只管**小队定义**（有哪些队、谁在里面、别名、启停），
- * 编译交给既有的 `team-profiles.py`（它已内置成员名撞键预检、别名校验、人格注入）。
- * 这样 UI 编辑器不需要复制一份校验逻辑，生成器仍是唯一权威。
- */
-import { readFileSync, statSync, existsSync } from "node:fs";
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { dirname, join } from "node:path";
-import { promisify } from "node:util";
-
-import { writeFileAtomic } from "./catalog.js";
-
-/** 异步编译器调用：**绝不能**用 execFileSync —— 那会同步阻塞整个 Host 事件循环。 */
-const runFile = promisify(execFile);
-
-/** profile key 只允许小写 ASCII + 数字 + 连字符（引擎按它生成命令别名）。 */
-const KEY_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
-
-function text(value) {
-  return typeof value === "string" ? value : "";
-}
-
-function fail(code, message, details = {}) {
-  /** @type {Error & { code?: string, details?: object }} */
-  const error = new Error(message);
-  error.code = code;
-  error.details = details;
-  return error;
-}
-
-/** members 允许两种写法：slug 字符串，或 {slug|name, role} 对象（兼容手写）。 */
-function memberSlug(member) {
-  if (typeof member === "string") return member.trim();
-  if (member !== null && typeof member === "object") {
-    for (const key of ["slug", "name", "role"]) {
-      if (typeof member[key] === "string" && member[key].trim() !== "") return member[key].trim();
-    }
-  }
-  return "";
-}
-
-/**
- * 编译器的成员上限默认值（与 `data/team-profiles.py` 的 `MAX_MEMBERS` 同一口径）。
- *
- * 它只是**兼容旧编译器的回退默认**，不是第二个真源：调用方通过 `maxMembers` 把
- * `Config.maxMembers` 传进来，编译器支持 `--max-members` 时以传入值为准（见 `build()`）。
- */
-export const COMPILER_DEFAULT_MAX_MEMBERS = 8;
-
-/**
- * @param generator - 小队编译器路径。调用方**只有传包内那份**才是安全且正确的接线：
- *   `lib/index.js` 现在**只**传 `<包>/data/team-profiles.py`，**不回退**数据目录副本。
- *   为什么：数据目录那份是 bootstrap 播种的**用户可写**文件，让「保存小队」去执行它
- *   等于一条同权限代码执行面，且它与包内版本的漂移无法校验（C-3）。
- *   本函数保留「未传就取同目录 `team-profiles.py`」的默认，只是为了直连数据层的调用方
- *   （自检 / 面板预览脚本）不必显式传路径 —— **插件运行路径绝不走这个默认**。
- * @param maxMembers - 成员上限（来自 `Config.maxMembers`）。只有编译器声明支持 `--max-members`
- *   时才会真正生效；旧编译器把上限写死在源码里，此时会**记一条 warn** 并退回它的默认值，
- *   而不是让保存小队在「改大上限」后必然编译失败并回滚（D-14）。
- * @param onReload - 小队保存**编译成功之后**的热重载回调（由 `lib/index.js` 注入：它持有团队引擎的
- *   fiber，用新的 profiles 重挂引擎）。数据层不碰 `ctx`：这里只负责在正确时机敲门。
- *   回调返回 `{ ok: true }` 表示重载成功；`{ ok: false, detail }` 表示重载失败（原因要能报给用户）。
- *   **没有注入时不算成功**：那与"重载失败"是同一个后果（盘上是新配置、引擎还在用旧的），
- *   所以会记成 `lastReload.ok === false` 并带出明确原因，而不是静默当成功（见 `scheduleReload()`）。
- *   编译失败并回滚时本回调**绝不**被调用：那时盘上还是旧配置，重载只会重新加载同一份旧配置
- *   （见 `save()`）。
- * @param logger - 宿主 logger（`ctx.logger`，可选）。小队编译/重载的诊断**必须走这里**，
- *   不能写 `console`：桌面与 Web 里 stderr 用户看不见，等于这条失败从来没被上报过
- *   （与 `catalog.js` 的 N-3 同一条口径）。
- *   **没有注入时也不写 console**：那正是「用户看不见」的老毛病，宁可静默也不能假装报了。
- */
-export function createSquadService({ teamsFile, catalog, python = "python3", generator: generatorPath, maxMembers, onReload, logger }) {
-  const dataDir = dirname(teamsFile);
-  const generator = typeof generatorPath === "string" && generatorPath !== ""
-    ? generatorPath
-    : join(dataDir, "team-profiles.py");
-  const memberLimit = typeof maxMembers === "number" && Number.isSafeInteger(maxMembers) && maxMembers > 0
-    ? maxMembers
-    : COMPILER_DEFAULT_MAX_MEMBERS;
-  // 编译器能力探测**只做一次**（读它自己的源码找 flag）：比「先试传、失败再重跑」便宜，
-  // 也不会在 argparse 报错时留下半跑过的生成物。
-  const generatorSupportsMemberLimit = existsSync(generator)
-    ? readFileSync(generator, "utf8").includes("--max-members")
-    : false;
-  /** 诊断一律走宿主 logger（见 `logger` 参数的说明）：console 在 GUI 里无人可见。 */
-  const logError = (message) => logger?.error?.(`[t-team] ${message}`);
-  let lastBuild = { at: 0, ok: true, output: "" };
-  /** 正在跑的编译（见 `build()`）：并发调用合并成同一次，避免共享的 `lastBuild` 被交错覆盖。 */
-  let buildInFlight;
-  /**
-   * 热重载的**串行尾**：连续快速保存时，后一次重载必须等前一次结束再开始。
-   *
-   * 不只是节流：引擎重挂期间它自己的 fiber 处于 unload→load 过渡，并发重挂会让两次
-   * dispose/apply 交叠，最后一次重挂会在「已卸载」的中间态上跑，留下半死的引擎。
-   * 用一条 promise 链把重载串起来，天然满足「重载中不得并发重载」。
-   */
-  let reloadTail;
-  /**
-   * 最近一次**已完成**的重载结果（诊断用：设置页面板与系统提示段都读它）。
-   * 初值是 ok:true —— 「还没重载过」不等于失败。
-   */
-  let lastReload = { at: 0, ok: true, detail: "" };
-
-  function readSpec() {
-    try {
-      const spec = JSON.parse(readFileSync(teamsFile, "utf8"));
-      return spec !== null && typeof spec === "object" ? spec : {};
-    } catch (error) {
-      throw fail("tTeam/squads-unreadable", `读不到小队定义 ${teamsFile}：${String(error)}`);
-    }
-  }
-
-  function revisionOf() {
-    try {
-      const stat = statSync(teamsFile);
-      const hash = createHash("sha256").update(readFileSync(teamsFile)).digest("hex").slice(0, 12);
-      return `${stat.mtimeMs.toString(36)}-${hash}`;
-    } catch {
-      return "missing";
-    }
-  }
-
-  /** 名册快照（成员选择器用）：slug / 中英文名 / 分区 / 是否已启用。 */
-  async function roster() {
-    let experts = [];
-    let enabled = new Set();
-    try {
-      // 名册服务的 snapshot() 是异步的（它要读 settings），必须 await。
-      const snapshot = await catalog?.snapshot?.();
-      experts = snapshot?.experts ?? [];
-      enabled = new Set(snapshot?.enabled ?? []);
-    } catch {
-      /* 名册不可用时只给小队本身 */
-    }
-    const bySlug = new Map(experts.map((expert) => [expert.slug, expert]));
-    return {
-      experts: experts.map((expert) => ({
-        slug: expert.slug,
-        name: expert.name,
-        nameZh: expert.nameZh ?? expert.name,
-        division: expert.division,
-        divisionZh: expert.divisionZh ?? expert.division,
-        enabled: enabled.has(expert.slug),
-        conflict: expert.conflict === true,
-      })),
-      bySlug,
-    };
-  }
-
-  function describeMembers(members, bySlug) {
-    return (Array.isArray(members) ? members : []).map((member) => {
-      const slug = memberSlug(member);
-      const expert = bySlug.get(slug);
-      return {
-        slug,
-        role: typeof member === "object" && member !== null && typeof member.role === "string" ? member.role : "",
-        name: expert?.name ?? slug,
-        nameZh: expert?.nameZh ?? expert?.name ?? slug,
-        division: expert?.division ?? "",
-        divisionZh: expert?.divisionZh ?? expert?.division ?? "",
-        known: expert !== undefined,
-      };
-    });
-  }
-
-  async function list() {
-    const spec = readSpec();
-    const { bySlug, experts } = await roster();
-    const rawProfiles = spec.profiles !== null && typeof spec.profiles === "object" ? spec.profiles : {};
-    const squads = Object.entries(rawProfiles).map(([key, profile]) => {
-      const source = profile !== null && typeof profile === "object" ? profile : {};
-      return {
-        key,
-        description: text(source.description),
-        aliases: Array.isArray(source.aliases) ? source.aliases.filter((alias) => typeof alias === "string") : [],
-        taskPlanning: source.taskPlanning === "seed" ? "seed" : "captain",
-        // 缺省视为启用（老定义没有这个字段）
-        enabled: source.enabled !== false,
-        members: describeMembers(source.members, bySlug),
-      };
-    });
-    return {
-      revision: revisionOf(),
-      teamsFile,
-      squads,
-      experts,
-      engine: spec.engine ?? {},
-      defaults: spec.defaults ?? {},
-      lastBuild,
-      lastReload,
-      reloading: reloadTail !== undefined,
-    };
-  }
-
-  /** 编译器**实际**会执行的上限：旧编译器不认 --max-members，用它写死的默认值。 */
-  const effectiveMemberLimit = () => (generatorSupportsMemberLimit ? memberLimit : COMPILER_DEFAULT_MAX_MEMBERS);
-
-  /** 校验（生成器之外的第一道闸门，错误信息面向面板）。 */
-  function validate(squads) {
-    if (!Array.isArray(squads) || squads.length === 0) {
-      throw fail("tTeam/squads-invalid", "至少要保留一个小队。");
-    }
-    const seenKeys = new Set();
-    const seenAliases = new Map();
-    squads.forEach((squad, index) => {
-      const label = `第 ${index + 1} 个小队`;
-      const key = text(squad?.key).trim();
-      if (!KEY_RE.test(key)) {
-        throw fail("tTeam/squads-invalid", `${label} 的 key「${key}」不合法：只能用小写字母、数字和连字符（例如 t-team-writing）。`);
-      }
-      if (seenKeys.has(key)) throw fail("tTeam/squads-invalid", `小队 key 重复：${key}`);
-      seenKeys.add(key);
-      const members = Array.isArray(squad?.members) ? squad.members.map(memberSlug).filter((slug) => slug !== "") : [];
-      if (members.length === 0) throw fail("tTeam/squads-invalid", `「${key}」没有成员：至少要选一位专家。`);
-      // 上限只有一个真源，但旧编译器**执行不了** Config 的值：直接挡在保存前，并把原因说清，
-      // 而不是把 10 人小队写下去、让编译器报「超过上限 8」再回滚（D-14 的可见形态）。
-      const limit = effectiveMemberLimit();
-      if (members.length > limit) {
-        throw fail("tTeam/squads-invalid",
-          `「${key}」有 ${members.length} 位成员，超过当前生效上限 ${limit}。`
-          + (generatorSupportsMemberLimit
-            ? "（上限来自 Config.maxMembers）"
-            : `该编译器版本不支持 --max-members，只能按它内置的 ${COMPILER_DEFAULT_MAX_MEMBERS} 执行；请更新 data/team-profiles.py 后再调大 Config.maxMembers。`));
-      }
-      for (const alias of Array.isArray(squad?.aliases) ? squad.aliases : []) {
-        const value = text(alias).trim();
-        if (value === "") continue;
-        const owner = seenAliases.get(value);
-        if (owner !== undefined && owner !== key) {
-          throw fail("tTeam/squads-invalid", `别名「${value}」被 ${owner} 和 ${key} 同时占用，会让 /t 无法判断用哪个小队。`);
-        }
-        seenAliases.set(value, key);
-      }
-    });
-  }
-
-  /** 把 UI 传来的小队列表写回 teams.json（保留 engine/defaults 等顶层字段）。 */
-  function serialize(spec, squads) {
-    const previous = spec.profiles !== null && typeof spec.profiles === "object" ? spec.profiles : {};
-    const profiles = {};
-    for (const squad of squads) {
-      const key = text(squad.key).trim();
-      const members = (Array.isArray(squad.members) ? squad.members : [])
-        .map(memberSlug)
-        .filter((slug) => slug !== "");
-      // 保留面板没建模的字段（personaMode / personaBudget 等），只覆盖面板负责的那几项。
-      const merged = {
-        ...(previous[key] !== null && typeof previous[key] === "object" ? previous[key] : {}),
-        description: text(squad.description),
-        aliases: (Array.isArray(squad.aliases) ? squad.aliases : [])
-          .map((alias) => text(alias).trim())
-          .filter((alias) => alias !== ""),
-        taskPlanning: squad.taskPlanning === "seed" ? "seed" : "captain",
-        members,
-      };
-      if (squad.enabled === false) merged.enabled = false;
-      else delete merged.enabled;
-      profiles[key] = merged;
-    }
-    return { ...spec, profiles };
-  }
-
-  /**
-   * 跑生成器：编译 t-team.config.json + teams.resolved.json（失败即回滚 teams.json）。
-   *
-   * **异步、且不得并发**（P-1）：这里过去用 `execFileSync`，保存一次小队就把整个 Host 事件
-   * 循环同步阻塞（最长 60s）—— 同一进程里所有会话的 SSE、工具调用与 Web 请求全部停摆。
-   * 改成 `await execFile(...)` 之后事件循环继续转，但会引入原来不存在的交错点：两次 `build()`
-   * 可能并行运行，共享的 `lastBuild` 会被先完成的那次覆盖。所以用一条 in-flight promise 把
-   * 并发调用**合并成同一次**（语义上也更正确：同时刻的 teams.json 只该被编译一次）。
-   *
-   * @returns {Promise<{at:number, ok:boolean, output:string}>}
-   */
-  function build() {
-    if (buildInFlight !== undefined) return buildInFlight;
-    const run = (async () => {
-      if (!existsSync(generator)) {
-        lastBuild = { at: Date.now(), ok: false, output: `找不到生成器 ${generator}` };
-        return lastBuild;
-      }
-      try {
-        // 上限随 Config 走；旧编译器（无 --max-members）退回它写死的默认值并明确告警。
-        if (memberLimit !== COMPILER_DEFAULT_MAX_MEMBERS && !generatorSupportsMemberLimit) {
-          lastBuild = {
-            at: Date.now(),
-            ok: true,
-            output: `[warn] 小队编译器不支持 --max-members（${generator}），成员上限仍按它内置的 ${COMPILER_DEFAULT_MAX_MEMBERS} 执行：`
-              + `超过 ${COMPILER_DEFAULT_MAX_MEMBERS} 人的小队会编译失败，Config.maxMembers=${memberLimit} 不会生效。`
-              + `要真正用上它，请把 data/team-profiles.py 更新到带 --max-members 的版本。`,
-          };
-        }
-        const memberArgs = generatorSupportsMemberLimit ? ["--max-members", String(memberLimit)] : [];
-        // 参数与 execFileSync 时代逐项一致（数组传参、无 shell、60s 上限），只换执行方式。
-        const { stdout, stderr } = await runFile(python, [generator, "--teams", teamsFile, ...memberArgs], {
-          cwd: dataDir,
-          encoding: "utf8",
-          timeout: 60_000,
-          maxBuffer: 4 * 1024 * 1024,
-        });
-        const parts = [stdout, stderr].map((part) => text(part).trim()).filter((part) => part !== "");
-        lastBuild = { at: Date.now(), ok: true, output: parts.join("\n").split("\n").slice(-6).join("\n") };
-      } catch (error) {
-        const output = [error?.stdout, error?.stderr].map((part) => text(part).trim()).filter((part) => part !== "").join("\n");
-        lastBuild = { at: Date.now(), ok: false, output: output === "" ? String(error) : output };
-      }
-      return lastBuild;
-    })().finally(() => {
-      if (buildInFlight === run) buildInFlight = undefined;
-    });
-    buildInFlight = run;
-    return run;
-  }
-
-  /**
-   * 引擎热重载：保存成功后，让运行中的引擎用**新的** profiles 重挂，无需重启 DSH。
-   *
-   * 为什么必须在这里做：`/t` 列表每次从磁盘读（`lib/command.js` 的 `readTeams`），而引擎的
-   * profiles 是挂载期快照 —— 两者过去只在「重启」这一个点上重新对齐。保存是唯一让磁盘
-   * 配置变化的地方，所以在**编译成功之后**敲门重载是恢复一致性的正确时机。
-   *
-   * 三条不可动摇的语义：
-   *   1. 编译失败并回滚 → **不调用**（见 `save()`：回滚分支在调用点之前就抛了）；
-   *   2. 重载失败**不改抛**——盘上已经是新配置，抛错会让用户以为「保存没生效」而不停重试；
-   *      失败原因通过返回值进 `lastReload`、日志与系统提示段，用户/模型都看得到；
-   *   3. 重载串行化：并发保存不会产生并发重挂。
-   */
-  function scheduleReload() {
-    const run = (reloadTail ?? Promise.resolve()).then(async () => {
-      if (typeof onReload !== "function") {
-        // **绝不能静默当成功**：没有注入重载方意味着「保存生效了、引擎还用着旧 profiles」，
-        // 与"重载失败"是同一个可观察后果。记成失败（lastReload.ok=false + 原因），
-        // 系统提示段与 lastReload 都会带出去，用户/模型复述得到的是真实状态。
-        // 唯一的合法场景是单测直接构造数据层（此时没人会读 lastReload）。
-        lastReload = {
-          at: Date.now(),
-          ok: false,
-          detail: "没有注入热重载回调（onReload）：这次保存已写入磁盘，但引擎仍在使用上一次的小队配置，需要重载插件或重启 DSH 才能用新小队建队。",
-        };
-        logError(lastReload.detail);
-        return;
-      }
-      const outcome = await onReload();
-      const ok = outcome?.ok !== false;
-      lastReload = { at: Date.now(), ok, detail: text(outcome?.detail) };
-      if (!ok) {
-        // 失败必须响：重载失败意味着"保存生效了、但运行中的引擎还用着旧 profiles"。
-        logError(`小队已保存，但团队引擎热重载失败：${lastReload.detail}`);
-      }
-    }).catch((error) => {
-      // 注入方自己抛错（契约违背）也要留住，不能让保存报告成"一切正常"。
-      lastReload = { at: Date.now(), ok: false, detail: String(error) };
-      logError(`小队已保存，但团队引擎热重载异常：${lastReload.detail}`);
-    }).finally(() => {
-      if (reloadTail === run) reloadTail = undefined;
-    });
-    reloadTail = run;
-    return run;
-  }
-
-  async function save(squads, expectedRevision) {
-    validate(squads);
-    const current = revisionOf();
-    if (typeof expectedRevision === "string" && expectedRevision !== "" && expectedRevision !== current) {
-      throw fail("tTeam/squads-conflict", "小队定义已在别处改动，请刷新后重试。", {
-        expectedRevision,
-        actualRevision: current,
-      });
-    }
-    const previousText = readFileSync(teamsFile, "utf8");
-    const nextSpec = serialize(readSpec(), squads);
-    // 原子写（P-2）：先写临时文件再 rename。进程若在写入中途被杀，原来会留下**截断的**
-    // teams.json，`readSpec()` 随即抛 `tTeam/squads-unreadable`，设置页「小队」标签整体不可用。
-    await writeFileAtomic(teamsFile, `${JSON.stringify(nextSpec, null, 2)}\n`);
-    const built = await build();
-    if (!built.ok) {
-      await writeFileAtomic(teamsFile, previousText); // 回滚，别把坏定义留在盘上（同样原子）
-      // 回滚之后**不重载**：盘上是旧配置，重载只会重新加载同一份旧配置，白跑一次还可能
-      // 让「保存失败」看起来像「保存成功」。下一次成功保存会重新对齐。
-      throw fail("tTeam/squads-build-failed", `配置生成失败，已回滚 teams.json：\n${built.output}`, {
-        actualRevision: revisionOf(),
-      });
-    }
-    // 编译成功 = 新配置已经落在盘上（`build()` 写的正是引擎启动时读的那份），现在敲门重载。
-    const settled = scheduleReload();
-    const result = await list();
-    // 有重载还在跑时（可能是本次的，也可能是上一次的尾巴）就等它结束：这样本次保存返回的
-    // `lastReload` 才名副其实，调用方（自检探针 / 未来的面板）能直接读到「这次保存到底重载
-    // 成功没有」。等待期间系统提示段已经把真相写出来了，不会误导。
-    await settled;
-    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, resync, revision: revisionOf, generator, dataDir,
-    // 本服务没有 `dispose()`：它只在 `save()` 调用期间持有状态（重载串行尾由 save() 自己 await
-    // 干净），两次调用之间是无状态的，所以宿主卸载时没有需要收尾的异步工作。
-    // 让调用方（与自检）看得到「这次编译用的是哪个上限、编译器到底认不认这个参数」。
-    memberLimit,
-    generatorSupportsMemberLimit,
-  };
-}

package/lib/teams/assignee-contract.js

@@ -1,47 +0,0 @@
-/**
- * 「谁能当 assignee」的契约 —— 一处定义，三处复用。
- *
- * `captain` 是引擎的**预留键**，不是成员：`add_member` 明确禁止把成员命名成
- * captain（`tools.js`），成员表里也永远查不到它。
- *
- * 但同名参数 `assignee` 在三个入口里的合法取值**并不相同**：
- *
- * | 入口 | `assignee="captain"` |
- * |---|---|
- * | `t_team_create_task` | ✗ 拒绝（本模块的报错） |
- * | `t_team_reassign_task` | ✓ 队长接管，由它自己开旁路并执行接管约束 |
- * | `t_team_plan_check` | ✗ 拒绝（与 create_task 一致） |
- *
- * 为什么不干脆让 create_task 也接受：队长接管受两条**只能在接管阶段**判断的约束
- * （依赖未完成的阻塞任务不能被接管；同一时刻只能持有 1 个未完成接管任务），
- * 而建图时任务还是 pending、两条都无据可查。放开等于绕开安全闸。
- *
- * 因此正确做法是：**建任务不给 assignee（进共享池），等依赖完成后用
- * `reassign_task(task_id, assignee="captain")` 接管**。
- *
- * 曾经的缺陷：create_task 直接把它丢给按成员名精确匹配的 `requireMember()`，
- * 于是只回一句 `no active member named "captain"`，不提示正确入口 ——
- * 模型自然会重试同一条路。本模块存在的意义就是把这个岔路口说清楚。
- * @module t-team/assignee-contract
- */
-import { CAPTAIN_KEY } from "./state.js";
-
-/** create_task / plan_check 对 reserve 键的标准报错文案（含可执行的下一步）。 */
-export const CAPTAIN_ASSIGNEE_HINT = 'captain 是引擎预留键、不是成员，create_task 不能把任务派给队长；'
-    + '请不带 assignee 建任务（进共享池），等依赖完成后再用 t_team_reassign_task(task_id, assignee="captain") 接管'
-    + '（依赖未完成的任务不能被接管，且队长同一时刻只能持有 1 个未完成接管任务）';
-
-/**
- * 在 create_task / plan_check 的 assignee 校验位拦下预留键。
- * 大小写与空白无关（`Captain`、` CAPTAIN ` 同样拦下），与 `sanitizeKey` 的语义对齐。
- * @param {unknown} assignee 调用方给的 assignee 原值
- * @returns {string | undefined} 通过时返回清洗后的成员名，未给 assignee 时返回 undefined
- * @throws {Error} 取值等价于 captain 时抛出，文案即 `CAPTAIN_ASSIGNEE_HINT`
- */
-export function normalizeAssigneeForCreate(assignee) {
-    if (typeof assignee !== 'string') return undefined;
-    const trimmed = assignee.trim();
-    if (trimmed === '') return undefined;
-    if (trimmed.toLowerCase() === CAPTAIN_KEY) throw new Error(CAPTAIN_ASSIGNEE_HINT);
-    return trimmed;
-}

package/lib/teams/capabilities.js

@@ -1,106 +0,0 @@
-import { readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { readTeamSync, readRetiredMemberIdsSync } from "./state.js";
-import { MEMBER_TOOL_NAMES, TEAM_TOOL_NAMES } from "./tool-names.js";
-export const TEAM_ACTIVATION_PROMPT = 'T Team （T专家 团队） provides multi-agent team collaboration. Apply these rules when the user requests it (including /t-team) or when continuing an existing team. Mentioning, quoting, discussing, or declining T Team alone is not a request to start work.';
-export const TEAM_MEMBER_PROMPT = 'You are a T Team member. Follow your assigned member persona and task contract. Use t_team_claim_task, t_team_update_task, t_team_send_message and t_team_status for your own work. Include the current attempt_id in updates; report completion or failure to the captain. Do not create, approve, edit or resume a team. If your durable membership is unavailable, report that to the parent instead of creating a replacement.';
-function stateRoot(agent, config) {
-    return join(agent.session.header.cwd ?? process.cwd(), config.stateDir);
-}
-/** Synchronous startup/HMR hydration must finish before the first assembly. */
-function currentTeam(agent, config) {
-    const root = stateRoot(agent, config);
-    let entries;
-    try {
-        entries = readdirSync(root, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw error;
-    }
-    let found;
-    for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name === 'archive')
-            continue;
-        const team = readTeamSync(root, entry.name);
-        if (team === undefined || (team.captainSessionId !== agent.id
-            && !team.members.some(member => member.id === agent.id)))
-            continue;
-        if (found !== undefined)
-            throw new Error('ambiguous T Team membership');
-        found = team;
-    }
-    return found;
-}
-/** Call once, after all business definitions have registered. Never per member. */
-export function installTeamCapabilities(ctx, config) {
-    const states = new WeakMap();
-    const active = new Set();
-    let mounted = true;
-    // Snapshot policy once: profiles, team state, and tool results must never
-    // rewrite this prefix or control whether core instructions are available.
-    const captainPrompt = `${TEAM_ACTIVATION_PROMPT}\n\n${config.captainPrompt()}`;
-    function attach(agent) {
-        const prior = states.get(agent);
-        if (prior !== undefined)
-            return prior;
-        if (!mounted)
-            throw new Error('T Team capability provider is disposed');
-        // Determine a member's role before its first request and retain it for the
-        // lifetime of this scope. Team creation/archive must never rewrite the
-        // captain's system/tools prefix, even after a long ordinary conversation.
-        let member = config.isPendingMember(agent);
-        try {
-            member ||= readRetiredMemberIdsSync(stateRoot(agent, config)).has(agent.id);
-            const team = currentTeam(agent, config);
-            member ||= team !== undefined && team.captainSessionId !== agent.id;
-        }
-        catch (error) {
-            // Unrelated damaged state must not disable ordinary conversation.
-            // Business tools still validate durable team state before acting.
-            ctx.logger.warn(`t-team: capability hydration failed: ${String(error)}`);
-        }
-        const state = { member, dispose: () => undefined };
-        let revoke;
-        let disposed = false;
-        let releaseLifetime;
-        state.dispose = () => {
-            if (disposed)
-                return;
-            disposed = true;
-            revoke?.();
-            releaseLifetime?.();
-            states.delete(agent);
-            active.delete(state);
-        };
-        states.set(agent, state);
-        active.add(state);
-        try {
-            if (member)
-                revoke = agent.ctx.tools.restrict({
-                    deny: TEAM_TOOL_NAMES.filter(name => !MEMBER_TOOL_NAMES.includes(name)),
-                });
-            releaseLifetime = agent.ctx.effect(() => state.dispose, 't-team: capability lifetime');
-            return state;
-        }
-        catch (error) {
-            state.dispose();
-            throw error;
-        }
-    }
-    ctx.systemPrompt.section({
-        name: 't-team:usage', order: config.order ?? 117,
-        text: ({ agent }) => {
-            return agent !== undefined && states.get(agent)?.member ? TEAM_MEMBER_PROMPT : captainPrompt;
-        },
-    });
-    ctx.on('agent/session-start', ({ agent }) => { attach(agent); });
-    ctx.effect(() => () => {
-        mounted = false;
-        for (const state of [...active])
-            state.dispose();
-    }, 't-team: capability scopes');
-    for (const agent of ctx.agents.list())
-        attach(agent);
-}