dsh-plugin-t-expert 0.2.16 → 0.3.24

package/lib/schedule.js

@@ -0,0 +1,436 @@
+// @ts-check
+/**
+ * T专家 定时事项引擎：按 cron 表达式把提示词交给一个**全新的** agent 会话执行。
+ *
+ * 为什么自建而不是直接依赖 `@weibaohui/dsh-tasks`：用户明确要求两个插件可以同时安装、
+ * 同时可用。所以这里与它**零共享**——
+ *   · 数据不落它的 `dsh_tasks` 存储域，而是 T专家 自己的数据目录（`<root 同级>/schedule.json`）；
+ *   · 服务名 `tTeamSchedule`、错误码前缀 `tTeam/schedule-*`、消息来源 `plugin: dsh-plugin-t-expert`
+ *     全部独立，两个插件的任务互不可见、互不干扰。
+ *
+ * 三件事在这里闭环：
+ *   1. 持久化：一个 JSON 文件，原子写（与 `teams.json` 同级、同风格）；
+ *   2. 调度：每个启用项一个 croner job，宿主启动时全量重建，卸载时全部 stop；
+ *   3. 执行：新建 agent 会话 → 挂部署默认 preset（不挂就没有工具）→ 提交提示词。
+ *
+ * 开关语义（用户口径）：`setArmed(false)` = 定时事项功能整体停用——**停止全部定时触发**
+ * 且拒绝手动执行；任务与执行记录完整保留，重新 armed 后自动恢复调度。
+ */
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { Cron } from "croner";
+import { writeFileAtomic } from "./catalog.js";
+
+/** 定时事项服务名（remote 侧的服务访问器用它）。 */
+export const SCHEDULE_SERVICE = "tTeamSchedule";
+/** 数据文件名（落在 T专家 数据根下，与 teams.json 同级）。 */
+export const SCHEDULE_FILE_NAME = "schedule.json";
+/** 每条事项保留的执行记录条数（最旧的先丢）。 */
+export const MAX_RUNS = 20;
+/** 事项条数上限（防止一次误操作把设置文件写成天文数字）。 */
+export const MAX_ITEMS = 200;
+/** 标题 / 提示词的字符上限。 */
+export const MAX_TITLE_CHARS = 200;
+export const MAX_PROMPT_CHARS = 20000;
+/** 写进会话消息来源的插件名（与 dsh-tasks 区分开，两个插件的任务是两回事）。 */
+export const PLUGIN_ID = "dsh-plugin-t-expert";
+
+/**
+ * cron 表达式校验：构造一个 `paused` 的探测 job（只解析、不真的挂定时器），
+ * 随即 stop 掉，保证探测本身不会让事件循环多活一秒。
+ * @param {unknown} expression - 待校验的表达式。
+ * @param {(key: string, params?: Record<string, unknown>) => string} t - host 侧文案函数。
+ */
+export function validateCron(expression, t) {
+  const text = typeof expression === "string" ? expression.trim() : "";
+  if (text === "") throw new Error(t("schedule.cronEmpty"));
+  try {
+    const probe = new Cron(text, { paused: true }, () => undefined);
+    probe.stop();
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(t("schedule.invalidCron", { detail }));
+  }
+  return text;
+}
+
+/** 该表达式接下来的若干次触发时间（ISO 串），供面板在保存前预览。 */
+export function previewRuns(expression, t, count = 5) {
+  const text = validateCron(expression, t);
+  const probe = new Cron(text, { paused: true });
+  try {
+    return probe.nextRuns(count).map((date) => date.toISOString());
+  } finally {
+    probe.stop();
+  }
+}
+
+/** 短本地时间戳（`MM-DD HH:mm`）：同一个事项的多次运行在侧栏里要能区分开。 */
+export function runStamp(iso) {
+  const date = new Date(iso);
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+/** 追加一条执行记录（超过上限丢最旧的），并刷新最近一次执行摘要字段。 */
+export function withRun(item, entry) {
+  const runs = [...(Array.isArray(item.runs) ? item.runs : []), entry].slice(-MAX_RUNS);
+  const next = { ...item, runs, lastRunAt: entry.at };
+  // 成功时**删掉**失败字段而不是置 undefined：线上（remote 严格 schema）与 JSON 都不需要
+  // 一个"值为 undefined 的键"，留着只会让序列化前后形状不一致。
+  if (entry.ok === true) delete next.lastRunError;
+  else next.lastRunError = entry.error || "failed";
+  return next;
+}
+
+/** 校验一条事项的入参（面板提交的形状）；返回规范化后的字段。 */
+export function normalizeInput(input, t) {
+  if (input === null || typeof input !== "object") throw new Error(t("schedule.inputInvalid"));
+  const raw = /** @type {Record<string, unknown>} */ (input);
+  const title = typeof raw.title === "string" ? raw.title.trim() : "";
+  const prompt = typeof raw.prompt === "string" ? raw.prompt : "";
+  if (title === "") throw new Error(t("schedule.titleEmpty"));
+  if (title.length > MAX_TITLE_CHARS) throw new Error(t("schedule.titleTooLong", { limit: MAX_TITLE_CHARS }));
+  if (prompt.trim() === "") throw new Error(t("schedule.promptEmpty"));
+  if (prompt.length > MAX_PROMPT_CHARS) throw new Error(t("schedule.promptTooLong", { limit: MAX_PROMPT_CHARS }));
+  const cron = validateCron(raw.cron, t);
+  const enabled = raw.enabled !== false;
+  const workspaceId = typeof raw.workspaceId === "string" && raw.workspaceId !== "" ? raw.workspaceId : undefined;
+  return { title, prompt, cron, enabled, ...(workspaceId === undefined ? {} : { workspaceId }) };
+}
+
+/**
+ * 创建定时事项引擎。
+ *
+ * @param {object} options
+ * @param {any} options.ctx - 插件上下文（用 `ctx.get(...)` 懒查可选服务）。
+ * @param {string} options.file - 数据文件绝对路径。
+ * @param {any} options.logger - cordis logger（可缺省）。
+ * @param {(key: string, params?: Record<string, unknown>) => string} options.t - host 文案函数。
+ * @param {string} options.defaultCwd - 不绑定工作区时的会话工作目录。
+ * @param {boolean} [options.armed] - 初始是否启用调度（= 界面开关的当前值）。
+ * @param {(text: string) => Promise<string>} [options.expandPrompt] - 提交前的提示词改写
+ *   （提示词里挑中的 `@专家名` 由它落成召唤指令）。缺省就是原文。
+ * @param {(path: string, title?: string) => Promise<{ id: string, title: string, path: string }>} [options.ensureWorkspace]
+ *   - 准备定时任务的工作区（默认「定时任务」工作区，或面板里填的自定义目录）。缺省则面板该项不可用。
+ */
+export function createScheduleEngine(options) {
+  const { ctx, file, logger, t, defaultCwd } = options;
+  /** 工作区准备（默认「定时任务」工作区 / 自定义目录），由 host 注入。 */
+  const ensureWorkspace = typeof options.ensureWorkspace === "function" ? options.ensureWorkspace : undefined;
+  /** 提交前的提示词改写：没有注入就原样提交（定时任务本身不依赖它）。 */
+  const expandPrompt = typeof options.expandPrompt === "function"
+    ? options.expandPrompt
+    : async (text) => text;
+  /** @type {Map<string, any>} id → 事项 */
+  const items = new Map();
+  /** @type {Map<string, any>} id → croner job */
+  const jobs = new Map();
+  /** 正在执行中的事项 id：同一事项不并发跑两次。 */
+  const running = new Set();
+  let armed = options.armed !== false;
+  /** 写盘串行链：并发变更不能交错写同一个文件。 */
+  let writeChain = Promise.resolve();
+
+  /** 读盘（同步，apply 期就要拿到数据）。读不动时**出声**并按空列表继续。 */
+  function load() {
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch (error) {
+      const code = /** @type {any} */ (error)?.code;
+      if (code !== "ENOENT") {
+        logger?.warn?.(`[t-team] 定时事项数据文件读取失败（按空列表继续）：${file}：${error instanceof Error ? error.message : String(error)}`);
+      }
+      return;
+    }
+    try {
+      const parsed = JSON.parse(text);
+      const list = Array.isArray(parsed?.items) ? parsed.items : [];
+      for (const entry of list) {
+        if (entry === null || typeof entry !== "object") continue;
+        if (typeof entry.id !== "string" || typeof entry.cron !== "string") continue;
+        items.set(entry.id, {
+          id: entry.id,
+          title: typeof entry.title === "string" ? entry.title : "",
+          prompt: typeof entry.prompt === "string" ? entry.prompt : "",
+          cron: entry.cron,
+          enabled: entry.enabled !== false,
+          ...(typeof entry.workspaceId === "string" && entry.workspaceId !== "" ? { workspaceId: entry.workspaceId } : {}),
+          createdAt: typeof entry.createdAt === "string" ? entry.createdAt : new Date().toISOString(),
+          updatedAt: typeof entry.updatedAt === "string" ? entry.updatedAt : new Date().toISOString(),
+          ...(typeof entry.lastRunAt === "string" ? { lastRunAt: entry.lastRunAt } : {}),
+          ...(typeof entry.lastRunError === "string" ? { lastRunError: entry.lastRunError } : {}),
+          runs: Array.isArray(entry.runs) ? entry.runs.slice(-MAX_RUNS) : [],
+        });
+      }
+    } catch (error) {
+      logger?.warn?.(`[t-team] 定时事项数据文件解析失败（按空列表继续）：${file}：${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /** 落盘：串行 + 原子写（临时文件 + rename），失败只告警不打断内存态。 */
+  function persist() {
+    const payload = `${JSON.stringify({ version: 1, items: [...items.values()] }, null, 2)}\n`;
+    writeChain = writeChain
+      .then(() => writeFileAtomic(file, payload))
+      .catch((error) => {
+        logger?.warn?.(`[t-team] 定时事项写盘失败：${file}：${error instanceof Error ? error.message : String(error)}`);
+      });
+    return writeChain;
+  }
+
+  /** 停掉一个 job（幂等）。 */
+  function stopJob(id) {
+    const job = jobs.get(id);
+    if (job === undefined) return;
+    try {
+      job.stop();
+    } catch {
+      /* 已经停掉的 job 再 stop 无所谓 */
+    }
+    jobs.delete(id);
+  }
+
+  /** 按当前 armed 状态与 enabled 标记给一条事项挂/摘定时器。 */
+  function scheduleOne(item) {
+    stopJob(item.id);
+    if (!armed || item.enabled !== true) return;
+    try {
+      // `unref: true`：不让定时器把宿主进程的事件循环钉住（进程想退出就能退出）。
+      // 它是 croner 的**构造选项**，不是 job 上的方法（写成 job.unref() 会静默无效）。
+      const job = new Cron(item.cron, { unref: true }, () => {
+        void runScheduled(item.id);
+      });
+      jobs.set(item.id, job);
+    } catch (error) {
+      // 表达式在写入时已校验过，这里失败只可能是运行期异常（例如 croner 版本差异）：
+      // 记一条 warn 并保持该事项不调度，别让一个坏 job 拖垮整张表。
+      logger?.warn?.(`[t-team] 定时事项「${item.title}」调度失败（该事项不会自动触发）：${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /** 全量重建调度表（启动、开关切换、批量变更后调用）。 */
+  function rescheduleAll() {
+    for (const id of [...jobs.keys()]) stopJob(id);
+    if (!armed) return;
+    for (const item of items.values()) scheduleOne(item);
+  }
+
+  /** 定时触发的入口：跑完更新记录并落盘。 */
+  async function runScheduled(id) {
+    const current = items.get(id);
+    if (current === undefined || !armed) return;
+    if (running.has(id)) return; // 上一轮还没跑完，这一轮跳过（不排队、不叠加）
+    const updated = await execute(current);
+    items.set(id, updated);
+    await persist();
+  }
+
+  /**
+   * 执行一条事项：新建会话 + 提交提示词，把结果记进 runs。
+   * 失败**不抛**（定时路径没人接异常），而是把原因写进 `lastRunError`。
+   */
+  async function execute(item) {
+    const startedAt = new Date().toISOString();
+    running.add(item.id);
+    try {
+      const agents = ctx.get("agents");
+      if (agents === undefined || typeof agents.create !== "function") {
+        throw new Error(t("schedule.agentsMissing"));
+      }
+      const workspace = item.workspaceId === undefined
+        ? undefined
+        : ctx.get("workspaceRegistry")?.get?.(item.workspaceId);
+      if (item.workspaceId !== undefined && workspace === undefined) {
+        throw new Error(t("schedule.workspaceMissing", { id: item.workspaceId }));
+      }
+      const selection = ctx.get("agentDefaultModel")?.currentSelection?.() ?? {};
+      const sessionId = `session-${randomUUID()}`;
+      const handle = await agents.create({
+        sessionId,
+        meta: { cwd: workspace ? workspace.path : defaultCwd },
+        ...(typeof selection.provider === "string" && typeof selection.model === "string"
+          ? { agentOptions: { provider: selection.provider, model: selection.model } }
+          : {}),
+        // 没有 preset 挂载的新会话**没有任何工具**（模型只能空口回答），所以这里按 web 网关
+        // 建会话的同款做法解析并挂上部署的默认 preset。
+        setup: async (agentCtx) => {
+          const presets = ctx.get("agentPresets");
+          if (!presets || typeof presets.resolve !== "function" || typeof presets.mount !== "function") return;
+          const resolved = await presets.resolve(undefined);
+          if (resolved && resolved.id) await presets.mount(agentCtx, resolved.id);
+        },
+      });
+      if (workspace !== undefined && typeof workspace.attachSession === "function") {
+        await workspace.attachSession(sessionId);
+      }
+      // 标题钉成「事项标题 · 时间」：同一事项的多次运行在侧栏里能一一区分。
+      // 以 `user` 来源直接写日志，避免自动标题生成把它覆盖掉（失败不致命）。
+      try {
+        handle.agent.session.append("session/title", {
+          title: `${item.title} · ${runStamp(startedAt)}`,
+          messageSeqs: [],
+          source: { kind: "user" },
+        });
+      } catch {
+        /* 标题没钉上也照样执行 */
+      }
+      // 提示词里可能带 `@专家名`（面板里挑中的那位）：交给注入的改写器落成召唤指令。
+      // 改写失败不致命 —— 退回原文提交，任务照跑，只在日志里留一句可查的线索。
+      let promptText = item.prompt;
+      try {
+        promptText = await expandPrompt(item.prompt);
+      } catch (error) {
+        logger?.warn?.(`[t-team] 定时任务「${item.title}」的提示词改写失败，按原文提交：${error instanceof Error ? error.message : String(error)}`);
+      }
+      handle.agent.followup({
+        id: randomUUID(),
+        role: "user",
+        content: [{ type: "text", text: promptText }],
+        source: { kind: "plugin", plugin: PLUGIN_ID },
+      });
+      return withRun(item, { at: startedAt, ok: true, sessionId });
+    } catch (error) {
+      return withRun(item, {
+        at: startedAt,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    } finally {
+      running.delete(item.id);
+    }
+  }
+
+  load();
+  // 读盘之后必须**立刻**按当前开关挂上定时器：少了这一句，插件每次启动都是"任务在、但永远不触发"，
+  // 直到用户碰一下开关或增删一条才恢复 —— 那种"看着正常、其实没在跑"的失效最难发现，所以这里
+  // 也有对应自检（verify [20c] 的「重启后 enabled 的任务自动进入调度」）。
+  rescheduleAll();
+
+  /** 面板要的全部数据：事项 + 开关状态 + 可选工作区（一次调用拿全，省一次往返）。 */
+  function snapshot() {
+    const registry = ctx.get("workspaceRegistry") ?? ctx.get("workspace");
+    const list = typeof registry?.list === "function" ? registry.list() : [];
+    return {
+      items: [...items.values()],
+      armed,
+      file,
+      running: [...running],
+      capabilities: {
+        agents: typeof ctx.get("agents")?.create === "function",
+        presets: typeof ctx.get("agentPresets")?.mount === "function",
+      },
+      workspaces: list.map((workspace) => ({
+        id: String(workspace.id ?? ""),
+        title: String(workspace.title ?? workspace.path ?? ""),
+        // 目录：面板把它显示在表单里，用户能看清这条任务落在哪个文件夹。
+        path: typeof workspace.path === "string" ? workspace.path : "",
+      })).filter((workspace) => workspace.id !== ""),
+    };
+  }
+
+  /** 新建一条事项。 */
+  async function create(input) {
+    if (items.size >= MAX_ITEMS) throw new Error(t("schedule.tooManyItems", { limit: MAX_ITEMS }));
+    const fields = normalizeInput(input, t);
+    const now = new Date().toISOString();
+    const item = {
+      id: `item-${randomUUID()}`,
+      ...fields,
+      createdAt: now,
+      updatedAt: now,
+      runs: [],
+    };
+    items.set(item.id, item);
+    scheduleOne(item);
+    await persist();
+    return item;
+  }
+
+  /** 改一条事项（只覆盖传进来的字段）。 */
+  async function update(id, patch) {
+    const current = items.get(id);
+    if (current === undefined) throw new Error(t("schedule.itemMissing", { id }));
+    const source = patch === null || typeof patch !== "object" ? {} : patch;
+    const merged = {
+      title: source.title === undefined ? current.title : source.title,
+      prompt: source.prompt === undefined ? current.prompt : source.prompt,
+      cron: source.cron === undefined ? current.cron : source.cron,
+      enabled: source.enabled === undefined ? current.enabled : source.enabled,
+      workspaceId: source.workspaceId === undefined ? current.workspaceId : source.workspaceId,
+    };
+    const fields = normalizeInput(merged, t);
+    const next = { ...current, ...fields, updatedAt: new Date().toISOString() };
+    // 展开旧记录会把旧的 workspaceId 一起带过来：用户把绑定改回「不绑定」时
+    // fields 里没有这个键，必须显式删掉，否则界面上看着解绑了、执行时还挂在旧工作区。
+    if (fields.workspaceId === undefined) delete next.workspaceId;
+    items.set(id, next);
+    scheduleOne(next);
+    await persist();
+    return next;
+  }
+
+  /** 删一条事项（顺带摘掉它的定时器）。 */
+  async function remove(id) {
+    if (!items.has(id)) throw new Error(t("schedule.itemMissing", { id }));
+    stopJob(id);
+    items.delete(id);
+    await persist();
+    return { removed: true };
+  }
+
+  /** 立即执行一条事项（面板上的「立即执行」）。 */
+  async function runNow(id) {
+    if (!armed) throw new Error(t("schedule.disabled"));
+    const current = items.get(id);
+    if (current === undefined) throw new Error(t("schedule.itemMissing", { id }));
+    if (running.has(id)) return current; // 正在跑就原样返回，面板保持「执行中…」
+    const updated = await execute(current);
+    items.set(id, updated);
+    await persist();
+    return updated;
+  }
+
+  /**
+   * 开关联动：关掉 = 停止全部定时触发并拒绝手动执行；打开 = 按 stored enabled 全量重建。
+   * 只改运行态，不写数据文件（开关本身是界面偏好，存在宿主设置里）。
+   */
+  function setArmed(next) {
+    const value = next !== false;
+    if (value === armed) return { armed };
+    armed = value;
+    rescheduleAll();
+    return { armed };
+  }
+
+  /** 卸载：停掉全部定时器（数据留着，下次启动重建）。 */
+  function dispose() {
+    for (const id of [...jobs.keys()]) stopJob(id);
+  }
+
+  return {
+    file,
+    snapshot,
+    list: () => [...items.values()],
+    create,
+    update,
+    remove,
+    runNow,
+    preview: (cron) => ({ fires: previewRuns(cron, t) }),
+    /** 给面板用：确保定时任务的默认工作区（或自定义目录）存在，返回 { id, title, path }。 */
+    ensureWorkspace: (path, title) => {
+      if (ensureWorkspace === undefined) {
+        return Promise.reject(new Error("宿主没有提供工作区准备能力（ensureWorkspace）。"));
+      }
+      return ensureWorkspace(path, title);
+    },
+    setArmed,
+    isArmed: () => armed,
+    /** 当前真正挂着定时器的事项 id（自检与诊断用：能看出"任务在、但没排定"这种失效）。 */
+    scheduledIds: () => [...jobs.keys()],
+    dispose,
+    /** 开关变化后重建调度（settings 回调里用）。 */
+    rescheduleAll,
+  };
+}

package/lib/skill.js

@@ -33,10 +33,20 @@ export const SKILLS_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), ".."
  * 随包发布的 skill 清单（目录名 = 宿主路由用的 skill 名）。
  *
  * 顺序即注册顺序。缺文件的条目会被跳过并逐条告警，而不是让整段注册失败 ——
- * 一个 skill 文件缺失不该带走另外两个。
+ * 一个 skill 文件缺失不该带走另外两个（见 {@link LOCAL_ONLY_SKILL_NAMES} 的例外）。
  */
 export const BUNDLED_SKILL_NAMES = ["t-expert-manager", "dsh-harness-project", "dsh-harness-languages"];
 
+/**
+ * **只在本机布局里存在**的 skill：不进 npm 包（见 `package.json` 的 `files`）。
+ *
+ * 为什么：`t-expert-manager` 的正文整篇都是 `tz.sh` 运维流程，而 `ops/`、`tools/`、`tz.sh`
+ * 都不随包发布 —— 从 npm 装的人本来就不该有它，拿了也是一份跑不动的手册。所以它缺席是**预期**，
+ * 不能按"缺文件"告警（否则每次启动一条"未注册"，看着像装坏了）。本机从源码装（`tz.sh install`
+ * 会把整个 `skills/` 复制进运行副本）时它照常在，运维流程一字不少。
+ */
+export const LOCAL_ONLY_SKILL_NAMES = ["t-expert-manager"];
+
 /** 只有运维 skill 的正文带 `{{TZ}}` / `{{OPS_ROOT}}` 占位符，其余按原样注册。 */
 const PLACEHOLDER_SKILL = "t-expert-manager";
 
@@ -161,17 +171,23 @@ function loadBundledSkill(name, config = {}) {
 /**
  * 逐个构建随包 skill，并**记下**哪些条目没建成以及为什么。
  *
- * 注册方靠 `missing` 逐条告警 —— 缺一个文件不该静默、也不该带走另外两个。
+ * 注册方靠 `missing` 逐条告警 —— 缺一个文件不该静默、也不该带走另外两个；
+ * 唯一的例外是 {@link LOCAL_ONLY_SKILL_NAMES}：它们不随 npm 包发布，缺席是预期。
  * @param config - 插件配置。
- * @returns `{ skills, missing }`；顺序与 {@link BUNDLED_SKILL_NAMES} 一致。
+ * @returns `{ skills, missing }`；`skills` 顺序与 {@link BUNDLED_SKILL_NAMES} 一致。
  */
 function collectBundledSkills(config = {}) {
   const skills = [];
   const missing = [];
   for (const name of BUNDLED_SKILL_NAMES) {
     const loaded = loadBundledSkill(name, config);
-    if (loaded.skill === undefined) missing.push({ name, reason: loaded.reason });
-    else skills.push(loaded.skill);
+    if (loaded.skill !== undefined) {
+      skills.push(loaded.skill);
+      continue;
+    }
+    // 本机专有的 skill（npm 包里本来就没有）：缺席是预期，既不告警也不进 missing。
+    if (LOCAL_ONLY_SKILL_NAMES.includes(name)) continue;
+    missing.push({ name, reason: loaded.reason });
   }
   return { skills, missing };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-t-expert",
-  "version": "0.2.16",
+  "version": "0.3.24",
   "type": "module",
   "description": "T Expert — a 316-expert, 22-division roster with full Chinese translations, as a standalone DeepSeek Harness plugin, with a built-in multi-agent team engine (T Team).",
   "license": "MIT",
@@ -42,7 +42,8 @@
   "files": [
     "lib",
     "data",
-    "skills",
+    "skills/dsh-harness-project",
+    "skills/dsh-harness-languages",
     "cordis.patch.yml",
     "README.md",
     "LICENSE",
@@ -172,6 +173,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
+    "croner": "^9.1.0",
     "zod": "^4.4.3"
   }
 }

package/vendor/third-party-licenses/README.md

@@ -5,7 +5,7 @@
 
 | 文件 | 覆盖的随包内容 | 来源 |
 | --- | --- | --- |
-| `agency-agents.LICENSE` | `data/experts/`（22 分区 / 316 位；其中 315 位来自第三方 —— 279 位为上游仓库逐字节镜像、35 位来自名册来源包快照；余 2 位为本仓自建，不由本许可覆盖） | The Agency / AgentLand 名册快照，MIT |
+| `agency-agents.LICENSE` | `data/experts/`（22 分区 / 316 位；其中 314 位来自第三方 —— 279 位为上游仓库逐字节镜像、35 位来自名册来源包快照；余 2 位为本仓自建，不由本许可覆盖） | The Agency / AgentLand 名册快照，MIT |
 | `agency-agents-zh.LICENSE` | `data/zh/` 中的中文名字、简介与人格正文 | `agency-agents-zh` 中文翻译与本地化资产，MIT |
 
 两份文本都是从实际用于生成快照的来源包内**逐字节复制**的，未经改写：

package/vendor/third-party-licenses/croner.LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2021 Hexagon <github.com/Hexagon>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/skills/t-expert-manager/SKILL.md

@@ -1,119 +0,0 @@
----
-name: t-expert-manager
-description: T专家 运维台 —— 316 位专家 / 22 分区的名册增删、名册一致性校验、统计与中文覆盖、小队（/t）成员编辑、装机到 DSH Desktop、发布到 npm。Use when the user asks to add/remove/validate/count T专家 experts, 新增专家 / 删除专家 / 校验名册 / 名册统计 / 改小队 / 重装插件 / 发布插件.
----
-
-# T专家 运维（expert-manager）
-
-运维入口只有一个：`bash "{{TZ}}"`。本机运维台根目录：`{{OPS_ROOT}}`。
-
-这套流程解决的是「你是原作者，要维护自己的名册和插件」的场景；只想**用**专家或拉小队，不要走这里
-（用 `list_t_experts` / `summon_t_expert`，小队用 `/t`）。
-
-## 铁律
-
-1. **只用 tz.sh**。不要手改 `data/experts/`、`plugin/`、`~/.t-team/`，也不要手改 `package.json` 的版本号 ——
-   这些动作脚本都代劳了，绕开脚本换来的就是"源码加了、运行时没加"这类半成品状态。
-2. **`data/experts/` 是真源**。增删由 `add-expert.py`（tz.sh 代跑）执行，它**同时写**源码与运行时
-   `~/.t-team/experts/`，两边永远一致。
-3. **统计必须递归**。有专家落在嵌套子目录（如 `game-development/unreal-engine/…`），
-   只看分类目录的第一层会漏掉它们。位数一律以 `tz.sh status` 的递归结果为准 ——
-   正文里不写死位数，因为每加一位专家它就会过期。
-4. **数据更新不用重装、不用重启**（宿主按 mtime 指纹自动重载名册）；**改插件代码**才需要
-   `tz.sh build` → `tz.sh install` → 重启 DSH Desktop。
-5. **小队改完分两条路，只有设置页那条会热重载**：
-   - **设置页「队伍」保存**（推荐）：`squads.save()` 编译成功后**就地热重载引擎配置 → 立即生效、不用重启**。
-   - **`tz.sh squads`（= 菜单 11）**：只是 CLI 直跑编译器（`python3 data/team-profiles.py`）把 `teams.json`
-     编译成引擎配置，**不经过插件、不会热重载**——运行中的引擎仍用旧 profiles，**必须重启 DSH**
-     （或再到设置页保存一次）才生效。所以别对用户说「跑完 tz.sh squads 就已经生效」。
-   两条路的失败语义一致：编译失败会**回滚**，盘上仍是旧配置（按旧小队建队）。
-   只有**改插件代码**才需要重启（见第 4 条）。
-6. **`data/zh/` 已冻结**：不要新增或"补译"中文。新专家没有中文名/简介会回退英文，这是预期行为。
-7. **破坏性动作先确认**：删除专家、卸载插件、发布 npm 之前，把影响讲给用户听，得到明确同意再执行。
-
-## 先看状态
-
-```bash
-bash "{{TZ}}" status
-```
-
-一眼给出：名册位数 / 分类数 / 中文覆盖 / 插件版本 vs DSH 里装的版本 / 仓库是否干净。
-
-## 工作流
-
-### A. 新增专家
-
-1. 先确认 slug 不冲突（`bash "{{TZ}}" roster` 看现有分类与位数）。
-2. **先 dry-run**：
-   ```bash
-   bash "{{TZ}}" experts add --category <分区> --slug <slug> --file </绝对路径/xxx.md> --dry-run
-   ```
-3. 确认路径无误后去掉 `--dry-run` 正式写入。源文件缺 frontmatter 时补 `--name` / `--description`；
-   目标已存在要覆盖时加 `--force`。
-4. 收尾校验：`bash "{{TZ}}" experts check`，必须报"三处一致"。
-
-### B. 删除专家
-
-先 `--dry-run` 看清要删的两条路径，再执行：
-
-```bash
-bash "{{TZ}}" experts remove --category <分区> --slug <slug> --yes
-```
-
-源码与运行时会被一并删除（`--yes` 跳过交互确认，所以**先跟用户确认过**再用）。
-
-### C. 校验名册
-
-```bash
-bash "{{TZ}}" experts check     # 源码 ↔ 运行时 ↔ 清单，逐文件 sha256；退出码 1 = 有漂移
-bash "{{TZ}}" verify            # check + 插件自检（verify.mjs），改过代码后必跑
-```
-
-### D. 统计与中文覆盖
-
-```bash
-bash "{{TZ}}" experts stats
-```
-
-汇报时给"分类数 / 专家数 / 中文覆盖"，不要把整张分类表贴给用户。
-
-### E. 修改小队（`/t`）
-
-1. 小队定义在 `data/teams.json`（人工维护）：成员写专家 slug 字符串，或 `{slug, role}` 对象。
-2. 用编辑器改完后编译成引擎配置：
-   ```bash
-   bash "{{TZ}}" squads
-   ```
-3. 明确告诉用户：**`tz.sh squads` 只是 CLI 直跑编译器**——它把 `teams.json` 编译成引擎配置，
-   **不会让运行中的插件重载**。所以：**要让新小队真正生效，需重启 DSH Desktop**（或再到设置页「队伍」保存一次，
-   那条路才会就地热重载、立即生效）。若 `/t` 里仍看不到新小队，先确认编译没报错（编译失败会回滚，盘上仍是旧配置）。
-4. 想免重启就直接走设置页：设置 → T专家 → 队伍 → 改完保存（`squads.save()` 编译成功后触发引擎热重载，立即生效）。
-
-### F. 装机（只在改过插件代码时需要）
-
-```bash
-bash "{{TZ}}" verify            # 先自检
-bash "{{TZ}}" build             # 构建 client bundle
-bash "{{TZ}}" install           # 装到 profile（默认 desktop）；可先 --dry-run
-```
-
-装机后仍需**重启 DSH Desktop**。装错/装坏时 `bash "{{TZ}}" install-restore` 可还原被接管的依赖。
-
-### G. 发布到 npm
-
-```bash
-bash "{{TZ}}" publish-dry       # 预演：只跑预检与打包预览
-bash "{{TZ}}" publish           # 默认 patch；也可 --minor / --major / --version X.Y.Z
-```
-
-**发布前必须**：(a) 得到用户明确同意；(b) `experts check` 与 `verify` 全绿；(c) 工作区没有未提交的意外改动。
-
-## 汇报约定
-
-- 给"执行的命令 + 结尾结论"，不要贴整篇日志。
-- 失败就贴出错那一段（含退出码）并说明下一步；不要静默重试或换个命令重来。
-- 名册位数永远按递归结果报（见铁律 3）。
-
-## 参考
-
-- `references/ops-reference.md` —— 完整子命令 / 菜单号 / 参数表，以及"哪份文件是真源"的地图。