dsh-plugin-experts 0.1.0

package/dist/host.js

@@ -0,0 +1,1298 @@
+// ../../shared/host/route.mjs
+function json(body, status) {
+  return Response.json(body, { status, headers: { "cache-control": "no-store" } });
+}
+function ok(value) {
+  return json({ ok: true, value: value ?? null }, 200);
+}
+function fail(code, message) {
+  return json({ ok: false, error: { code, message } }, 200);
+}
+var FeatureError2 = class extends Error {
+  /**
+   * @param {string} code - stable machine-readable code, for example `connector/not-found`.
+   * @param {string} message - human-readable reason shown to the user.
+   */
+  constructor(code, message) {
+    super(message);
+    this.name = "FeatureError";
+    this.code = code;
+  }
+};
+function registerFeatureRoute(ctx, { feature, handlers, methods = ["POST"] }) {
+  const path = `/api/dsh-skills/${feature}`;
+  return ctx.effect(
+    () => ctx.connection.fetch.register({
+      path,
+      methods: [...methods],
+      requestBody: "buffered",
+      fetch: async (request) => {
+        try {
+          if (request.method !== "POST") return fail("method-not-allowed", "\u6B64\u8DEF\u7531\u53EA\u63A5\u53D7 POST");
+          const body = await request.json().catch(() => null);
+          if (body === null || typeof body !== "object" || Array.isArray(body)) {
+            return fail("malformed-request", "\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+          }
+          const { endpoint, payload } = body;
+          if (typeof endpoint !== "string") return fail("malformed-request", "endpoint \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+          const handler = Object.hasOwn(handlers, endpoint) ? handlers[endpoint] : void 0;
+          if (typeof handler !== "function") return fail("unknown-endpoint", `\u672A\u77E5\u7AEF\u70B9 ${JSON.stringify(endpoint)}`);
+          const result = await handler(payload ?? {}, request);
+          return result instanceof Response ? result : ok(result);
+        } catch (error) {
+          const code = typeof error?.code === "string" && error.code.length > 0 ? error.code : "handler-failed";
+          return fail(code, String(error?.message ?? error));
+        }
+      }
+    }),
+    `dsh-skills: ${feature} route`
+  );
+}
+
+// ../../shared/dsh-package.mjs
+import { createRequire } from "node:module";
+import { isAbsolute, join } from "node:path";
+import { pathToFileURL } from "node:url";
+function dshResolutionAnchors({ argv = process.argv, cwd = process.cwd() } = {}) {
+  const anchors = [];
+  if (typeof argv[1] === "string" && isAbsolute(argv[1])) anchors.push(argv[1]);
+  if (typeof argv[2] === "string" && isAbsolute(argv[2])) anchors.push(join(argv[2], "package.json"));
+  anchors.push(join(cwd, "package.json"));
+  return [...new Set(anchors)];
+}
+var stubs = /* @__PURE__ */ new Map();
+function resolveDshPackage(specifier, options = {}) {
+  if (stubs.has(specifier)) return `stub:${specifier}`;
+  const tried = [];
+  for (const anchor of dshResolutionAnchors(options)) {
+    try {
+      return createRequire(anchor).resolve(specifier);
+    } catch (error) {
+      tried.push(`${anchor} (${error?.code ?? error?.name ?? "error"})`);
+    }
+  }
+  throw new Error(
+    `dsh-skills: cannot resolve ${JSON.stringify(specifier)} from the dsh installation or the profile.
+Tried: ${tried.join(", ")}
+A Host half must not import an official package by bare specifier: Node resolves that from
+this plugin's realpath, which is outside the installation. Use importDshPackage() instead.`
+  );
+}
+async function importDshPackage(specifier, options) {
+  const stub = stubs.get(specifier);
+  if (stub !== void 0) return stub;
+  return import(pathToFileURL(resolveDshPackage(specifier, options)).href);
+}
+
+// ../../shared/host/storage.mjs
+var cached;
+async function storageKit() {
+  if (cached !== void 0) return cached;
+  const [domain, zod] = await Promise.all([
+    importDshPackage("@deepseek-ai/dsh-storage-domain"),
+    importDshPackage("zod")
+  ]);
+  const z = zod.z ?? zod.default ?? zod;
+  if (typeof domain?.defineDomain !== "function" || typeof domain?.domainTable !== "function") {
+    throw new Error("dsh-skills: @deepseek-ai/dsh-storage-domain no longer exports defineDomain/domainTable");
+  }
+  if (typeof z?.object !== "function") {
+    throw new Error("dsh-skills: the installation's zod does not expose z.object");
+  }
+  cached = { defineDomain: domain.defineDomain, domainTable: domain.domainTable, descriptorOf: domain.descriptorOf, z };
+  return cached;
+}
+
+// src/domains.js
+var LOCAL_PRINCIPAL = "local";
+function buildExpertDomains({ z, defineDomain, domainTable }) {
+  const loose = z.record(z.string(), z.unknown());
+  const stateSchema = z.object({
+    schemaVersion: z.literal(1),
+    experts: loose,
+    drafts: loose,
+    revisions: loose,
+    adoptions: loose,
+    // Additive collections must be `.default()`ed, never plain: the domain
+    // facility validates every stored record **on `open()`**, before the
+    // consumer ever sees it (`dsh-storage-domain`'s `parseRecord`), and an
+    // unparsable record is a hard `DomainError` unless the spec opts into
+    // `backup-and-skip`. A record written before `teams` existed therefore
+    // throws out of `ctx.storageDomain.open()`, which used to abort the whole
+    // of `apply()` in `index.js` — losing the route, the tools *and* the
+    // `/expert-manager` skill, while every unit test still passed
+    // (none of them opened a real domain against a real stored record).
+    // `.default({})` is what keeps a new collection additive: the record stays
+    // `schemaVersion: 1` and old rows still parse.
+    teams: loose.default({})
+  });
+  return {
+    stateSchema,
+    expertsDomain: defineDomain({
+      name: "dsh_skills_experts",
+      version: 1,
+      layout: "per-record",
+      tables: { states: domainTable(stateSchema) }
+    })
+  };
+}
+
+// src/manager.js
+import { createHash, randomUUID } from "node:crypto";
+var ROLE_TOKEN_BUDGET = 8e3;
+var MAX_PREFERRED_SKILLS = 12;
+var SKILL_NAME_MAX = 128;
+var NAME_MAX = 120;
+var TEAM_NAME_MAX = NAME_MAX;
+var TEAM_DESCRIPTION_MAX = 2e3;
+var TEAM_MANDATE_MAX = 6e4;
+var TEAM_MEMBERS_MIN = 2;
+var TEAM_MEMBERS_MAX = 16;
+var MEMBER_KEY = /^[a-z][a-z0-9-]{0,39}$/;
+function estimateRoleTokens(value) {
+  let wide = 0;
+  let narrow = 0;
+  for (const character of value) /[^\u0000-\u00ff]/u.test(character) ? wide++ : narrow++;
+  return wide + Math.ceil(narrow / 4);
+}
+function clean(value, code, max) {
+  const next = typeof value === "string" ? value.trim() : "";
+  if (next.length === 0 || next.length > max) throw new FeatureError2(code, "\u5185\u5BB9\u4E3A\u7A7A\u6216\u8D85\u51FA\u957F\u5EA6\u9650\u5236\u3002");
+  return next;
+}
+function revisionFor(fields) {
+  return createHash("sha256").update(JSON.stringify({
+    name: fields.name,
+    description: fields.description,
+    role: fields.role,
+    preferredSkills: fields.preferredSkills
+  }), "utf8").digest("hex");
+}
+function pickFields(row) {
+  return {
+    name: row.name,
+    description: row.description,
+    role: row.role,
+    preferredSkills: [...row.preferredSkills ?? []]
+  };
+}
+function teamRevisionFor(fields) {
+  return createHash("sha256").update(JSON.stringify({
+    name: fields.name,
+    description: fields.description,
+    mandate: fields.mandate,
+    members: fields.members.map((member) => ({ key: member.key, expertId: member.expertId, lead: member.lead }))
+  }), "utf8").digest("hex");
+}
+function readSkillNames(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new FeatureError2("experts/invalid-request", "\u5B57\u6BB5 preferredSkills \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\u3002");
+  }
+  if (value.length > MAX_PREFERRED_SKILLS) {
+    throw new FeatureError2("experts/too-many-skills", `\u9996\u9009\u6280\u80FD\u6700\u591A ${MAX_PREFERRED_SKILLS} \u4E2A\u3002`);
+  }
+  const names = [];
+  for (const entry of value) {
+    const name2 = typeof entry === "string" ? entry.trim() : "";
+    if (name2.length === 0 || name2.length > SKILL_NAME_MAX) {
+      throw new FeatureError2("experts/invalid-skill-name", "\u9996\u9009\u6280\u80FD\u540D\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u4E14\u4E0D\u8D85\u8FC7 128 \u4E2A\u5B57\u7B26\u3002");
+    }
+    if (!names.includes(name2)) names.push(name2);
+  }
+  return names;
+}
+function normalizeExpertFields(input) {
+  const name2 = clean(input?.name, "experts/invalid-name", NAME_MAX);
+  const description = clean(input?.description, "experts/invalid-description", 2e3);
+  const role = clean(input?.role, "experts/invalid-role", 6e4);
+  if (estimateRoleTokens(role) > ROLE_TOKEN_BUDGET) {
+    throw new FeatureError2("experts/role-budget-exceeded", "\u89D2\u8272\u8BF4\u660E\u8D85\u8FC7\u9884\u7559\u4E0A\u4E0B\u6587\u9884\u7B97\uFF0C\u8BF7\u5220\u51CF\u91CD\u590D\u80CC\u666F\u3002");
+  }
+  return { name: name2, description, role, preferredSkills: readSkillNames(input?.preferredSkills) };
+}
+function optionalText(value, code, max) {
+  const next = typeof value === "string" ? value.trim() : "";
+  if (next.length > max) throw new FeatureError2(code, "\u5185\u5BB9\u8D85\u51FA\u957F\u5EA6\u9650\u5236\u3002");
+  return next;
+}
+function readTeamMembers(value, state) {
+  if (!Array.isArray(value)) {
+    throw new FeatureError2("experts/invalid-team-members", "\u5B57\u6BB5 members \u5FC5\u987B\u662F\u6570\u7EC4\u3002");
+  }
+  if (value.length < TEAM_MEMBERS_MIN || value.length > TEAM_MEMBERS_MAX) {
+    throw new FeatureError2(
+      "experts/team-members-out-of-range",
+      `\u4E13\u5BB6\u56E2\u9700\u8981 ${TEAM_MEMBERS_MIN} \u81F3 ${TEAM_MEMBERS_MAX} \u4F4D\u6210\u5458\u3002`
+    );
+  }
+  const members = [];
+  const keys = /* @__PURE__ */ new Set();
+  const expertIds = /* @__PURE__ */ new Set();
+  let leads = 0;
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new FeatureError2("experts/invalid-team-members", "\u6BCF\u4E2A\u6210\u5458\u5FC5\u987B\u662F\u5BF9\u8C61\u3002");
+    }
+    const key = typeof entry.key === "string" ? entry.key.trim() : "";
+    if (!MEMBER_KEY.test(key) || key === "lead") {
+      throw new FeatureError2("experts/invalid-member-key", "\u6210\u5458\u6807\u8BC6\u987B\u4E3A\u5C0F\u5199\u82F1\u6587\u548C\u8FDE\u5B57\u7B26\uFF0Clead \u4FDD\u7559\u7ED9\u4E3B\u7406\u4EBA\u3002");
+    }
+    if (keys.has(key)) throw new FeatureError2("experts/duplicate-member-key", `\u6210\u5458\u6807\u8BC6 ${key} \u91CD\u590D\u3002`);
+    keys.add(key);
+    const expertId = requireString(entry.expertId, "members[].expertId");
+    if (state.experts[expertId] === void 0) {
+      throw new FeatureError2("experts/unknown-member", `\u6210\u5458 ${key} \u5F15\u7528\u7684\u4E13\u5BB6\u4E0D\u5B58\u5728\u3002`);
+    }
+    if (expertIds.has(expertId)) throw new FeatureError2("experts/duplicate-member", "\u540C\u4E00\u4F4D\u4E13\u5BB6\u4E0D\u80FD\u5728\u4E13\u5BB6\u56E2\u91CC\u51FA\u73B0\u4E24\u6B21\u3002");
+    expertIds.add(expertId);
+    const lead = entry.lead === true;
+    if (lead) leads += 1;
+    members.push({ key, expertId, lead });
+  }
+  if (leads > 1) throw new FeatureError2("experts/multiple-leads", "\u4E13\u5BB6\u56E2\u53EA\u80FD\u6709\u4E00\u4F4D\u4E3B\u7406\u4EBA\u6210\u5458\u3002");
+  return members;
+}
+function normalizeTeamFields(input, state) {
+  const name2 = clean(input?.name, "experts/invalid-team-name", TEAM_NAME_MAX);
+  return {
+    name: name2,
+    description: optionalText(input?.description, "experts/invalid-team-description", TEAM_DESCRIPTION_MAX),
+    mandate: optionalText(input?.mandate, "experts/invalid-team-mandate", TEAM_MANDATE_MAX),
+    members: readTeamMembers(input?.members, state)
+  };
+}
+function requireString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new FeatureError2("experts/invalid-request", `\u7F3A\u5C11\u5B57\u6BB5 ${field}\u3002`);
+  }
+  return value;
+}
+function emptyState() {
+  return { schemaVersion: 1, experts: {}, drafts: {}, revisions: {}, adoptions: {}, teams: {} };
+}
+function copyName(name2) {
+  const suffix = " \u526F\u672C";
+  const room = NAME_MAX - suffix.length;
+  return `${name2.length > room ? name2.slice(0, room).trimEnd() : name2}${suffix}`;
+}
+var ExpertManager = class {
+  /**
+   * @param {import('@deepseek-ai/cordis').Context} ctx - Host context.
+   * @param {{ expertsDomain: object }} domains - built spec.
+   */
+  constructor(ctx, domains) {
+    this.ctx = ctx;
+    this.domains = domains;
+    this.states = void 0;
+    this.state = void 0;
+    this.serial = Promise.resolve();
+  }
+  /** Open the domain and load the single state record into memory. */
+  async init() {
+    const domain = await this.ctx.storageDomain.open(this.domains.expertsDomain);
+    this.ctx.effect(() => () => domain.close(), "dsh-plugin-experts: domain");
+    this.states = domain.table("states");
+    const stored = this.states.get(LOCAL_PRINCIPAL);
+    const filled = stored === void 0 ? emptyState() : { ...stored, teams: stored.teams ?? {} };
+    this.state = filled;
+    if (stored === void 0 || stored.teams === void 0) await this.states.put(LOCAL_PRINCIPAL, filled);
+  }
+  // ---- read surface --------------------------------------------------------
+  /** Expert summaries, newest edit first. */
+  list(query = "") {
+    const state = this.load();
+    const needle = typeof query === "string" ? query.trim().toLocaleLowerCase() : "";
+    return Object.values(state.experts).map((expert) => this.summary(state, expert)).filter((row) => needle.length === 0 || `${row.name} ${row.description} ${row.preferredSkills.join(" ")}`.toLocaleLowerCase().includes(needle)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+  /** One expert's summary row. */
+  summary(state, expert) {
+    const draft = state.drafts[expert.id];
+    const published = expert.publishedRevisionId === void 0 ? void 0 : state.revisions[expert.publishedRevisionId];
+    return {
+      id: expert.id,
+      name: draft?.name ?? published?.name ?? "",
+      description: draft?.description ?? published?.description ?? "",
+      preferredSkills: draft?.preferredSkills ?? published?.preferredSkills ?? [],
+      published: published !== void 0,
+      revisionNumber: published?.number ?? 0,
+      draftRevision: expert.draftRevision,
+      updatedAt: expert.updatedAt
+    };
+  }
+  /** One expert with its draft, every revision and the published pointer. */
+  get(expertId) {
+    const state = this.load();
+    return this.detail(state, this.requireExpert(state, expertId));
+  }
+  /** Build the detail shape from a state snapshot. */
+  detail(state, expert) {
+    const revisions = Object.values(state.revisions).filter((row) => row.expertId === expert.id).sort((a, b) => b.number - a.number);
+    return {
+      expert,
+      draft: state.drafts[expert.id] ?? null,
+      revisions,
+      publishedRevision: revisions.find((row) => row.id === expert.publishedRevisionId) ?? null
+    };
+  }
+  /** The adoption record for one conversation, or null. */
+  adoption(sessionId) {
+    return this.load().adoptions[sessionId] ?? null;
+  }
+  /**
+   * Everything the prompt needs for one conversation, or undefined when it has
+   * no adoption (or the referenced expert/revision disappeared).
+   */
+  adoptionContext(sessionId) {
+    const state = this.load();
+    const adoption = state.adoptions[sessionId];
+    if (adoption === void 0) return void 0;
+    const expert = state.experts[adoption.expertId];
+    const revision = state.revisions[adoption.revisionId];
+    if (expert === void 0 || revision === void 0) return void 0;
+    return { adoption, expert, revision };
+  }
+  // ---- team read surface ---------------------------------------------------
+  /**
+   * Team summaries, newest edit first.
+   *
+   * A summary resolves each member to the expert it references so a card can be
+   * rendered without a second round trip. A member whose expert has since been
+   * deleted is reported with `missing: true` and placeholder text rather than
+   * dropped, because silently shortening a roster would misrepresent the team.
+   */
+  listTeams(query = "") {
+    const state = this.load();
+    const needle = typeof query === "string" ? query.trim().toLocaleLowerCase() : "";
+    return Object.values(state.teams).map((team) => this.teamSummary(state, team)).filter((row) => needle.length === 0 || `${row.name} ${row.description} ${row.mandate} ${row.members.map((member) => member.name).join(" ")}`.toLocaleLowerCase().includes(needle)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+  /** One team's summary row, with its roster resolved. */
+  teamSummary(state, team) {
+    return {
+      id: team.id,
+      name: team.name,
+      description: team.description,
+      mandate: team.mandate,
+      members: team.members.map((member) => this.memberSummary(state, member)),
+      revision: team.revision,
+      createdAt: team.createdAt,
+      updatedAt: team.updatedAt
+    };
+  }
+  /** Resolve one member reference against the live expert record. */
+  memberSummary(state, member) {
+    const expert = state.experts[member.expertId];
+    if (expert === void 0) {
+      return { key: member.key, expertId: member.expertId, lead: member.lead, name: "", description: "", published: false, missing: true };
+    }
+    const row = this.summary(state, expert);
+    return { key: member.key, expertId: member.expertId, lead: member.lead, name: row.name, description: row.description, published: row.published, missing: false };
+  }
+  /** One team with its roster resolved. */
+  getTeam(teamId) {
+    const state = this.load();
+    return this.teamSummary(state, this.requireTeam(state, teamId));
+  }
+  // ---- write surface -------------------------------------------------------
+  /** Create an expert with its first draft. Nothing is published yet. */
+  create(input) {
+    return this.mutate((state) => {
+      const fields = normalizeExpertFields(input);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const expertId = randomUUID();
+      const draft = { expertId, ...fields, revision: revisionFor(fields), createdAt: now, updatedAt: now };
+      const expert = { id: expertId, draftRevision: draft.revision, createdAt: now, updatedAt: now };
+      const next = {
+        ...state,
+        experts: { ...state.experts, [expertId]: expert },
+        drafts: { ...state.drafts, [expertId]: draft }
+      };
+      return { next, result: this.detail(next, expert) };
+    });
+  }
+  /**
+   * Edit an expert's draft under an optimistic revision check.
+   *
+   * The expected revision is the draft's content address, so a stale save is
+   * refused rather than silently overwriting another editor's change.
+   */
+  updateDraft(expertId, patch, expectedRevision) {
+    return this.mutate((state) => {
+      const expert = this.requireExpert(state, expertId);
+      const draft = this.requireDraft(state, expertId);
+      if (patch === null || typeof patch !== "object" || Array.isArray(patch)) {
+        throw new FeatureError2("experts/invalid-request", "\u5B57\u6BB5 patch \u5FC5\u987B\u662F\u5BF9\u8C61\u3002");
+      }
+      if (draft.revision !== expectedRevision) {
+        throw new FeatureError2("experts/draft-conflict", "\u8349\u7A3F\u5DF2\u88AB\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
+      }
+      const fields = normalizeExpertFields({
+        name: patch.name ?? draft.name,
+        description: patch.description ?? draft.description,
+        role: patch.role ?? draft.role,
+        preferredSkills: patch.preferredSkills ?? draft.preferredSkills
+      });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const nextDraft = { ...draft, ...fields, revision: revisionFor(fields), updatedAt: now };
+      const nextExpert = { ...expert, draftRevision: nextDraft.revision, updatedAt: now };
+      const next = {
+        ...state,
+        experts: { ...state.experts, [expertId]: nextExpert },
+        drafts: { ...state.drafts, [expertId]: nextDraft }
+      };
+      return { next, result: this.detail(next, nextExpert) };
+    });
+  }
+  /**
+   * Freeze the draft into a new immutable numbered revision and point the
+   * expert at it. The previous revision and every existing adoption survive
+   * untouched.
+   */
+  publish(expertId, expectedRevision) {
+    return this.mutate((state) => {
+      const expert = this.requireExpert(state, expertId);
+      const draft = this.requireDraft(state, expertId);
+      if (expectedRevision !== void 0 && draft.revision !== expectedRevision) {
+        throw new FeatureError2("experts/draft-conflict", "\u8349\u7A3F\u5DF2\u88AB\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
+      }
+      const fields = normalizeExpertFields(draft);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const revision = {
+        id: randomUUID(),
+        expertId,
+        number: this.nextRevisionNumber(state, expertId),
+        ...fields,
+        createdAt: now
+      };
+      const nextExpert = { ...expert, publishedRevisionId: revision.id, updatedAt: now };
+      const next = {
+        ...state,
+        experts: { ...state.experts, [expertId]: nextExpert },
+        revisions: { ...state.revisions, [revision.id]: revision }
+      };
+      return { next, result: { expert: nextExpert, revision } };
+    });
+  }
+  /**
+   * Copy an expert's published revision (or its draft when nothing is
+   * published) into a new unpublished expert.
+   * @param {string} expertId - the source expert.
+   * @param {string} [revisionId] - an exact source revision; defaults to the published one.
+   */
+  copy(expertId, revisionId) {
+    return this.mutate((state) => {
+      const source = this.requireExpert(state, expertId);
+      let fields;
+      if (revisionId !== void 0) {
+        const revision = state.revisions[revisionId];
+        if (revision === void 0 || revision.expertId !== expertId) {
+          throw new FeatureError2("experts/revision-not-found", "\u672A\u627E\u5230\u8BE5\u4E13\u5BB6\u4FEE\u8BA2\u3002");
+        }
+        fields = pickFields(revision);
+      } else if (source.publishedRevisionId !== void 0) {
+        const revision = state.revisions[source.publishedRevisionId];
+        if (revision === void 0) throw new FeatureError2("experts/not-found", "\u4E13\u5BB6\u53D1\u5E03\u4FEE\u8BA2\u7F3A\u5931\u3002");
+        fields = pickFields(revision);
+      } else {
+        fields = pickFields(this.requireDraft(state, expertId));
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const newId = randomUUID();
+      const named = { ...fields, name: copyName(fields.name) };
+      const draft = { expertId: newId, ...named, revision: revisionFor(named), createdAt: now, updatedAt: now };
+      const expert = { id: newId, draftRevision: draft.revision, createdAt: now, updatedAt: now };
+      const next = {
+        ...state,
+        experts: { ...state.experts, [newId]: expert },
+        drafts: { ...state.drafts, [newId]: draft }
+      };
+      return { next, result: this.detail(next, expert) };
+    });
+  }
+  /**
+   * Delete an expert, its draft and every revision it owns.
+   *
+   * Adoptions that reference it are dropped too, and the caller is told which
+   * conversations were released so their live prompt context can be removed.
+   *
+   * Teams are the harder case, because a team is *defined* by its roster and
+   * `createTeam`/`updateTeam` refuse a member that does not exist. Deleting an
+   * expert therefore has to leave every team consistent. Two designs were
+   * possible and this one is deliberate:
+   *
+   *   (a) drop the member from every team that listed it, or
+   *   (b) leave a dangling reference the reader has to tolerate.
+   *
+   * (b) is what upstream effectively does — it materializes each member as a
+   * child expert row and lets the roster keep pointing at it — but upstream also
+   * owns that child row's lifetime, which this repo does not port. Tolerating a
+   * dangling reference here would make a team unsaveable the moment it is
+   * edited (`updateTeam` revalidates the whole roster), which is a trap rather
+   * than a feature. So: **(a)**.
+   *
+   * A team whose roster would fall below `TEAM_MEMBERS_MIN` is deleted too,
+   * because it could no longer be re-saved or represented — a two-member team
+   * that loses one member is not a team any more. The caller receives both the
+   * teams it updated and the teams it removed, so the Client can say what
+   * happened instead of leaving the user to discover it.
+   */
+  remove(expertId) {
+    return this.mutate((state) => {
+      this.requireExpert(state, expertId);
+      const experts = { ...state.experts };
+      const drafts = { ...state.drafts };
+      delete experts[expertId];
+      delete drafts[expertId];
+      const revisions = {};
+      for (const [id, row] of Object.entries(state.revisions)) {
+        if (row.expertId !== expertId) revisions[id] = row;
+      }
+      const adoptions = {};
+      const releasedSessions = [];
+      for (const [sessionId, row] of Object.entries(state.adoptions)) {
+        if (row.expertId === expertId) releasedSessions.push(sessionId);
+        else adoptions[sessionId] = row;
+      }
+      const teams = { ...state.teams };
+      const updatedTeams = [];
+      const removedTeams = [];
+      for (const [teamId, team] of Object.entries(state.teams)) {
+        if (!team.members.some((member) => member.expertId === expertId)) continue;
+        const members = team.members.filter((member) => member.expertId !== expertId);
+        if (members.length < TEAM_MEMBERS_MIN) {
+          delete teams[teamId];
+          removedTeams.push({ id: teamId, name: team.name });
+          continue;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const fields = { name: team.name, description: team.description, mandate: team.mandate, members };
+        teams[teamId] = { ...team, ...fields, revision: teamRevisionFor(fields), updatedAt: now };
+        updatedTeams.push({ id: teamId, name: team.name });
+      }
+      return {
+        next: { ...state, experts, drafts, revisions, adoptions, teams },
+        result: { removed: true, releasedSessions, updatedTeams, removedTeams }
+      };
+    });
+  }
+  // ---- team write surface --------------------------------------------------
+  /**
+   * Create a team over existing experts. Nothing is published; a team has no
+   * revision history of its own, only a content address for optimistic edits.
+   */
+  createTeam(input) {
+    return this.mutate((state) => {
+      const fields = normalizeTeamFields(input, state);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const team = { id: randomUUID(), ...fields, revision: teamRevisionFor(fields), createdAt: now, updatedAt: now };
+      const next = { ...state, teams: { ...state.teams, [team.id]: team } };
+      return { next, result: this.teamSummary(next, team) };
+    });
+  }
+  /**
+   * Replace a team's authored fields under an optimistic revision check.
+   *
+   * Unlike an expert, a team has no draft/published split: the roster is the
+   * whole content and there is nothing downstream to freeze. The revision is a
+   * content address, so a stale save is refused rather than silently
+   * overwriting another editor's roster.
+   */
+  updateTeam(teamId, patch, expectedRevision) {
+    return this.mutate((state) => {
+      const team = this.requireTeam(state, teamId);
+      if (patch === null || typeof patch !== "object" || Array.isArray(patch)) {
+        throw new FeatureError2("experts/invalid-request", "\u5B57\u6BB5 patch \u5FC5\u987B\u662F\u5BF9\u8C61\u3002");
+      }
+      if (expectedRevision !== void 0 && team.revision !== expectedRevision) {
+        throw new FeatureError2("experts/team-conflict", "\u4E13\u5BB6\u56E2\u5DF2\u88AB\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
+      }
+      const fields = normalizeTeamFields({
+        name: patch.name ?? team.name,
+        description: patch.description ?? team.description,
+        mandate: patch.mandate ?? team.mandate,
+        members: patch.members ?? team.members
+      }, state);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const nextTeam = { ...team, ...fields, revision: teamRevisionFor(fields), updatedAt: now };
+      const next = { ...state, teams: { ...state.teams, [teamId]: nextTeam } };
+      return { next, result: this.teamSummary(next, nextTeam) };
+    });
+  }
+  /**
+   * Delete a team. Teams own nothing else, so this is a plain removal — but the
+   * experts it listed are untouched, because a team only ever referenced them.
+   */
+  removeTeam(teamId) {
+    return this.mutate((state) => {
+      this.requireTeam(state, teamId);
+      const teams = { ...state.teams };
+      delete teams[teamId];
+      return { next: { ...state, teams }, result: { removed: true } };
+    });
+  }
+  /**
+   * Adopt an expert for one conversation, pinning its current published
+   * revision. Passing `null` un-adopts.
+   */
+  setAdoption(sessionId, expertId) {
+    return this.mutate((state) => {
+      if (expertId === null) {
+        if (state.adoptions[sessionId] === void 0) return { next: state, result: null };
+        const adoptions = { ...state.adoptions };
+        delete adoptions[sessionId];
+        return { next: { ...state, adoptions }, result: null };
+      }
+      const expert = this.requireExpert(state, expertId);
+      const revisionId = expert.publishedRevisionId;
+      if (revisionId === void 0 || state.revisions[revisionId] === void 0) {
+        throw new FeatureError2("experts/not-published", "\u8BE5\u4E13\u5BB6\u8FD8\u6CA1\u6709\u53D1\u5E03\u4FEE\u8BA2\uFF0C\u65E0\u6CD5\u91C7\u7528\u3002");
+      }
+      const adoption = {
+        sessionId,
+        expertId,
+        revisionId,
+        adoptedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return {
+        next: { ...state, adoptions: { ...state.adoptions, [sessionId]: adoption } },
+        result: adoption
+      };
+    });
+  }
+  /** The route dispatch table. */
+  handlers() {
+    return {
+      list: (payload) => this.list(typeof payload.query === "string" ? payload.query : ""),
+      get: (payload) => this.get(requireString(payload.expertId, "expertId")),
+      create: (payload) => this.create(payload),
+      "update-draft": (payload) => this.updateDraft(
+        requireString(payload.expertId, "expertId"),
+        payload.patch ?? {},
+        requireString(payload.expectedRevision, "expectedRevision")
+      ),
+      publish: (payload) => this.publish(
+        requireString(payload.expertId, "expertId"),
+        typeof payload.expectedRevision === "string" ? payload.expectedRevision : void 0
+      ),
+      copy: (payload) => this.copy(
+        requireString(payload.expertId, "expertId"),
+        typeof payload.revisionId === "string" ? payload.revisionId : void 0
+      ),
+      delete: (payload) => this.remove(requireString(payload.expertId, "expertId")),
+      "set-adoption": (payload) => this.setAdoption(
+        requireString(payload.sessionId, "sessionId"),
+        typeof payload.expertId === "string" && payload.expertId.length > 0 ? payload.expertId : null
+      ),
+      adoption: (payload) => this.adoption(requireString(payload.sessionId, "sessionId")),
+      "list-teams": (payload) => this.listTeams(typeof payload.query === "string" ? payload.query : ""),
+      "get-team": (payload) => this.getTeam(requireString(payload.teamId, "teamId")),
+      "create-team": (payload) => this.createTeam(payload),
+      "update-team": (payload) => this.updateTeam(
+        requireString(payload.teamId, "teamId"),
+        payload.patch ?? {},
+        typeof payload.expectedRevision === "string" ? payload.expectedRevision : void 0
+      ),
+      "delete-team": (payload) => this.removeTeam(requireString(payload.teamId, "teamId"))
+    };
+  }
+  // ---- internals -----------------------------------------------------------
+  /** In-memory state, loaded by `init`. */
+  load() {
+    if (this.state === void 0) throw new FeatureError2("experts/not-ready", "\u4E13\u5BB6\u5B58\u50A8\u5C1A\u672A\u5C31\u7EEA\u3002");
+    return this.state;
+  }
+  /** Apply one state transition and persist it. */
+  async mutate(transition) {
+    const run = async () => {
+      const { next, result } = transition(this.load());
+      if (next !== this.state) {
+        this.state = next;
+        await this.states.put(LOCAL_PRINCIPAL, next);
+      }
+      return result;
+    };
+    const queued = this.serial.then(run, run);
+    this.serial = queued.then(() => void 0, () => void 0);
+    return queued;
+  }
+  /** Read a live expert or refuse. */
+  requireExpert(state, expertId) {
+    const row = state.experts[expertId];
+    if (row === void 0) throw new FeatureError2("experts/not-found", "\u672A\u627E\u5230\u8BE5\u4E13\u5BB6\u3002");
+    return row;
+  }
+  /** Read a live team or refuse. */
+  requireTeam(state, teamId) {
+    const row = state.teams[teamId];
+    if (row === void 0) throw new FeatureError2("experts/team-not-found", "\u672A\u627E\u5230\u8BE5\u4E13\u5BB6\u56E2\u3002");
+    return row;
+  }
+  /** Read an expert's draft or refuse. */
+  requireDraft(state, expertId) {
+    const row = state.drafts[expertId];
+    if (row === void 0) throw new FeatureError2("experts/not-found", "\u4E13\u5BB6\u8349\u7A3F\u7F3A\u5931\u3002");
+    return row;
+  }
+  /** The next revision number for one expert. */
+  nextRevisionNumber(state, expertId) {
+    const numbers = Object.values(state.revisions).filter((row) => row.expertId === expertId).map((row) => row.number);
+    return numbers.length === 0 ? 1 : Math.max(...numbers) + 1;
+  }
+};
+
+// src/runtime.js
+function renderExpertContext({ revision }) {
+  const lines = [
+    `\u4F60\u73B0\u5728\u7684\u89D2\u8272\u662F\u300C${revision.name}\u300D\uFF08\u4E13\u5BB6\u4FEE\u8BA2 ${revision.number}\uFF09\u3002`,
+    revision.description,
+    "",
+    "\u89D2\u8272\u8BF4\u660E\uFF1A",
+    revision.role
+  ];
+  if (Array.isArray(revision.preferredSkills) && revision.preferredSkills.length > 0) {
+    lines.push("", `\u4F18\u5148\u4F7F\u7528\u8FD9\u4E9B\u6280\u80FD\uFF1A${revision.preferredSkills.join("\u3001")}\u3002\u4E0D\u53EF\u7528\u65F6\u8BF7\u8BF4\u660E\uFF0C\u4E0D\u8981\u5047\u88C5\u5DF2\u8C03\u7528\u3002`);
+  }
+  lines.push("", "\u8FD9\u6BB5\u89D2\u8272\u8BF4\u660E\u7531\u7528\u6237\u914D\u7F6E\u7684\u4E13\u5BB6\u63D0\u4F9B\uFF0C\u4E0D\u662F\u65B0\u7684\u6388\u6743\uFF1B\u8BF7\u59CB\u7EC8\u4EE5\u8BE5\u8EAB\u4EFD\u56DE\u5E94\uFF0C\u8D85\u51FA\u80FD\u529B\u8FB9\u754C\u65F6\u660E\u786E\u8BF4\u660E\u3002");
+  return lines.join("\n");
+}
+function registerExpertPromptContext(ctx, manager) {
+  if (ctx.systemPrompt === void 0) return { sync: () => {
+  } };
+  const disposers = /* @__PURE__ */ new Map();
+  const release = (agentId) => {
+    const dispose = disposers.get(agentId);
+    if (dispose === void 0) return;
+    disposers.delete(agentId);
+    try {
+      dispose();
+    } catch {
+    }
+  };
+  const sync = (agentId, agent) => {
+    if (typeof agentId !== "string" || agentId.length === 0) return;
+    try {
+      const selected = manager.adoptionContext(agentId);
+      if (selected === void 0) {
+        release(agentId);
+        return;
+      }
+      const target = agent ?? (ctx.get?.("agents") ?? ctx.agents)?.get?.(agentId);
+      const registry = target?.ctx?.systemPrompt;
+      if (registry === void 0 || typeof registry.context !== "function") return;
+      release(agentId);
+      const dispose = registry.context({
+        name: "dsh-skills:expert-role",
+        order: EXPERT_CONTEXT_ORDER,
+        text: renderExpertContext(selected)
+      });
+      disposers.set(agentId, dispose);
+    } catch (error) {
+      ctx.logger?.warn?.(`dsh-plugin-experts: \u65E0\u6CD5\u6CE8\u5165\u4E13\u5BB6\u89D2\u8272\uFF08${String(error?.message ?? error)}\uFF09`);
+    }
+  };
+  ctx.on("agent/created", ({ agent }) => {
+    const agentId = String(agent?.id ?? "");
+    if (agentId.length === 0) return;
+    sync(agentId, agent);
+  });
+  ctx.on("agent/disposed", ({ agent }) => {
+    release(String(agent?.id ?? ""));
+  });
+  ctx.effect(() => () => {
+    for (const agentId of [...disposers.keys()]) release(agentId);
+  }, "dsh-plugin-experts: prompt contexts");
+  return {
+    /** Re-read the adoption for one conversation after a state change. */
+    sync: (sessionId) => sync(String(sessionId ?? ""), void 0)
+  };
+}
+var EXPERT_CONTEXT_ORDER = 126;
+
+// src/skill.js
+import { readFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../skills/src/frontmatter.js
+var SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var MAX_DOCUMENT_BYTES = 1024 * 1024;
+function isSkillName(name2) {
+  return typeof name2 === "string" && SKILL_NAME.test(name2);
+}
+function scalar(text) {
+  if (text.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed === "string") return parsed;
+    } catch {
+    }
+    const closing = text.lastIndexOf('"');
+    return closing > 0 ? text.slice(1, closing) : text.slice(1);
+  }
+  if (text.startsWith("'")) {
+    const match = /^'((?:[^']|'')*)'/.exec(text);
+    if (match !== null) return match[1].replace(/''/g, "'");
+    return text.slice(1);
+  }
+  if (text === "true") return true;
+  if (text === "false") return false;
+  return text.split(" #")[0].trim();
+}
+function parseTopLevel(yaml) {
+  const data = {};
+  const lines = yaml.split("\n").map((line) => line.replace(/\r$/, ""));
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent !== 0) continue;
+    const separator = line.indexOf(":");
+    if (separator <= 0) continue;
+    const key = line.slice(0, separator).trim();
+    if (key.length === 0) continue;
+    const rest = line.slice(separator + 1).trim();
+    const block = /^([|>])([+-]?)(\d*)$/.exec(rest);
+    if (block !== null) {
+      const collected = [];
+      let contentIndent = -1;
+      let cursor = index + 1;
+      for (; cursor < lines.length; cursor += 1) {
+        const raw = lines[cursor];
+        if (raw.trim().length === 0) {
+          collected.push("");
+          continue;
+        }
+        const inner = raw.length - raw.trimStart().length;
+        if (inner <= indent) break;
+        if (contentIndent < 0) contentIndent = inner;
+        collected.push(raw.slice(contentIndent));
+      }
+      const keepTrailing = block[2] === "+";
+      while (!keepTrailing && collected.length > 0 && collected[collected.length - 1] === "") collected.pop();
+      const text = collected.join("\n");
+      data[key] = block[1] === ">" ? text.split(/\n{2,}/).map((paragraph) => paragraph.split("\n").map((part) => part.trim()).filter((part) => part.length > 0).join(" ")).filter((paragraph) => paragraph.length > 0).join("\n\n") : text;
+      index = cursor - 1;
+      continue;
+    }
+    if (rest.length === 0) continue;
+    data[key] = scalar(rest);
+  }
+  return data;
+}
+function readFrontmatter(document) {
+  const text = document.charCodeAt(0) === 65279 ? document.slice(1) : document;
+  const firstBreak = text.indexOf("\n");
+  if (firstBreak < 0) return void 0;
+  if (text.slice(0, firstBreak).replace(/\r$/, "") !== "---") return void 0;
+  let cursor = firstBreak + 1;
+  while (cursor <= text.length) {
+    const next = text.indexOf("\n", cursor);
+    const end = next < 0 ? text.length : next;
+    if (text.slice(cursor, end).replace(/\r$/, "") === "---") {
+      return {
+        data: parseTopLevel(text.slice(firstBreak + 1, cursor)),
+        body: text.slice(next < 0 ? text.length : next + 1)
+      };
+    }
+    if (next < 0) break;
+    cursor = next + 1;
+  }
+  return void 0;
+}
+
+// src/skill.js
+var SKILL_DIRECTORY = fileURLToPath(new URL("../resources/skills/expert-manager/", import.meta.url));
+var SKILL_FILE = join2(SKILL_DIRECTORY, "SKILL.md");
+var SKILL_PROVIDER = "dsh-plugin-experts";
+function loadExpertManagerSkill() {
+  let document;
+  try {
+    document = readFileSync(SKILL_FILE, "utf8");
+  } catch (error) {
+    throw new Error(`experts/skill-missing: cannot read ${SKILL_FILE} (${error?.message ?? error})`);
+  }
+  const parsed = readFrontmatter(document);
+  if (parsed === void 0) {
+    throw new Error(`experts/skill-invalid-frontmatter: ${SKILL_FILE} must start with a --- delimited header`);
+  }
+  const { name: name2, description, "when-to-use": whenToUse } = parsed.data;
+  if (typeof name2 !== "string" || !isSkillName(name2)) {
+    throw new Error(`experts/skill-invalid-name: frontmatter "name" must be a kebab-case skill name in ${SKILL_FILE}`);
+  }
+  for (const [key, value] of [["description", description], ["when-to-use", whenToUse]]) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new Error(`experts/skill-invalid-frontmatter: frontmatter "${key}" must be a non-empty string in ${SKILL_FILE}`);
+    }
+  }
+  const content = parsed.body.trim();
+  if (content.length === 0) {
+    throw new Error(`experts/skill-empty-body: no instructions after the frontmatter in ${SKILL_FILE}`);
+  }
+  return { name: name2, description: description.trim(), whenToUse: whenToUse.trim(), content };
+}
+function registerExpertManagerSkill(ctx) {
+  const skill = loadExpertManagerSkill();
+  const registry = ctx.skills;
+  if (registry === void 0 || typeof registry.register !== "function") return { registered: false, name: skill.name };
+  ctx.effect(() => registry.register({
+    name: skill.name,
+    description: skill.description,
+    whenToUse: skill.whenToUse,
+    source: "bundled",
+    provider: SKILL_PROVIDER,
+    content: skill.content,
+    // The body cites `references/...` and `runtime/...` by relative path; the
+    // registry renders this directory into `<skill_resources>` so the model can
+    // resolve them against a real absolute path.
+    resourceBase: { kind: "directory", path: dirname(SKILL_FILE) }
+  }), "dsh-plugin-experts: skill expert-manager");
+  return { registered: true, name: skill.name };
+}
+
+// ../library/src/tools.js
+function compileValue(node) {
+  if (node === null || typeof node !== "object") throw new Error("dsh-plugin-library: schema node must be an object");
+  if (node.type === "object") {
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(node.properties ?? {})) {
+      if (value?.required === true) required.push(key);
+      properties[key] = compileValue(value);
+    }
+    return {
+      type: "object",
+      additionalProperties: node.additionalProperties === true,
+      properties,
+      ...required.length > 0 ? { required } : {},
+      ...node.description !== void 0 ? { description: node.description } : {}
+    };
+  }
+  if (node.type === "array") {
+    return {
+      type: "array",
+      ...node.items !== void 0 ? { items: compileValue(node.items) } : {},
+      ...node.description !== void 0 ? { description: node.description } : {}
+    };
+  }
+  return {
+    type: node.type,
+    ...node.description !== void 0 ? { description: node.description } : {},
+    ...node.enum !== void 0 ? { enum: [...node.enum] } : {}
+  };
+}
+function compileParameters(spec) {
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(spec ?? {})) {
+    if (value?.required === true) required.push(key);
+    properties[key] = compileValue(value);
+  }
+  return { type: "object", properties, ...required.length > 0 ? { required } : {} };
+}
+function fallbackDefineTool(options) {
+  return {
+    name: options.name,
+    description: options.description,
+    parameters: compileParameters(options.parameters),
+    output: { schema: compileValue(options.output.schema), render: options.output.render },
+    execute: options.execute
+  };
+}
+var cached2;
+async function loadDefineTool() {
+  if (cached2 !== void 0) return cached2;
+  try {
+    const mod = await importDshPackage("@deepseek-ai/dsh-tools");
+    if (typeof mod?.defineTool === "function") {
+      cached2 = mod.defineTool;
+      return cached2;
+    }
+  } catch {
+  }
+  cached2 = fallbackDefineTool;
+  return cached2;
+}
+
+// src/tools.js
+async function guard(run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (error instanceof FeatureError2) {
+      throw new FeatureError2(error.code, error.message);
+    }
+    const code = typeof error?.code === "string" && error.code.length > 0 && error.code !== "ERR_ASSERTION" ? error.code : "experts/tool-failed";
+    throw new FeatureError2(code, String(error?.message ?? error));
+  }
+}
+function listRow(row) {
+  return {
+    expert_id: row.id,
+    name: row.name,
+    description: row.description,
+    preferred_skills: [...row.preferredSkills],
+    published: row.published,
+    revision_number: row.revisionNumber,
+    draft_revision: row.draftRevision,
+    updated_at: row.updatedAt
+  };
+}
+function draftFields(draft) {
+  if (draft === null || draft === void 0) {
+    return { name: "", description: "", role: "", preferred_skills: [] };
+  }
+  return {
+    name: draft.name,
+    description: draft.description,
+    role: draft.role,
+    preferred_skills: [...draft.preferredSkills ?? []]
+  };
+}
+function detailForModel(detail) {
+  const fields = draftFields(detail.draft);
+  const published = detail.publishedRevision;
+  return {
+    expert_id: detail.expert.id,
+    name: fields.name,
+    description: fields.description,
+    role: fields.role,
+    preferred_skills: fields.preferred_skills,
+    draft_revision: detail.expert.draftRevision,
+    published: published !== null,
+    revision_number: published?.number ?? 0,
+    ...published !== null ? { published_revision_id: published.id } : {},
+    updated_at: detail.expert.updatedAt
+  };
+}
+var authoredParameters = {
+  name: { type: "string", description: "\u4E13\u5BB6\u540D\u79F0\uFF0C1\u2013120 \u5B57\u7B26\uFF1B\u8FD9\u662F\u5217\u8868\u91CC\u663E\u793A\u7684\u540D\u5B57\u3002" },
+  description: { type: "string", description: "\u4E00\u53E5\u8BDD\u63CF\u8FF0\u8FD9\u4F4D\u4E13\u5BB6\u89E3\u51B3\u4EC0\u4E48\u95EE\u9898\uFF0C\u6700\u591A 2000 \u5B57\u7B26\u3002" },
+  role: { type: "string", description: "\u89D2\u8272\u8BF4\u660E\u6B63\u6587\uFF1A\u8FD9\u4F4D\u4E13\u5BB6\u7684\u80FD\u529B\u3001\u5224\u65AD\u6846\u67B6\u3001\u5DE5\u4F5C\u65B9\u5F0F\u4E0E\u8FB9\u754C\u3002\u8FD9\u6BB5\u6587\u5B57\u4F1A\u539F\u6837\u8FDB\u5165\u91C7\u7528\u5B83\u7684\u4F1A\u8BDD\u7684\u6A21\u578B\u4E0A\u4E0B\u6587\uFF0C\u8BF7\u5199\u5B8C\u6574\u7684\u6307\u4EE4\u6587\u672C\u800C\u4E0D\u662F\u6458\u8981\u3002" },
+  preferred_skills: {
+    type: "array",
+    description: "\u53EF\u9009\uFF1A\u9996\u9009\u6280\u80FD\u540D\u5217\u8868\uFF08\u6700\u591A 12 \u4E2A\uFF0C\u6BCF\u4E2A\u4E0D\u8D85\u8FC7 128 \u5B57\u7B26\uFF09\u3002\u53EA\u662F\u7ED9\u6A21\u578B\u7684\u63D0\u793A\uFF0C\u6280\u80FD\u4E0D\u5B58\u5728\u65F6\u4E0D\u62A5\u9519\uFF0C\u4F46\u4E0D\u8981\u5728\u7528\u6237\u6CA1\u63D0\u4F9B\u65F6\u51ED\u7A7A\u7F16\u9020\u540D\u79F0\u3002",
+    items: { type: "string" }
+  }
+};
+var expertProperties = {
+  expert_id: { type: "string", required: true },
+  name: { type: "string", required: true },
+  description: { type: "string", required: true },
+  role: { type: "string", required: true },
+  preferred_skills: { type: "array", required: true, items: { type: "string" } },
+  draft_revision: { type: "string", required: true, description: "\u8349\u7A3F\u7684\u5E76\u53D1\u4EE4\u724C\uFF1B\u4E0B\u6B21 expert_update \u4F20\u8FD9\u4E2A\u503C\u4F5C\u4E3A expected_revision\u3002" },
+  published: { type: "boolean", required: true },
+  revision_number: { type: "integer", required: true, description: "\u5DF2\u53D1\u5E03\u4FEE\u8BA2\u7684\u7F16\u53F7\uFF1B0 \u8868\u793A\u8FD8\u6CA1\u6709\u53D1\u5E03\u8FC7\u3002" },
+  published_revision_id: { type: "string", description: "\u5DF2\u53D1\u5E03\u4FEE\u8BA2 id\uFF1B\u4EC5\u5F53 published \u4E3A true \u65F6\u5B58\u5728\u3002" },
+  updated_at: { type: "string", required: true }
+};
+function renderExpert(value) {
+  return [
+    `${value.name}\uFF08expert_id=${value.expert_id}\uFF09`,
+    value.description,
+    value.published ? `\u5DF2\u53D1\u5E03\u4FEE\u8BA2 ${value.revision_number}\uFF08${value.published_revision_id}\uFF09` : "\u5C1A\u672A\u53D1\u5E03",
+    `\u8349\u7A3F\u4EE4\u724C ${value.draft_revision}`,
+    value.preferred_skills.length > 0 ? `\u9996\u9009\u6280\u80FD\uFF1A${value.preferred_skills.join("\u3001")}` : "\u672A\u58F0\u660E\u9996\u9009\u6280\u80FD"
+  ].join("\n");
+}
+async function registerExpertTools(ctx, manager) {
+  const defineTool = await loadDefineTool();
+  ctx.effect(() => ctx.tools.register(defineTool({
+    name: "expert_list",
+    description: "\u5217\u51FA\u672C\u673A\u5DF2\u6709\u7684\u4E13\u5BB6\uFF08\u89D2\u8272\u8BBE\u5B9A\uFF09\uFF0C\u53EF\u7528\u5173\u952E\u8BCD\u6309\u540D\u79F0\u3001\u63CF\u8FF0\u548C\u9996\u9009\u6280\u80FD\u8FC7\u6EE4\u3002\u8981\u4FEE\u6539\u67D0\u4F4D\u4E13\u5BB6\u524D\u5148\u7528\u5B83\u627E\u5230 expert_id\uFF1B\u53EA\u8BFB\uFF0C\u4E0D\u4FEE\u6539\u4EFB\u4F55\u5185\u5BB9\u3002",
+    parameters: {
+      query: { type: "string", description: "\u53EF\u9009\u5173\u952E\u8BCD\uFF0C\u6309\u540D\u79F0\u3001\u63CF\u8FF0\u548C\u9996\u9009\u6280\u80FD\u505A\u4E0D\u533A\u5206\u5927\u5C0F\u5199\u7684\u5339\u914D\uFF1B\u7701\u7565\u5219\u8FD4\u56DE\u5168\u90E8\u3002" }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          experts: {
+            type: "array",
+            required: true,
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                expert_id: { type: "string", required: true },
+                name: { type: "string", required: true },
+                description: { type: "string", required: true },
+                preferred_skills: { type: "array", required: true, items: { type: "string" } },
+                published: { type: "boolean", required: true },
+                revision_number: { type: "integer", required: true },
+                draft_revision: { type: "string", required: true },
+                updated_at: { type: "string", required: true }
+              }
+            }
+          }
+        }
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: value.experts.length > 0 ? value.experts.map((row) => `${row.name}\uFF08expert_id=${row.expert_id}${row.published ? ` \xB7 \u5DF2\u53D1\u5E03\u4FEE\u8BA2 ${row.revision_number}` : " \xB7 \u672A\u53D1\u5E03"}\uFF09
+${row.description}`).join("\n\n") : "\u672C\u673A\u8FD8\u6CA1\u6709\u4E13\u5BB6\u3002\u7528 expert_create \u521B\u5EFA\u7B2C\u4E00\u4F4D\u3002"
+      }]
+    },
+    async execute(args) {
+      const rows = await guard(() => manager.list(typeof args.query === "string" ? args.query : ""));
+      return { experts: rows.map(listRow) };
+    }
+  })), "dsh-plugin-experts: tool expert_list");
+  ctx.effect(() => ctx.tools.register(defineTool({
+    name: "expert_get",
+    description: "\u8BFB\u53D6\u4E00\u4F4D\u4E13\u5BB6\u7684\u5B8C\u6574\u5185\u5BB9\uFF1A\u540D\u79F0\u3001\u63CF\u8FF0\u3001\u89D2\u8272\u8BF4\u660E\u3001\u9996\u9009\u6280\u80FD\u3001\u8349\u7A3F\u5E76\u53D1\u4EE4\u724C\u548C\u5DF2\u53D1\u5E03\u4FEE\u8BA2\u3002\u4FEE\u6539\u524D\u5148\u8C03\u7528\u5B83\u62FF\u6700\u65B0\u7684 draft_revision\u3002\u53EA\u8BFB\u3002",
+    parameters: {
+      expert_id: { type: "string", required: true, description: "expert_list \u8FD4\u56DE\u7684 expert_id\u3002" }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          expert_id: { type: "string", required: true },
+          name: { type: "string", required: true, description: "\u4EE5\u4E0B\u5B57\u6BB5\u662F**\u5F53\u524D\u8349\u7A3F**\u7684\u5185\u5BB9\uFF0C\u4E5F\u5C31\u662F\u6B63\u5728\u7F16\u8F91\u7684\u7248\u672C\u3002" },
+          description: { type: "string", required: true },
+          role: { type: "string", required: true },
+          preferred_skills: { type: "array", required: true, items: { type: "string" } },
+          draft_revision: { type: "string", required: true },
+          published: { type: "boolean", required: true },
+          revision_number: { type: "integer", required: true },
+          published_revision_id: { type: "string" },
+          updated_at: { type: "string", required: true }
+        }
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: `${renderExpert(value)}
+
+\u89D2\u8272\u8BF4\u660E\uFF1A
+${value.role}`
+      }]
+    },
+    async execute(args) {
+      const detail = await guard(() => manager.get(args.expert_id));
+      return detailForModel(detail);
+    }
+  })), "dsh-plugin-experts: tool expert_get");
+  ctx.effect(() => ctx.tools.register(defineTool({
+    name: "expert_create",
+    description: "\u521B\u5EFA\u4E00\u4F4D\u65B0\u7684\u4E13\u5BB6\uFF08\u53EF\u590D\u7528\u7684\u89D2\u8272\u8BBE\u5B9A\uFF09\u3002\u8FD9\u662F**\u53EA\u5199\u8349\u7A3F**\uFF1A\u521B\u5EFA\u540E\u4E13\u5BB6\u5904\u4E8E\u672A\u53D1\u5E03\u72B6\u6001\uFF0C\u7528\u6237\u91C7\u7528\u524D\u8FD8\u9700\u8981 expert_publish\u3002\u89D2\u8272\u8BF4\u660E\u8981\u5199\u5B8C\u6574\u7684\u6307\u4EE4\u6B63\u6587\uFF0C\u4E0D\u8981\u53EA\u5199\u6458\u8981\uFF1B\u5B57\u6BB5\u7F3A\u5931\u6216\u8D85\u957F\u4F1A\u88AB\u62D2\u7EDD\u3002",
+    parameters: { ...authoredParameters, name: { ...authoredParameters.name, required: true }, description: { ...authoredParameters.description, required: true }, role: { ...authoredParameters.role, required: true } },
+    output: {
+      schema: { type: "object", additionalProperties: false, properties: expertProperties },
+      render: (_args, value) => [{ type: "text", text: `\u5DF2\u521B\u5EFA\u8349\u7A3F\uFF1A
+${renderExpert(value)}
+
+\u8BE5\u4E13\u5BB6\u5C1A\u672A\u53D1\u5E03\uFF1B\u786E\u8BA4\u5185\u5BB9\u65E0\u8BEF\u540E\u8C03\u7528 expert_publish\u3002` }]
+    },
+    async execute(args) {
+      const detail = await guard(() => manager.create({
+        name: args.name,
+        description: args.description,
+        role: args.role,
+        preferredSkills: args.preferred_skills
+      }));
+      return detailForModel(detail);
+    }
+  })), "dsh-plugin-experts: tool expert_create");
+  ctx.effect(() => ctx.tools.register(defineTool({
+    name: "expert_update",
+    description: "\u4FEE\u6539\u4E00\u4F4D\u4E13\u5BB6\u7684**\u8349\u7A3F**\u3002\u53EA\u4F20\u8981\u6539\u7684\u5B57\u6BB5\uFF0C\u672A\u63D0\u4F9B\u7684\u5B57\u6BB5\u4FDD\u6301\u4E0D\u53D8\u3002\u5FC5\u987B\u4F20 expected_revision\uFF08\u6765\u81EA expert_get / expert_create / \u4E0A\u4E00\u6B21 expert_update \u7684 draft_revision\uFF09\uFF0C\u8349\u7A3F\u5DF2\u88AB\u6539\u52A8\u65F6\u4F1A\u62D2\u7EDD\u5E76\u8981\u6C42\u91CD\u65B0\u8BFB\u53D6\uFF0C\u4E0D\u4F1A\u8986\u76D6\u4ED6\u4EBA\u7684\u4FEE\u6539\u3002\u7EDD\u4E0D\u6539\u52A8\u5DF2\u53D1\u5E03\u7684\u4FEE\u8BA2\u3002",
+    parameters: {
+      expert_id: { type: "string", required: true, description: "expert_list \u8FD4\u56DE\u7684 expert_id\u3002" },
+      expected_revision: { type: "string", required: true, description: "\u5E76\u53D1\u4EE4\u724C\uFF1Aexpert_get \u8FD4\u56DE\u7684 draft_revision\uFF0C\u539F\u6837\u4F20\u5165\u3002" },
+      name: { ...authoredParameters.name, description: "\u53EF\u9009\uFF1A\u65B0\u7684\u540D\u79F0\uFF1B\u7701\u7565\u5219\u4FDD\u6301\u4E0D\u53D8\u3002" },
+      description: { ...authoredParameters.description, description: "\u53EF\u9009\uFF1A\u65B0\u7684\u63CF\u8FF0\uFF1B\u7701\u7565\u5219\u4FDD\u6301\u4E0D\u53D8\u3002" },
+      role: { ...authoredParameters.role, description: "\u53EF\u9009\uFF1A\u65B0\u7684\u89D2\u8272\u8BF4\u660E\u6B63\u6587\uFF1B\u7701\u7565\u5219\u4FDD\u6301\u4E0D\u53D8\u3002" },
+      preferred_skills: { ...authoredParameters.preferred_skills, description: "\u53EF\u9009\uFF1A\u66FF\u6362\u6574\u4E2A\u9996\u9009\u6280\u80FD\u5217\u8868\uFF1B\u7701\u7565\u5219\u4FDD\u6301\u4E0D\u53D8\u3002" }
+    },
+    output: {
+      schema: { type: "object", additionalProperties: false, properties: expertProperties },
+      render: (_args, value) => [{ type: "text", text: `\u8349\u7A3F\u5DF2\u66F4\u65B0\uFF1A
+${renderExpert(value)}` }]
+    },
+    async execute(args) {
+      const patch = {};
+      if (args.name !== void 0) patch.name = args.name;
+      if (args.description !== void 0) patch.description = args.description;
+      if (args.role !== void 0) patch.role = args.role;
+      if (args.preferred_skills !== void 0) patch.preferredSkills = args.preferred_skills;
+      const detail = await guard(() => manager.updateDraft(args.expert_id, patch, args.expected_revision));
+      return detailForModel(detail);
+    }
+  })), "dsh-plugin-experts: tool expert_update");
+  ctx.effect(() => ctx.tools.register(defineTool({
+    name: "expert_publish",
+    description: "\u628A\u5F53\u524D\u8349\u7A3F\u51BB\u7ED3\u6210\u4E00\u4E2A**\u65B0\u7684\u3001\u4E0D\u53EF\u53D8\u7684\u3001\u5E26\u7F16\u53F7\u7684**\u5DF2\u53D1\u5E03\u4FEE\u8BA2\uFF0C\u5E76\u8BA9\u4E13\u5BB6\u6307\u5411\u5B83\u3002\u8FD9\u662F\u4E0D\u53EF\u64A4\u9500\u7684\u4E00\u6B65\uFF1A\u65E7\u4FEE\u8BA2\u548C\u5DF2\u7ECF\u91C7\u7528\u8BE5\u4E13\u5BB6\u7684\u4F1A\u8BDD\u90FD\u4E0D\u53D8\uFF0C\u4F46\u7528\u6237\u4ECE\u6B64\u91C7\u7528\u5230\u7684\u5C31\u662F\u8FD9\u4E00\u7248\u3002\u8C03\u7528\u524D\u5E94\u786E\u8BA4\u7528\u6237\u5DF2\u770B\u8FC7\u8349\u7A3F\u5185\u5BB9\u3002",
+    parameters: {
+      expert_id: { type: "string", required: true, description: "expert_list \u8FD4\u56DE\u7684 expert_id\u3002" },
+      expected_revision: { type: "string", description: "\u53EF\u9009\u5E76\u53D1\u4EE4\u724C\uFF1A\u8349\u7A3F\u7684 draft_revision\u3002\u4F20\u5165\u65F6\u8349\u7A3F\u4E0E\u4E4B\u4E0D\u7B26\u5C31\u62D2\u7EDD\uFF1B\u7701\u7565\u5219\u76F4\u63A5\u53D1\u5E03\u5F53\u524D\u8349\u7A3F\u3002" }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          expert_id: { type: "string", required: true },
+          revision_id: { type: "string", required: true, description: "\u65B0\u51BB\u7ED3\u7684\u4FEE\u8BA2 id\u3002" },
+          revision_number: { type: "integer", required: true },
+          name: { type: "string", required: true },
+          published: { type: "boolean", required: true },
+          draft_revision: { type: "string", required: true, description: "\u53D1\u5E03\u4E0D\u6539\u53D8\u8349\u7A3F\u4EE4\u724C\u3002" }
+        }
+      },
+      render: (_args, value) => [{ type: "text", text: `\u5DF2\u53D1\u5E03\u300C${value.name}\u300D\u4FEE\u8BA2 ${value.revision_number}\uFF08revision_id=${value.revision_id}\uFF09\u3002\u7528\u6237\u73B0\u5728\u53EF\u4EE5\u91C7\u7528\u8FD9\u4F4D\u4E13\u5BB6\u3002` }]
+    },
+    async execute(args) {
+      const result = await guard(() => manager.publish(args.expert_id, args.expected_revision));
+      return {
+        expert_id: result.expert.id,
+        revision_id: result.revision.id,
+        revision_number: result.revision.number,
+        name: result.revision.name,
+        published: true,
+        draft_revision: result.expert.draftRevision
+      };
+    }
+  })), "dsh-plugin-experts: tool expert_publish");
+}
+
+// index.js
+var name = "dsh-plugin-experts";
+var inject = ["connection", "storageDomain", "systemPrompt", "tools"];
+async function apply(ctx) {
+  registerExpertManagerSkillForLife(ctx);
+  const kit = await storageKit();
+  const manager = new ExpertManager(ctx, buildExpertDomains(kit));
+  await manager.init();
+  const runtime = registerExpertPromptContext(ctx, manager);
+  const handlers = manager.handlers();
+  const setAdoption = handlers["set-adoption"];
+  handlers["set-adoption"] = async (payload) => {
+    const result = await setAdoption(payload);
+    runtime.sync(payload?.sessionId);
+    return result;
+  };
+  const remove = handlers.delete;
+  handlers.delete = async (payload) => {
+    const result = await remove(payload);
+    for (const sessionId of result?.releasedSessions ?? []) runtime.sync(sessionId);
+    return result;
+  };
+  registerFeatureRoute(ctx, { feature: "experts", handlers });
+  await registerExpertTools(ctx, manager);
+  ctx.provide("dshSkillsExperts", { list: (query = "") => manager.list(query) });
+}
+function registerExpertManagerSkillForLife(ctx) {
+  if (typeof ctx.inject !== "function") return;
+  ctx.inject(["skills"], (scope) => {
+    registerExpertManagerSkill(scope);
+  });
+}
+export {
+  apply,
+  inject,
+  name
+};