dsh-plugin-t-expert 0.2.4 → 0.2.5

package/lib/i18n.js

@@ -20,11 +20,27 @@ const ZH = {
   "error.specsTooMany": "一次最多召唤 {limit} 位专家",
   "error.specInvalid": "experts[{index}] 需要 expert 与 task 两个字段",
   "error.settingsMissing": "T专家 设置段尚未注册",
-  "list.headerAll": "T专家 花名册（已启用 {total} 位，覆盖 {divisions} 个分区）：",
-  "list.headerOne": "分区 {division} 的已启用专家（{count} 位）：",
+  "error.customSlugInvalid": "slug 只能用 a-z、0-9 与连字符，且以字母或数字开头：\"{slug}\"",
+  "error.customSlugTaken": "slug「{slug}」已被内置或自建专家占用",
+  "error.customDivisionInvalid": "分类目录名只能用 a-z、0-9、连字符与点，且以字母或数字开头（中文请填在「显示名」里）：\"{division}\"",
+  "error.categoryOfficial": "「{division}」是官方分类：名字与存亡都跟随名册同步，只能改自建分类",
+  "error.categoryExists": "分类「{division}」已经存在",
+  "error.categoryMissing": "找不到自建分类「{division}」",
+  "error.categoryNotEmpty": "分类「{division}」下还有 {count} 位自建专家：先把它们移到别的分类或删掉，再删这个分类",
+  "error.customNameTaken": "名称「{name}」与已有专家「{other}」重复；重名会让两位都无法被召唤",
+  "error.customNameEmpty": "名称不能为空",
+  "error.customDescriptionEmpty": "简介不能为空（缺简介的专家不会进名册）",
+  "error.customBodyEmpty": "人格正文不能为空（专家靠它工作）",
+  "error.customTextTooLong": "{field} 超过 {limit} 个字符",
+  "error.customNotCustom": "「{slug}」不是自建专家；内置专家由名册同步维护，请用「复制为自建」再改",
+  "error.customMissing": "找不到自建专家「{slug}」",
+  "error.customConflict": "这位自建专家已被别处改动，请关掉编辑框重新打开再改",
+  "error.customRootMissing": "自建专家目录未配置（customRoot）",
+  "list.headerAll": "T专家 花名册（已启用 {total} 位，覆盖 {divisions} 个分类）：",
+  "list.headerOne": "分类 {division} 的已启用专家（{count} 位）：",
   "list.emptyAll": "还没有启用任何专家。请在 设置 → T专家 里启用。",
-  "list.emptyOne": "分区「{division}」下没有已启用的专家。",
-  "list.unknownDivision": "找不到分区「{query}」。可用分区：{divisions}",
+  "list.emptyOne": "分类「{division}」下没有已启用的专家。",
+  "list.unknownDivision": "找不到分类「{query}」。可用分类：{divisions}",
   "list.hint": "用 summon_t_expert(expert, task) 召唤其中一位；批量用 summon_t_experts。",
   "summon.batchHeader": "批量召唤 {total} 位专家：成功 {ok} / 失败 {failed}",
   "summon.itemOk": "## {expert}\n{answer}",
@@ -49,6 +65,22 @@ 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.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",
+  "error.categoryMissing": "No custom division named \"{division}\"",
+  "error.categoryNotEmpty": "Division \"{division}\" still has {count} custom expert(s): move or delete them first, then delete the division",
+  "error.customSlugTaken": "slug \"{slug}\" is already taken by a built-in or custom expert",
+  "error.customDivisionInvalid": "A division directory name may only use a-z, 0-9, dots and hyphens, starting with a letter or digit (put the Chinese in the display name): \"{division}\"",
+  "error.customNameTaken": "Name \"{name}\" duplicates existing expert \"{other}\"; duplicates make both unsummonable",
+  "error.customNameEmpty": "Name cannot be empty",
+  "error.customDescriptionEmpty": "Description cannot be empty (experts without one never enter the roster)",
+  "error.customBodyEmpty": "Persona body cannot be empty (it is what the expert works from)",
+  "error.customTextTooLong": "{field} exceeds {limit} characters",
+  "error.customNotCustom": "\"{slug}\" is not a custom expert; built-in experts come from the synced roster (copy it as custom first)",
+  "error.customMissing": "Custom expert not found: \"{slug}\"",
+  "error.customConflict": "This custom expert changed elsewhere; close and reopen the editor",
+  "error.customRootMissing": "Custom expert root is not configured (customRoot)",
   "list.headerAll": "T Expert roster ({total} enabled experts across {divisions} divisions):",
   "list.headerOne": "Enabled experts in division {division} ({count}):",
   "list.emptyAll": "No expert is enabled yet. Enable some in Settings → T Expert.",
@@ -84,7 +116,7 @@ export function readLocale(ctx) {
 
 /**
  * 按语言取专家显示名与简介。
- * 中文优先用侧车目录的译文（expert.nameZh / descriptionZh），缺失则回退上游英文。
+ * 中文优先用侧车目录的译文（expert.nameZh / descriptionZh），缺失则回退英文原文。
  */
 export function localized(expert, locale) {
   if (locale === "en") {

package/lib/index.js

@@ -11,31 +11,43 @@
  */
 import { homedir } from "node:os";
 import { existsSync, readFileSync } from "node:fs";
-import { stat } from "node:fs/promises";
+import { stat, rmdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import schema from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import {
+  CUSTOM_DIVISION,
+  CUSTOM_LIMITS,
   DEFAULT_DIVISIONS,
   catalogDivisions,
+  customExpertPath,
   divisionOf,
+  fileFingerprint,
   groupByDivision,
+  isValidDivision,
+  isValidSlug,
   loadCatalog,
   mapPool,
+  normalizedKey,
   readPersona,
+  removeCustomExpert,
   resolveExpert,
   sanitize,
+  saveCustomLabel,
+  serializeCustomExpert,
   truncate,
+  writeFileAtomic,
 } from "./catalog.js";
 import { localized, NS, readLocale, renderList, renderSummonResults, t } from "./i18n.js";
 import { seedData } from "./bootstrap.js";
 import { registerTeamCommand } from "./command.js";
 import { createSquadService } from "./squads.js";
+import { SNAPSHOT_DIR } from "./bootstrap.js";
 import { checkPlan } from "./plan-check.js";
 import { findTeamByCaptain } from "./teams/state.js";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-// 内置团队引擎：随插件一起发布的品牌化产物在 lib/teams/ 下（由 scripts/brand.mjs 从
-// vendor/ 里的上游镜像改名生成），这里在 T专家 内部挂载它 ——
+// 内置团队引擎：随插件一起发布的品牌化产物在 lib/teams/ 下（源自第三方引擎，改名后
+// 由本项目直接维护），这里在 T专家 内部挂载它 ——
 // 安装 T专家 即自带团队引擎与团队面板，不再需要单独安装引擎插件。
 // 上游来源、版本与许可见 THIRD-PARTY-NOTICES 与 vendor/。
 import * as teamsEngine from "./teams/index.js";
@@ -60,8 +72,13 @@ export const inject = ["tools", "subagents", "systemPrompt", "settings", "comman
 export const Config = schema.object({
   root: schema.string().default(join(homedir(), ".t-team", "experts")),
   zhRoot: schema.string().default(join(homedir(), ".t-team", "zh")),
+  /**
+   * 用户自建专家的根目录（与内置名册分开：内置名册随包发布、升级时整棵替换，自建专家放进去会被覆盖）。
+   * 面板「新建专家」写到这里，固定落在 custom 分区。
+   */
+  customRoot: schema.string().default(join(homedir(), ".t-team", "custom")),
   provider: schema.string().default("spawn"),
-  /** 留空 = 自动扫描 root 下所有含 .md 的分区目录（上游新增分区不必改配置/代码）。 */
+  /** 留空 = 自动扫描 root 下所有含 .md 的分类目录（新增分类不必改配置/代码）。 */
   divisions: schema.array(schema.string()).default([]),
   maxDepth: schema.natural(),
   /** 一次 summon_t_experts 最多召唤几位专家。 */
@@ -132,6 +149,12 @@ export function apply(ctx, config) {
   // ---- 花名册加载 ----
   let entries = [];
   let effectiveDivisions = config.divisions.length > 0 ? config.divisions.slice() : DEFAULT_DIVISIONS.slice();
+  /** 自建专家根下发现的分区（默认只有 custom）；进指纹，用于新建/删除后自动重载。 */
+  let customDivisions = [];
+  /** 只来自内置根的分区（官方、只读）：自建分区不许与它们重名。 */
+  let rosterDivisions = [];
+  /** 自建分类的显示名表（键 = 声明过的自建分类，允许空分类）。 */
+  let customLabels = {};
   let divisionLabels = {};
   let loaded = false;
   let loading = null;
@@ -142,7 +165,7 @@ export function apply(ctx, config) {
    * 名册指纹：source.json、各分区目录、以及中文侧车文件的 mtime。
    *
    * 要点：运行期读的中文正文路径是 `zh/<分区>/<slug>.md`（不是 `manual-bodies/`，那是
-   * 数据层的**输入**，由同步脚本合并后写进 `zh/<分区>/`）。所以 `zhRoot` 与每个
+   * 数据层的输入层，已冻结）。所以 `zhRoot` 与每个
    * `zh/<分区>/` 目录都必须进指纹 —— 否则「给某位专家**新增**一篇中文正文」这条最常见的
    * 补译操作不会触发重载：该专家的 personaPathZh 一直是 undefined，召唤时只能读英文。
    * （已在 verify 里用临时数据目录做过行为验证。）
@@ -161,15 +184,28 @@ export function apply(ctx, config) {
       ...effectiveDivisions.map((division) => mtimeOf(join(config.root, division))),
       ...effectiveDivisions.map((division) => mtimeOf(join(config.zhRoot, division))),
       ...effectiveDivisions.map((division) => mtimeOf(join(config.zhRoot, "manual-bodies", division))),
+      // 自建专家根：目录本身（新增/删除分区目录时变）+ 各分区目录（增删改单个专家时变）。
+      // 少了后一项，新建一位专家后指纹不变，面板要等到别的原因触发重载才看得到。
+      mtimeOf(config.customRoot),
+      ...customDivisions.map((division) => mtimeOf(join(config.customRoot, division))),
+      // 自建分区的显示名表：改一个已有文件不会变动父目录的 mtime，必须单独进指纹，
+      // 否则手工编辑 divisions.json 之后分区名不会刷新（与「新增 zh 正文不重载」同一类坑）。
+      mtimeOf(config.customRoot === undefined || config.customRoot === "" ? "" : join(config.customRoot, "divisions.json")),
     ]);
     return parts.join("|");
   }
 
   async function load() {
     try {
-      const catalog = await loadCatalog(config.root, config.divisions, { zhRoot: config.zhRoot });
+      const catalog = await loadCatalog(config.root, config.divisions, {
+        zhRoot: config.zhRoot,
+        customRoot: config.customRoot,
+      });
       entries = [...catalog.values()];
       const discovered = catalogDivisions(catalog);
+      if (catalog.customDivisions !== undefined) customDivisions = catalog.customDivisions;
+      if (catalog.rosterDivisions !== undefined) rosterDivisions = catalog.rosterDivisions;
+      customLabels = catalog.customLabels ?? {};
       if (discovered.length > 0) effectiveDivisions = discovered;
       divisionLabels = catalog.labels ?? {};
       loadError = null;
@@ -207,22 +243,47 @@ export function apply(ctx, config) {
   async function snapshot() {
     await ensureReady();
     const enabled = enabledSet();
-    return {
+    const experts = await Promise.all(usable().map(async (expert) => ({
       // 面板按 locale 取字段：name/description 为中文（缺译回退英文），nameEn/descriptionEn 恒为英文。
-      experts: usable().map((expert) => ({
-        slug: expert.slug,
-        name: expert.nameZh ?? expert.name,
-        nameEn: expert.nameEn,
-        description: expert.descriptionZh ?? expert.description,
-        descriptionEn: expert.descriptionEn,
-        emoji: expert.emoji,
-        division: expert.division,
-        divisionZh: divisionOf(expert.division, divisionLabels).zh,
-        divisionEn: divisionOf(expert.division, divisionLabels).en,
-        conflict: expert.conflict === true,
-      })),
+      slug: expert.slug,
+      name: expert.nameZh ?? expert.name,
+      nameEn: expert.nameEn,
+      description: expert.descriptionZh ?? expert.description,
+      descriptionEn: expert.descriptionEn,
+      emoji: expert.emoji,
+      division: expert.division,
+      divisionZh: divisionOf(expert.division, divisionLabels).zh,
+      divisionEn: divisionOf(expert.division, divisionLabels).en,
+      conflict: expert.conflict === true,
+      custom: expert.custom === true,
+      // 自建专家的内容指纹：编辑/删除时回传，拦住并发覆盖（内置专家不读文件、恒为空）。
+      hash: expert.custom === true ? await fileFingerprint(expert.personaPath) : "",
+    })));
+    return {
+      experts,
       enabled: [...enabled],
       revision: revision(),
+      // 自建专家固定落在这个分区；连同中文标签一起给面板，省得两端各写一份常量。
+      customDivision: CUSTOM_DIVISION,
+      customDivisionLabel: divisionOf(CUSTOM_DIVISION, divisionLabels).zh,
+      // 全部分类（面板的「分类」下拉与管理页）：
+      //   official=官方分类（只读镜像的一部分，名字跟随中文侧车）
+      //   count=该分类下的专家总数，customCount=其中自建的
+      // 自建专家可以归到官方分类名下 —— 分类是**归属**，文件始终写 customRoot，官方镜像不受影响。
+      // 默认分类恒在（它就是新建专家的落点），其余官方在前、自建在后。
+      categories: [...new Set([CUSTOM_DIVISION, ...rosterDivisions, ...customDivisions, ...Object.keys(customLabels)])]
+        .filter((key) => key !== "")
+        .map((key) => {
+          const inCategory = entries.filter((expert) => expert.division === key);
+          return {
+            key,
+            label: divisionOf(key, divisionLabels).zh,
+            official: rosterDivisions.includes(key),
+            count: inCategory.length,
+            customCount: inCategory.filter((expert) => expert.custom === true).length,
+          };
+        })
+        .sort((a, b) => Number(b.official) - Number(a.official) || a.label.localeCompare(b.label, "zh")),
     };
   }
 
@@ -234,6 +295,222 @@ export function apply(ctx, config) {
     return { prompt: await readPersona(expert) };
   }
 
+  // ---- 自建专家（面板「新建 / 编辑 / 删除」）----
+  // 写的是 customRoot（默认 ~/.t-team/custom），**不碰内置名册** —— 内置根是破坏性镜像，
+  // 往里写自建专家会在下次同步时被当成"意外文件"删掉。
+  /** 带业务码的错误：remote 的 businessError 会原样透传 code 给面板。 */
+  function customError(codeKey, params = {}) {
+    const error = new Error(t(locale(), codeKey, params));
+    error.code = `tTeam/${codeKey.replace(/^error\./, "").replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`)}`;
+    return error;
+  }
+
+  /** 校验并归一化自建专家表单；重名会连累内置专家一起不可召唤，所以挡在写盘前。 */
+  function normalizeCustomInput(input, editingSlug) {
+    const name = String(input?.name ?? "").trim();
+    if (name === "") throw customError("error.customNameEmpty");
+    if (name.length > CUSTOM_LIMITS.name) {
+      throw customError("error.customTextTooLong", { field: "名称", limit: CUSTOM_LIMITS.name });
+    }
+    const description = String(input?.description ?? "").trim();
+    if (description === "") throw customError("error.customDescriptionEmpty");
+    if (description.length > CUSTOM_LIMITS.description) {
+      throw customError("error.customTextTooLong", { field: "简介", limit: CUSTOM_LIMITS.description });
+    }
+    const body = String(input?.body ?? "").trim();
+    if (body === "") throw customError("error.customBodyEmpty");
+    if (body.length > CUSTOM_LIMITS.body) {
+      throw customError("error.customTextTooLong", { field: "人格正文", limit: CUSTOM_LIMITS.body });
+    }
+    const nameEn = String(input?.nameEn ?? "").trim();
+    if (nameEn.length > CUSTOM_LIMITS.nameEn) {
+      throw customError("error.customTextTooLong", { field: "英文名", limit: CUSTOM_LIMITS.nameEn });
+    }
+    const descriptionEn = String(input?.descriptionEn ?? "").trim();
+    const emoji = String(input?.emoji ?? "").trim();
+
+    // 重名（中文名或英文名撞车）：markConflicts 会把两位都标成冲突、双双不可召唤，
+    // 所以这里直接拒绝，并告诉用户撞上了谁。
+    for (const candidate of [name, nameEn]) {
+      if (candidate === "") continue;
+      const key = normalizedKey(candidate);
+      const clash = entries.find((expert) => expert.slug !== editingSlug
+        && (normalizedKey(expert.nameZh ?? expert.name) === key || normalizedKey(expert.nameEn) === key));
+      if (clash !== undefined) {
+        throw customError("error.customNameTaken", { name: candidate, other: clash.nameZh ?? clash.name });
+      }
+    }
+    return { name, nameEn, description, descriptionEn, emoji, body };
+  }
+
+  /** 写完立刻重载（不靠 mtime 分辨率：同一毫秒内的连续写也要看到最新结果）。 */
+  async function refreshCatalog() {
+    await load();
+    if (loadError !== null) throw loadError;
+  }
+
+  function requireCustomRoot() {
+    if (typeof config.customRoot !== "string" || config.customRoot.trim() === "") {
+      throw customError("error.customRootMissing");
+    }
+    return config.customRoot;
+  }
+
+  /**
+   * 定下这位自建专家该归到哪个分类（分类 = 面板里的归属，不决定文件写在哪）。
+   *
+   * 规则（服务端说了算，不信任面板传什么）：
+   *   - 空 → 默认分类 `custom`；
+   *   - 必须过 `isValidDivision`（与扫描口径同一个判断，避免写出「列表里有、扫不到」的目录）；
+   *   - **可以**用官方分类名（学术/金融/游戏…）：分类是归属，文件始终写 customRoot，
+   *     官方镜像目录一个字节都不动，所以不会被同步删掉（2026-09-12 用户选定）。
+   *
+   * @param keep - 当前所在分类：编辑时保留原值可以跳过校验（历史遗留的非 ASCII 目录名仍能就地保存）。
+   */
+  async function resolveDivision(raw, customRoot, keep) {
+    const requested = String(raw ?? "").trim();
+    const key = requested === "" ? (typeof keep === "string" && keep !== "" ? keep : CUSTOM_DIVISION) : requested;
+    if (typeof keep === "string" && key === keep) return key;
+    if (!isValidDivision(key)) throw customError("error.customDivisionInvalid", { division: key });
+    return key;
+  }
+
+  /** 分类管理只允许动自建分类：官方分类随包发布（名字与存亡都跟包内名册走，本机改不了）。 */
+  function requireCustomCategory(key) {
+    const name = String(key ?? "").trim();
+    if (!isValidDivision(name)) throw customError("error.customDivisionInvalid", { division: name });
+    if (rosterDivisions.includes(name)) throw customError("error.categoryOfficial", { division: name });
+    return name;
+  }
+
+  /** 该分类下已有的自建专家（删除分类前的安全检查）。 */
+  function customExpertsIn(division) {
+    return entries.filter((expert) => expert.division === division && expert.custom === true);
+  }
+
+  /** 分类是否已存在（官方名、已声明、或目录里已有专家都算）。 */
+  function categoryExists(key) {
+    return rosterDivisions.includes(key) || customDivisions.includes(key) || Object.hasOwn(customLabels, key);
+  }
+
+  /** 新建自建分类（可以暂时是空分类：目录等第一位专家落进来时才创建）。 */
+  async function createCategory(key, label) {
+    await ensureReady();
+    const customRoot = requireCustomRoot();
+    const name = String(key ?? "").trim();
+    if (!isValidDivision(name)) throw customError("error.customDivisionInvalid", { division: name });
+    if (categoryExists(name)) throw customError("error.categoryExists", { division: name });
+    const text = String(label ?? "").trim();
+    if (text.length > CUSTOM_LIMITS.divisionLabel) {
+      throw customError("error.customTextTooLong", { field: "分类显示名", limit: CUSTOM_LIMITS.divisionLabel });
+    }
+    await saveCustomLabel(customRoot, name, text);
+    await refreshCatalog();
+    return await snapshot();
+  }
+
+  /** 改自建分类的显示名（清空＝回退到目录名本身）。 */
+  async function updateCategory(key, label) {
+    await ensureReady();
+    const customRoot = requireCustomRoot();
+    const name = requireCustomCategory(key);
+    if (!categoryExists(name)) throw customError("error.categoryMissing", { division: name });
+    const text = String(label ?? "").trim();
+    if (text.length > CUSTOM_LIMITS.divisionLabel) {
+      throw customError("error.customTextTooLong", { field: "分类显示名", limit: CUSTOM_LIMITS.divisionLabel });
+    }
+    await saveCustomLabel(customRoot, name, text);
+    await refreshCatalog();
+    return await snapshot();
+  }
+
+  /** 删除自建分类：里面还有自建专家就拒绝（不静默连删），删完顺手收掉空目录。 */
+  async function deleteCategory(key) {
+    await ensureReady();
+    const customRoot = requireCustomRoot();
+    const name = requireCustomCategory(key);
+    if (!categoryExists(name)) throw customError("error.categoryMissing", { division: name });
+    const owned = customExpertsIn(name);
+    if (owned.length > 0) {
+      throw customError("error.categoryNotEmpty", { division: name, count: owned.length });
+    }
+    await saveCustomLabel(customRoot, name, "");
+    // 只收空目录：目录里若还有别的文件（用户自己放的），rmdir 会失败，忽略即可。
+    await rmdirIfEmpty(join(customRoot, name));
+    await refreshCatalog();
+    return await snapshot();
+  }
+
+  /** 记下自建分区的中文显示名（没传就什么都不做，不动已有标签）。 */
+  async function rememberDivisionLabel(customRoot, division, label) {
+    const text = String(label ?? "").trim();
+    if (text === "" || text.length > CUSTOM_LIMITS.divisionLabel) return;
+    await saveCustomLabel(customRoot, division, text);
+  }
+
+  /** 新建自建专家 → 返回刷新后的整份快照。 */
+  async function createExpert(input) {
+    await ensureReady();
+    const customRoot = requireCustomRoot();
+    const slug = String(input?.slug ?? "").trim().toLowerCase();
+    if (!isValidSlug(slug)) throw customError("error.customSlugInvalid", { slug });
+    if (entries.some((expert) => expert.slug === slug)) {
+      throw customError("error.customSlugTaken", { slug });
+    }
+    const fields = normalizeCustomInput(input);
+    const division = await resolveDivision(input?.division, customRoot);
+    await writeFileAtomic(customExpertPath(customRoot, slug, division), serializeCustomExpert(fields));
+    await rememberDivisionLabel(customRoot, division, input?.divisionLabel);
+    await refreshCatalog();
+    return await snapshot();
+  }
+
+  /** 编辑自建专家（不改 slug；改分区＝移动文件）→ 返回刷新后的快照。 */
+  async function updateExpert(slug, input, expectedHash) {
+    await ensureReady();
+    const customRoot = requireCustomRoot();
+    const expert = entries.find((item) => item.slug === slug);
+    if (expert === undefined) throw customError("error.customMissing", { slug });
+    if (expert.custom !== true) throw customError("error.customNotCustom", { slug });
+    const path = expert.customPath ?? customExpertPath(customRoot, slug, expert.division);
+    const actual = await fileFingerprint(path);
+    if (typeof expectedHash === "string" && expectedHash !== "" && actual !== expectedHash) {
+      throw customError("error.customConflict");
+    }
+    const fields = normalizeCustomInput(input, slug);
+    const division = await resolveDivision(input?.division, customRoot, expert.division);
+    const target = customExpertPath(customRoot, slug, division);
+    await writeFileAtomic(target, serializeCustomExpert(fields));
+    // 换分区＝移动：老文件必须删掉，否则同一个 slug 会以两份文件出现在两个分区里
+    // （扫描按 slug 去重，面板上表现为"改完分区又弹回原处"）。
+    if (target !== path) await removeCustomExpert(customRoot, slug, expert.division);
+    await rememberDivisionLabel(customRoot, division, input?.divisionLabel);
+    await refreshCatalog();
+    return await snapshot();
+  }
+
+  /** 删除自建专家 → 返回刷新后的快照。 */
+  async function deleteExpert(slug, expectedHash) {
+    await ensureReady();
+    const customRoot = requireCustomRoot();
+    const expert = entries.find((item) => item.slug === slug);
+    if (expert === undefined) throw customError("error.customMissing", { slug });
+    if (expert.custom !== true) throw customError("error.customNotCustom", { slug });
+    const path = expert.customPath ?? customExpertPath(customRoot, slug, expert.division);
+    const actual = await fileFingerprint(path);
+    if (typeof expectedHash === "string" && expectedHash !== "" && actual !== expectedHash) {
+      throw customError("error.customConflict");
+    }
+    await removeCustomExpert(customRoot, slug, expert.division);
+    // 删除后把该专家从启用列表里摘掉，否则设置段会留下一个指向空气的 slug
+    const enabled = [...enabledSet()].filter((item) => item !== slug);
+    if (enabled.length !== enabledSet().size) {
+      await ctx.settings.mutate(SETTINGS_NAMESPACE, [{ op: "set", path: ["enabled"], value: enabled }], revision());
+    }
+    await refreshCatalog();
+    return await snapshot();
+  }
+
   /** 整体替换启用列表（远程服务用）。 */
   async function setEnabled(next, expectedRevision) {
     const list = (Array.isArray(next) ? next : []).filter((item) => typeof item === "string");
@@ -244,8 +521,20 @@ export function apply(ctx, config) {
     return { enabled: [...enabledSet()], revision: revision() };
   }
 
-  const catalogService = { snapshot, prompt, setEnabled, root: config.root };
-  ctx.reflect.provide(CATALOG_SERVICE, catalogService);
+  /** 删掉一个空目录；非空或不存在都当没事（只用于分类删除后的收尾）。 */
+  async function rmdirIfEmpty(path) {
+    try {
+      await rmdir(path);
+    } catch {
+      // ENOTEMPTY / ENOENT 都无所谓：里面还有别的东西就不动它。
+    }
+  }
+
+  const catalogService = {
+    snapshot, prompt, setEnabled, root: config.root,
+    createExpert, updateExpert, deleteExpert,
+    createCategory, updateCategory, deleteCategory,
+  };  ctx.reflect.provide(CATALOG_SERVICE, catalogService);
 
   // ---- 召唤 ----
   async function runExpert(query, task, exec) {
@@ -476,7 +765,7 @@ export function apply(ctx, config) {
     },
   }));
 
-  // ---- 内置团队引擎（vendor 自上游并品牌化；小队数据来自 team-profiles.py 生成的 JSON）----
+  // ---- 内置团队引擎（源自第三方引擎、已品牌化并入；小队数据来自 team-profiles.py 生成的 JSON）----
   // 配置路径与引擎标量都是 Config 字段（可从 cordis.yml 覆盖）：标量以 Config 为准，
   // 数据文件只提供生成物本身（profiles / memberMaxDepth）——小队目录是数据，不是可调参数。
   const engineConfigDir = dirname(config.root);
@@ -556,6 +845,10 @@ export function apply(ctx, config) {
   const squads = createSquadService({
     teamsFile,
     catalog: catalogService,
+    // 编译器优先用包内那份（随插件版本走）；包内没有（例如被裁剪的安装）才回退数据目录。
+    generator: existsSync(join(SNAPSHOT_DIR, "team-profiles.py"))
+      ? join(SNAPSHOT_DIR, "team-profiles.py")
+      : undefined,
   });
   ctx.reflect.provide(SQUAD_SERVICE, squads);