dsh-plugin-t-expert 0.3.88 → 0.3.89

package/lib/command.js

@@ -1,251 +0,0 @@
-// @ts-check
-/**
- * `/t` —— T专家 的小队短命令。
- *
- * 只做一件事：把 `/t <小队> <目标>` 翻译成引擎认得的手势消息
- * `/t --profile <key> <目标>`（引擎的手势边界认得这个形状），并作为**一条真实用户消息**投递回去；
- * 之后由引擎的 `agent/pre-step` 手势边界接手。
- * 也就是说：引擎 100% 复用内置的团队引擎（lib/teams/），T专家 只提供「人 + 短命令」。
- */
-import { readFileSync } from "node:fs";
-import { createUserMessage } from "@deepseek-ai/dsh-llm";
-
-export const COMMAND_NAME = "t";
-
-/** 把两种来源的成员写法归一成 { name, role }：
- *  - team-profiles.py 生成的 teams.resolved.json：成员已是对象
- *  - 人工维护的 teams.json：成员是专家 slug 字符串
- */
-function normalizeMembers(members) {
-  if (!Array.isArray(members)) return [];
-  return members
-    .map((member) => {
-      if (typeof member === "string") return { name: member, role: member };
-      if (member !== null && typeof member === "object" && typeof member.name === "string") {
-        return { name: member.name, role: typeof member.role === "string" ? member.role : member.name };
-      }
-      return undefined;
-    })
-    .filter((member) => member !== undefined);
-}
-
-/** 归一成 { description, aliases, taskPlanning, members }，缺字段给安全默认值。 */
-function normalizeProfile(profile) {
-  const source = profile !== null && typeof profile === "object" ? profile : {};
-  return {
-    description: typeof source.description === "string" ? source.description : "",
-    aliases: Array.isArray(source.aliases) ? source.aliases.filter((a) => typeof a === "string") : [],
-    taskPlanning: source.taskPlanning === "seed" ? "seed" : "captain",
-    members: normalizeMembers(source.members),
-  };
-}
-
-/**
- * 每次调用都从磁盘读小队定义（改名单不需要重启）：
- * 优先读同目录下由 team-profiles.py 生成的 `teams.resolved.json`（成员带中文名），
- * 缺失时回退人工维护的 `teams.json`（成员是 slug）。
- */
-export function readTeams(file) {
-  const candidates = [file.replace(/teams\.json$/u, "teams.resolved.json"), file];
-  for (const candidate of candidates) {
-    try {
-      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-      const profiles = parsed?.profiles;
-      if (profiles === null || typeof profiles !== "object" || Array.isArray(profiles)) continue;
-      const out = {};
-      for (const [key, profile] of Object.entries(profiles)) out[key] = normalizeProfile(profile);
-      if (Object.keys(out).length > 0) return out;
-    } catch {
-      /* 试下一个候选 */
-    }
-  }
-  return {};
-}
-
-/** 归一化：小写、去空白、全角转半角（中文别名不受影响）。 */
-function normalizeToken(value) {
-  return String(value ?? "")
-    .trim()
-    .toLowerCase()
-    .replace(/[\uFF01-\uFF5E]/gu, (ch) => String.fromCharCode(ch.charCodeAt(0) - 0xfee0))
-    .replace(/[\s\u3000]/gu, "");
-}
-
-/**
- * 用 profile key 或别名找小队。三轮：① 精确（key/别名）② 双向子串（用户多打或少打字）
- * ③ 多个别名命中同一小队时视为命中（例如「写首诗」同时含「诗」与「写」两个别名）。
- */
-export function resolveTeam(profiles, query) {
-  const needle = normalizeToken(query);
-  if (needle === "") return undefined;
-  const entries = Object.entries(profiles).map(([key, profile]) => ({
-    key,
-    profile,
-    tokens: [key, ...(Array.isArray(profile?.aliases) ? profile.aliases : [])].map(normalizeToken).filter((t) => t !== ""),
-  }));
-  for (const entry of entries) {
-    if (entry.tokens.some((token) => token === needle)) return { key: entry.key, profile: entry.profile };
-  }
-  const fuzzy = entries.filter((entry) => entry.tokens.some((token) => token.includes(needle) || needle.includes(token)));
-  if (fuzzy.length === 1) return { key: fuzzy[0].key, profile: fuzzy[0].profile };
-  const multi = entries.filter((entry) => entry.tokens.filter((token) => needle.includes(token)).length >= 2);
-  if (multi.length === 1) return { key: multi[0].key, profile: multi[0].profile };
-  return undefined;
-}
-
-/** 小队一句话摘要（给队长复述用）。 */
-function describeProfile(key, profile) {
-  const members = Array.isArray(profile?.members) ? profile.members : [];
-  const names = members.map((member) => member.name).filter((name) => typeof name === "string");
-  const aliases = Array.isArray(profile?.aliases) && profile.aliases.length > 0 ? `（别名 ${profile.aliases.join(" / ")}）` : "";
-  return `${key}${aliases} — ${profile?.description ?? ""}${names.length > 0 ? ` · ${names.length} 人：${names.join("、")}` : ""}`;
-}
-
-/**
- * 让队长把信息**用中文说出来**的投递文本。
- *
- * 为什么不用命令的返回值：部分 DSH 版本里命令行的结果行不渲染（用户「发了命令没任何反应」），
- * 而 followup 消息一定会渲染成可见对话。所以 `/t` 的每一种结果都投一条可读指令给队长。
- */
-function relayListDirective(list) {
-  return [
-    "【T专家 · 小队列表】用户敲了 `/t`（没有带目标），请直接用中文把下面的小队列表回复给用户，",
-    "并带一句用法提示：`/t <小队|别名> <目标>`。不要创建团队、不要调用建队工具。",
-    "",
-    list,
-  ].join("\n");
-}
-
-function relayPickDirective(key, profile) {
-  const members = Array.isArray(profile?.members) ? profile.members : [];
-  const names = members.map((member) => member.name).filter((name) => typeof name === "string");
-  return [
-    `【T专家 · 已选定小队：${key}】用户敲了 \`/t ${key}\` 但没给目标。`,
-    "请用中文先列出这个小队的成员，再问用户这次要完成什么。现在不要建队、不要调用建队工具。",
-    "",
-    `小队：${describeProfile(key, profile)}`,
-    names.length > 0 ? `成员：${names.join("、")}` : "成员：尚未解析（跑一次 team-profiles.py）",
-  ].join("\n");
-}
-
-function relayRouteDirective(input, list) {
-  return [
-    `【T专家 · 未指定小队】用户敲的是：\`/t ${input}\`，其中没有能匹配到小队名的词。`,
-    `请把「${input}」当作目标，从下面的小队里挑最合适的一个，然后**直接调用 t_team_create 并带上 profile="<key>"** 建队（approval=\"required\" 先 staged，等用户在面板 review）；`,
-    "不要反问用户该用哪个小队，也不要自己手搭成员——profile 已带好成员与人格。",
-    // profile 描述的是「这类目标通常涉及哪些角色」，不是「这次必须全员上场」。不写清这一条，
-    // 队长会把它读成「roster 不可动」，于是为了不让人闲着而给边缘角色硬造任务：实测一份单文件
-    // HTML 简历被派给了 5 个人 —— 后端架构师去写「信息架构」、数据库性能工程师去查「A4 分页」。
-    // 那次的队长思考里两处原话正是「有点牵强」「这有点为凑人头造工作」，但它仍然照派了。
-    "但 profile 是「编制清单」，不等于这次全员都得上场：挑定小队后先逐人自问「这次真的需要这个角色的独有产出吗」，用不上的在 staged 阶段用 t_team_edit_plan 的 remove_member 裁掉。",
-    "顺序必须是**先裁人、后建任务**——任务一旦引用了成员，再删人就得先改依赖引用。拿不准的一律保留，且至少留 2 人（一个产出者 + 一个独立验证者，否则独立验证无从谈起）。",
-    "无论裁没裁，都要在给用户的计划说明里写明留了谁、裁了谁、为什么。",
-    "若确实没有合适的小队，就用中文说明原因并列出可用小队。",
-    "",
-    list,
-  ].join("\n");
-}
-
-/** `/t` 无参数时的列表。 */
-export function renderTeamList(profiles) {
-  const keys = Object.keys(profiles);
-  if (keys.length === 0) {
-    return "还没有配置小队。打开 设置 → T专家 → 小队 保存一次就会生成（保存时用数据目录里的 team-profiles.py 编译引擎配置）。";
-  }
-  const lines = ["T专家 小队（用 /t <小队> <目标> 拉起）："];
-  for (const key of keys) {
-    const profile = profiles[key] ?? {};
-    const members = Array.isArray(profile.members) ? profile.members : [];
-    const names = members.map((member) => member.name).filter((name) => typeof name === "string");
-    const aliases = Array.isArray(profile.aliases) && profile.aliases.length > 0
-      ? `（别名 ${profile.aliases.join(" / ")}）`
-      : "";
-    const detail = names.length > 0 ? `${names.length} 人：${names.join("、")}` : "尚未解析成员（跑一次 team-profiles.py）";
-    lines.push(`- ${key}${aliases} — ${profile.description ?? ""} · ${detail}`);
-  }
-  lines.push("也可以直接用引号里的完整写法：/t --profile <key> <目标>");
-  return lines.join("\n");
-}
-
-/**
- * 注册 `/t`。
- * @param ctx 宿主上下文（需要 `effect` / `logger` 等完整能力）
- * @param {object} options 注册选项
- * @param {string} options.teamsFile teams.json 路径（通常与名册同目录）
- * @param {() => boolean} options.hasEngine 探测内置团队引擎是否在位的函数
- * @param {() => string} [options.engineError] 引擎不可用时的原因（报给用户）
- * @param {object} [options.commands] 已解析好的 commands 服务（可选服务的时序修复，见下）
- */
-export function registerTeamCommand(ctx, options) {
-  const teamsFile = options.teamsFile;
-  const hasEngine = options.hasEngine;
-  // ⚠️ 2026-09-13：`commands` 是**可选服务**，真实宿主里它**晚于本插件 apply** 才就绪；
-  // 而 `ctx.get("commands")` 在那一刻是 undefined，且 cordis 的 `provide` **不回溯通知**已跑过的代码
-  // —— 于是 `/t` 永远不会注册。调用方已用 `ctx.inject(["commands"], …)` 等到就绪后把服务传进来；
-  // 这里再兜底懒查一次（直连调用/测试），两条路都不做属性访问。
-  const commands = options.commands ?? ctx.get?.("commands");
-  if (typeof commands?.register !== "function") {
-    ctx.logger?.warn?.("[t-team] 没有可用的 commands 服务：/t 命令不注册。");
-    return;
-  }
-  ctx.effect(() => commands.register({
-    name: COMMAND_NAME,
-    description: "用 T专家 小队执行一个目标（底层走 T专家 内置的多智能体团队引擎）",
-    input: { hint: "<小队名|别名> <目标>" },
-    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专家 内置的团队引擎没有注册成功（它的工具没有出现在工具表里）。"
-          : `团队引擎挂载失败：${detail}`;
-        // 命令结果行在部分 DSH 版本不渲染，所以连错误也交给队长转述一次。
-        invocation.agent.followup(createUserMessage({
-          content: [{ type: "text", text: `【T专家】团队引擎未就绪，请用中文把这句话转告用户，不要建队：${text}` }],
-          source: { kind: "user" },
-        }));
-        return { kind: "error", text };
-      }
-      const profiles = readTeams(teamsFile);
-      const list = renderTeamList(profiles);
-      const deliver = (text) => invocation.agent.followup(createUserMessage({
-        content: [{ type: "text", text }],
-        source: { kind: "user" },
-      }));
-      const raw = String(invocation?.rawInput ?? "").trim();
-
-      // ① `/t` 裸调用：让队长把小队列表说出来（可见），而不是只塞进命令结果行。
-      if (raw === "" || raw === "list" || raw === "ls" || raw === "help") {
-        deliver(relayListDirective(list));
-        return { kind: "success", text: list };
-      }
-
-      const [head, ...rest] = raw.split(/\s+/u);
-      const goal = rest.join(" ").trim();
-      const hit = resolveTeam(profiles, head);
-
-      // ② 没匹配到小队：不报错了事，让队长按目标自动挑小队（用户不必记得队名）。
-      if (hit === undefined) {
-        deliver(relayRouteDirective(raw, list));
-        return { kind: "success", text: `「${head}」不是小队名——已交给队长按目标挑选小队。` };
-      }
-
-      // ③ 只给了小队名：让队长列成员并问目标。
-      if (goal === "") {
-        deliver(relayPickDirective(hit.key, hit.profile));
-        return { kind: "success", text: `已选定「${hit.key}」，队长会列出成员并问你这次要做什么。` };
-      }
-
-      // ④ 小队 + 目标：投成引擎认得的手势消息，pre-step 边界注入队长协议。
-      deliver(`/t --profile ${hit.key} ${goal}`);
-      const memberCount = Array.isArray(hit.profile?.members) ? hit.profile.members.length : 0;
-      const label = hit.profile?.description || hit.key;
-      return {
-        kind: "success",
-        text: `已激活「${label}」${memberCount > 0 ? `（${memberCount} 人）` : ""} —— 队长会先给出成员与任务草案，等你 review 后再启动。`,
-      };
-    },
-  }), "t-team: /t command");
-}

package/lib/plan-check.js

@@ -1,166 +0,0 @@
-// @ts-check
-/**
- * DAG 预检（只读）：把「打算创建的一整套任务」先跑一遍引擎的校验，**一次报出全部问题**。
- *
- * 为什么需要它：引擎建任务是**逐条**的（依赖只能引用已存在的任务），每条硬校验都单独拒绝，
- * 中途失败会留下半成品，模型再重试就容易出现重复任务（本机实测踩过）。
- * 这里复用引擎自己的 `validateCreateTask`（契约/写域重叠/质量门槛），**并复用引擎导出的
- * `collectStagedGraphProblems`** 做引用与环检查 —— 全部在内存里模拟、不写任何状态。
- *
- * 规则**只有一份**（`lib/teams/tools.js`）：过去这里按同规则复刻过一遍，两处一旦漂移，
- * 预检就会说 ok、真建任务却被引擎拒 —— 而预检的全部意义正是提前发现这种岔路。
- */
-import { CAPTAIN_KEY } from "./teams/state.js";
-import { normalizeAssigneeForCreate } from "./teams/assignee-contract.js";
-import { validateCreateTask } from "./teams/quality-gates.js";
-import { collectStagedGraphProblems } from "./teams/tools.js";
-
-/** 拓扑序（依赖在前）；有环时返回已排好的部分。 */
-function topologicalOrder(tasks) {
-  const ids = new Set(tasks.map((task) => task.id));
-  const byId = new Map(tasks.map((task) => [task.id, task]));
-  const done = new Set();
-  const order = [];
-  const visit = (id) => {
-    if (done.has(id)) return;
-    done.add(id);
-    for (const dependency of byId.get(id)?.dependencies ?? []) if (ids.has(dependency)) visit(dependency);
-    order.push(id);
-  };
-  for (const task of tasks) visit(task.id);
-  return order;
-}
-
-/**
- * @param team 引擎的团队状态（`readTeam` 的返回值）
- * @param tasks 拟创建的任务数组；每项可带 `id`（本批内互相引用的标签，可省略）、`subject`、`kind`、
- *              `dependencies`、`inScope`、`outOfScope`、`verify`、`acceptance`、`objective`、`assignee` 等
- * @returns `{ ok, problems, warnings, order, existing }`
- */
-export function checkPlan(team, tasks) {
-  const proposed = Array.isArray(tasks) ? tasks : [];
-  const existing = Array.isArray(team?.tasks) ? team.tasks : [];
-  const problems = [];
-  const warnings = [];
-  if (proposed.length === 0) problems.push("没有要检查的任务（tasks 为空）");
-
-  // 成员名集合：assignee 必须是活跃成员或 captain
-  const memberNames = new Set(
-    (team?.members ?? []).filter((member) => member.status !== "removed").map((member) => member.name),
-  );
-
-  // 逐条模拟：先做静态检查，再跑引擎的 validateCreateTask（它只看已存在的任务 + 已接受的模拟任务）
-  const sim = { ...(team ?? {}), tasks: [...existing] };
-  const taken = new Set(existing.map((task) => task.id));
-  // 本批 id（标签）→ 引擎会分配的模拟 id。**按声明顺序累积**，不预先解析全批 —— 见
-  // `resolveDependencies` 的说明：引擎要求依赖已存在，前向引用本就建不出来。
-  const labels = new Map();
-  // 每个位置（含**没有 id 的**任务）→ 模拟 id：发号与标签解析必须共用同一次发号，
-  // 否则「只给带 id 的发号」会让报告里的 id 与实际创建顺序不一致。
-  const simulatedIds = [];
-  // 引擎分配的是 `t${team.taskSeq + 1}` 并随后自增（不是"现有任务条数"）。两者只在
-  // taskSeq === tasks.length 时才一致 —— 有任务被删除/取消过就会分叉，所以以 taskSeq 为准。
-  let counter = Number.isSafeInteger(team?.taskSeq) ? team.taskSeq : existing.length;
-  const issueSimulatedId = () => {
-    let simulatedId;
-    do {
-      counter += 1;
-      simulatedId = `t${counter}`;
-    } while (taken.has(simulatedId) || existing.some((task) => task.id === simulatedId));
-    taken.add(simulatedId);
-    return simulatedId;
-  };
-  const resolveDependencies = (raw) => (Array.isArray(raw?.dependencies) ? raw.dependencies : [])
-    .map((dependency) => String(dependency))
-    .map((dependency) => labels.get(dependency) ?? dependency);
-  const report = [];
-
-  proposed.forEach((raw, index) => {
-    const local = [];
-    const wantId = typeof raw?.id === "string" && raw.id.trim() !== "" ? raw.id.trim() : undefined;
-    const simulatedId = issueSimulatedId();
-    simulatedIds[index] = simulatedId;
-    // 登记在本条**解析依赖之后**：这样 `dependencies` 里的同批标签只有「已声明过的」
-    // 才能解析成模拟 id，与引擎的「依赖必须已存在」一致。
-    if (wantId !== undefined) labels.set(wantId, simulatedId);
-
-    const subject = String(raw?.subject ?? "").trim();
-    if (subject === "") local.push("缺少 subject");
-    const kind = typeof raw?.kind === "string" && raw.kind !== "" ? raw.kind : "work";
-    const dependencies = resolveDependencies(raw);
-    if (dependencies.includes(simulatedId)) local.push("不能依赖自己");
-    // 判定「不存在的依赖」时，本批**已声明**的标签算作已知（它们会在模拟里成为真实任务 id）。
-    const unknown = dependencies.filter(
-      (dependency) => !taken.has(dependency) && !labels.has(dependency) && !existing.some((task) => task.id === dependency),
-    );
-    if (unknown.length > 0) local.push(`依赖不存在的任务：${unknown.join(", ")}`);
-    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）`);
-      }
-    }
-
-    // 引擎的契约/写域/质量门槛校验
-    let contract = "";
-    if (local.length === 0) {
-      const verdict = validateCreateTask(sim, {
-        ...raw,
-        subject,
-        kind,
-        dependencies,
-        assignee,
-      });
-      if (verdict.ok !== true) {
-        contract = String(verdict.error ?? "校验未通过");
-        local.push(contract);
-      } else {
-        sim.tasks.push({ ...verdict.task, id: simulatedId, dependencies });
-      }
-    }
-
-    if (local.length > 0) problems.push({ index, id: wantId ?? simulatedId, subject, error: local.join("；") });
-    report.push({ index, id: wantId ?? simulatedId, simulatedId, subject, ok: local.length === 0, error: local.join("；") });
-  });
-
-  // 环/引用检查（含已存在的任务）：**调用引擎导出实现**，不再本地复刻。
-  // 用 requireRunnable=false —— 预检允许"成员还没加"，那是 approve 阶段才要求的。
-  problems.push(...collectStagedGraphProblems(sim, false).map((error) => ({ index: -1, id: "graph", subject: "", error })));
-
-  // 提示（不阻塞）：成员同时只能有 1 个未完成任务（引擎在 claim/reassign 时才会拒）
-  const openStatuses = new Set(["pending", "claimed", "in_progress"]);
-  const busy = new Map();
-  for (const task of existing) {
-    if (task.assignee !== undefined && openStatuses.has(task.status)) busy.set(task.assignee, task.id);
-  }
-  for (const item of report) {
-    if (!item.ok) continue;
-    const assignee = proposed[item.index]?.assignee;
-    if (typeof assignee !== "string" || assignee === "" || assignee === CAPTAIN_KEY) continue;
-    const current = busy.get(assignee);
-    if (current !== undefined) {
-      warnings.push(`成员「${assignee}」已有未完成任务 ${current}（一个成员同时只能有 1 个未完成任务，新任务要等它结束）`);
-    }
-    busy.set(assignee, item.simulatedId);
-  }
-  if (report.length >= 3) {
-    const duplicated = report.map((item) => item.subject).filter((subject, index, all) => subject !== "" && all.indexOf(subject) !== index);
-    if (duplicated.length > 0) warnings.push(`有重复的 subject：${[...new Set(duplicated)].join("、")}（确认不是同一件事被建了两次）`);
-  }
-
-  return {
-    ok: problems.length === 0,
-    problems,
-    warnings: [...new Set(warnings)],
-    order: topologicalOrder(sim.tasks).filter((id) => !existing.some((task) => task.id === id)),
-    existing: existing.map((task) => ({ id: task.id, status: task.status, kind: task.kind ?? "work", assignee: task.assignee ?? "" })),
-  };
-}