dsh-plugin-t-expert 0.2.16 → 0.3.24

package/lib/i18n.js

@@ -48,6 +48,21 @@ const ZH = {
   "summon.batchHeader": "批量召唤 {total} 位专家：成功 {ok} / 失败 {failed}",
   "summon.itemOk": "## {expert}\n{answer}",
   "summon.itemFail": "## {expert}\n失败：{error}",
+  // ---- 定时任务（host 侧只负责校验与执行失败的原因文案；面板文案在客户端字典里）----
+  "schedule.cronEmpty": "cron 定时器不能为空",
+  "schedule.invalidCron": "cron 表达式无法解析：{detail}",
+  "schedule.inputInvalid": "定时任务的入参必须是一个对象",
+  "schedule.titleEmpty": "定时任务的标题不能为空",
+  "schedule.titleTooLong": "标题超过 {limit} 个字符",
+  "schedule.promptEmpty": "定时任务的提示词不能为空",
+  "schedule.promptTooLong": "提示词超过 {limit} 个字符",
+  "schedule.itemMissing": "找不到定时任务「{id}」（它可能已被删除）",
+  "schedule.tooManyItems": "定时任务最多 {limit} 条：请先删掉一些再新建",
+  "schedule.agentsMissing": "宿主没有可用的 agents 服务，无法为定时任务新建会话",
+  "schedule.workspaceMissing": "定时任务绑定的工作区「{id}」不存在（可能已被删除）",
+  "schedule.expertInvoke": "请用 summon_t_expert 召唤专家「{name}」来完成下面这件事，并原样转述它的结论；如果该工具不可用，就按这位专家的规范自己完成。\n\n任务：{task}",
+  "schedule.expertInvokeMany": "请用 summon_t_experts 同时召唤这些专家来完成下面这件事，并原样转述各自的结论：{names}。如果该工具不可用，就按这些专家的规范自己完成。\n\n任务：{task}",
+  "schedule.disabled": "定时任务功能当前已关闭：请在 设置 → T专家 里重新打开「显示定时任务按钮」",
 };
 
 const EN = {
@@ -95,6 +110,21 @@ const EN = {
   "summon.batchHeader": "Summoned {total} experts: {ok} succeeded / {failed} failed",
   "summon.itemOk": "## {expert}\n{answer}",
   "summon.itemFail": "## {expert}\nfailed: {error}",
+  // ---- Scheduled tasks (the host owns validation/execution failure text; the panel owns its own) ----
+  "schedule.cronEmpty": "The cron schedule must not be empty",
+  "schedule.invalidCron": "Cannot parse the cron expression: {detail}",
+  "schedule.inputInvalid": "A scheduled task must be an object",
+  "schedule.titleEmpty": "A scheduled task needs a title",
+  "schedule.titleTooLong": "The title exceeds {limit} characters",
+  "schedule.promptEmpty": "A scheduled task needs a prompt",
+  "schedule.promptTooLong": "The prompt exceeds {limit} characters",
+  "schedule.itemMissing": "Scheduled task \"{id}\" not found (it may have been deleted)",
+  "schedule.tooManyItems": "At most {limit} scheduled tasks: delete some before adding more",
+  "schedule.agentsMissing": "The host has no usable agents service, so no session can be created for this scheduled task",
+  "schedule.workspaceMissing": "The workspace bound to this scheduled task (\"{id}\") no longer exists",
+  "schedule.expertInvoke": "Summon the expert \"{name}\" with summon_t_expert to carry out the task below, and relay its findings verbatim; if that tool is unavailable, do it yourself following that expert's playbook.\n\nTask: {task}",
+  "schedule.expertInvokeMany": "Summon these experts together with summon_t_experts to carry out the task below, and relay each of their findings verbatim: {names}. If that tool is unavailable, do it yourself following those experts' playbooks.\n\nTask: {task}",
+  "schedule.disabled": "Scheduled tasks are currently turned off: re-enable \"Show scheduled tasks button\" in Settings → T Expert",
 };
 
 /** 取文案并按 {name} 占位替换。 */

package/lib/index.js

@@ -12,8 +12,8 @@
  */
 import { homedir } from "node:os";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { stat, rmdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { mkdir, stat, rmdir } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
 import schema from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import {
@@ -46,6 +46,9 @@ import { registerTeamCommand } from "./command.js";
 import { createSquadService } from "./squads.js";
 import { SNAPSHOT_DIR } from "./bootstrap.js";
 import { checkPlan } from "./plan-check.js";
+// 定时事项引擎：T专家 自己的实现（JSON 文件 + croner），与 @weibaohui/dsh-tasks 零共享 ——
+// 两个插件允许同时安装同时可用，所以存储、服务名、错误码、消息来源全都各走各的。
+import { SCHEDULE_FILE_NAME, SCHEDULE_SERVICE, createScheduleEngine } from "./schedule.js";
 import { findTeamByCaptain } from "./teams/state.js";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 // 内置团队引擎：随插件一起发布的品牌化产物在 lib/teams/ 下（源自第三方引擎，改名后
@@ -108,6 +111,16 @@ export const Config = schema.object({
   memberModel: schema.string(),
   /** 一支团队最多几名成员。 */
   maxMembers: schema.natural().min(1).default(8),
+  /**
+   * 定时任务默认绑定的工作区（首次使用时自动建/复用）。
+   *
+   * 为什么要有它：定时任务跑出来的会话如果"不绑定工作区"，在侧栏里就没有归属，
+   * 一堆自动会话会散在工作区列表外面；给它们一个固定去处（默认「定时任务」工作区、
+   * 目录 <默认目录>/tesk）最好找。目录不存在会被建出来 —— 宿主的工作区 create
+   * 只接受已存在的目录。
+   */
+  scheduleWorkspaceTitle: schema.string().default("定时任务"),
+  scheduleWorkspaceDir: schema.string().default(join(homedir(), "tesk")),
 });
 
 /** 供 remote 服务读取名册的服务名。 */
@@ -116,6 +129,13 @@ export const CATALOG_SERVICE = "tTeamCatalog";
 export const SQUAD_SERVICE = "tTeamSquads";
 /** 团队运行服务（设置页「团队」标签列活动/归档团队、停止团队）。 */
 export const TEAM_SERVICE = "tTeamTeams";
+/**
+ * 定时事项服务（remote 侧与服务访问器共用）。
+ *
+ * 定义在 `lib/schedule.js`（引擎与常量同处一地），这里**再导出**一次：`lib/remote.js` 与本文件
+ * 都从同一处取常量，避免出现两个字面量各写一遍、改名时漏改一处的经典漂移。
+ */
+export { SCHEDULE_SERVICE };
 /** 设置命名空间（= 插件名）。 */
 export const SETTINGS_NAMESPACE = NS;
 
@@ -131,6 +151,15 @@ export const UNKNOWN_SLUG_ERROR_CODE = "tTeam/unknown-slug";
 
 const settingsSchema = schema.object({
   enabled: schema.array(schema.string()).default([]),
+  /** 是否自动显示右上角的任务徽章（界面偏好，关掉后只在输入区浮层里手动查看）。 */
+  showTaskBadge: schema.boolean().default(true),
+  /**
+   * 是否显示侧栏「定时事项」按钮（界面偏好）。
+   *
+   * 语义（用户口径）：**关掉 = 定时事项功能整体停用** —— 不只是藏按钮，还要停掉全部定时触发
+   * （见 apply 里的 applyScheduleArmed）。任务与执行记录完整保留，重新打开即恢复调度。
+   */
+  showScheduleButton: schema.boolean().default(true),
 });
 
 /**
@@ -215,6 +244,119 @@ export function apply(ctx, config) {
     ctx.logger?.error?.(`[t-team] 名册快照同步失败，将按已有数据继续：${seeded.error}`);
   }
 
+  // ---- 定时事项引擎（T专家 自己的数据文件 + croner 调度）----
+  // 数据落在**本插件自己的数据根**里（`~/.t-team/schedule.json`，与 teams.json 同级）：
+  // 刻意不碰宿主的 dsh_tasks 存储域，也不碰 dsh-tasks 插件的任何文件——两个插件同时装着时，
+  // 各自的任务列表、执行记录、定时器完全隔离，谁先加载都不影响对方。
+  const scheduleEngine = createScheduleEngine({
+    ctx,
+    file: join(dirname(config.root), SCHEDULE_FILE_NAME),
+    logger: ctx.logger,
+    // 文案按**当前**语言现取：错误消息会出现在面板上，切了语言不该还留着旧语言。
+    t: (key, params) => t(locale(), key, params),
+    defaultCwd: process.cwd(),
+    // 提交前的提示词改写：提示词里挑中的 `@专家名` 由它在执行时落成召唤指令。
+    expandPrompt: (text) => expandSchedulePrompt(text),
+    // 工作区需求：定时任务默认绑到「定时任务」工作区（目录 <默认目录>/tesk），也可自定义目录。
+    ensureWorkspace: (path, title) => ensureWorkspace(path, title),
+    // 先按「开」起来；settings 就绪后立刻按真实偏好对齐（见下面的 inject 回调）。
+    armed: true,
+  });
+  ctx.effect(() => () => scheduleEngine.dispose(), "t-team: schedule jobs");
+  ctx.reflect.provide(SCHEDULE_SERVICE, scheduleEngine);
+
+  /**
+   * 确保一个工作区存在，并返回 { id, title, path }。
+   *
+   * 顺序：目录不存在先 mkdir（宿主的工作区 create **只接受已存在的目录**）→ 交给
+   * workspaceRegistry.create：它内部对同路径工作区是**幂等复用**（createCanonical 第一件事
+   * 就是按 path 查找已有实体），所以重复调用不会造出第二个「定时任务」工作区。
+   *
+   * @param path - 目录绝对路径；空串表示用配置里的 scheduleWorkspaceDir。
+   * @param title - 工作区标题；缺省时：默认工作区用配置里的 scheduleWorkspaceTitle，自定义目录用目录名。
+   */
+  async function ensureWorkspace(path, title) {
+    const registry = ctx.get("workspaceRegistry") ?? ctx.get("workspace");
+    if (registry === undefined || typeof registry.create !== "function") {
+      throw new Error("宿主没有可用的工作区服务（workspaceRegistry.create），无法准备定时任务工作区。");
+    }
+    const raw = typeof path === "string" && path.trim() !== "" ? path.trim() : config.scheduleWorkspaceDir;
+    const custom = typeof path === "string" && path.trim() !== "";
+    const target = resolve(raw);
+    await mkdir(target, { recursive: true });
+    // 自定义目录的工作区标题缺省取目录名：否则几个自定义目录会挤成同名「定时任务」，侧栏里分不出来。
+    const label = title !== undefined && title !== ""
+      ? title
+      : (custom ? basename(target) : config.scheduleWorkspaceTitle);
+    const entity = await registry.create(target, label);
+    return { id: String(entity.id), title: String(entity.title ?? ""), path: String(entity.path ?? target) };
+  }
+
+  /**
+   * 把定时任务提示词里点名的专家落成**明确的召唤指令**（支持同时点名多位）。
+   *
+   * 面板的「T专家」挑选器往提示词开头填的就是 `@专家名`（可以连着填好几位）；而执行时开的是一个
+   * **新会话**：它没有输入框那套引用芯片机制，只看到几个 `@名字`，模型不一定会去请人。所以这里按
+   * 当前名册把名字解析成"已启用专家"，并把提示词改写成 summon_t_expert（1 位）/ summon_t_experts
+   * （多位）指令；解析不出来（名字不在已启用名册里）就**原样提交** —— 不猜，也不改写用户没指定的东西。
+   *
+   * 判据与面板完全一致（中文名 / 英文名 / slug）：面板里填进去的名字，这里必须都认得。
+   *
+   * @param text - 任务里存的提示词原文。
+   * @returns 提交给新会话的文本。
+   */
+  async function expandSchedulePrompt(text) {
+    const raw = String(text ?? "");
+    if (!raw.includes("@")) return raw;
+    const current = await snapshot();
+    const enabled = new Set(current?.enabled ?? []);
+    const currentLocale = locale();
+    /** @type {{ name: string, display: string, slug: string }[]} */
+    const hits = [];
+    for (const expert of current?.experts ?? []) {
+      if (expert?.conflict === true || enabled.has(expert.slug) !== true) continue;
+      const names = [expert.name, expert.nameEn, expert.slug].filter((name) => typeof name === "string" && name !== "");
+      for (const name of names) {
+        if (!raw.includes(`@${name}`)) continue;
+        hits.push({
+          name,
+          display: currentLocale === "en" ? (expert.nameEn || expert.name) : (expert.name || expert.nameEn),
+          slug: expert.slug,
+        });
+      }
+    }
+    if (hits.length === 0) return raw;
+    // 长名先摘：名字互为子串时（「X」与「X 助理」）先处理长的，免得把长的截成短的；同一专家按 slug 去重。
+    hits.sort((a, b) => b.name.length - a.name.length);
+    const picked = [];
+    const seen = new Set();
+    for (const hit of hits) {
+      if (seen.has(hit.slug)) continue;
+      seen.add(hit.slug);
+      picked.push(hit);
+    }
+    let task = raw;
+    for (const hit of picked) task = task.split(`@${hit.name}`).join(" ");
+    task = task.replace(/[ \t]{2,}/gu, " ").trim();
+    if (picked.length === 1) {
+      return t(currentLocale, "schedule.expertInvoke", { name: picked[0].display, task });
+    }
+    const names = picked.map((hit) => hit.display).join(currentLocale === "en" ? ", " : "、");
+    return t(currentLocale, "schedule.expertInvokeMany", { names, task });
+  }
+
+  /**
+   * 把界面偏好里的「显示定时事项按钮」落到调度上。
+   *
+   * 为什么不是纯界面开关：用户口径是**关掉即功能整体停用** —— 只藏按钮却让 cron 继续在后台
+   * 开新会话干活，是最糟的一种"以为关了"。所以关掉就停掉全部定时触发，重开按 stored enabled 重建。
+   * @param prefs - 界面前缀（缺省视为开）。
+   */
+  function applyScheduleArmed(prefs) {
+    const armed = prefs?.showScheduleButton !== false;
+    scheduleEngine.setArmed(armed);
+  }
+
   // ---- 设置段（T专家 自己的命名空间，与其它插件不冲突）----
   // `settings` 是**可选**服务（见文件顶部的 inject 注释）：宿主没挂它时本插件仍要能加载并工作，
   // 所以不在静态 `inject` 里。
@@ -245,7 +387,7 @@ export function apply(ctx, config) {
         return;
       }
       scope = settingsService.register(SETTINGS_NAMESPACE, settingsSchema, {
-        base: { enabled: [] },
+        base: { enabled: [], showTaskBadge: true, showScheduleButton: true },
         applies: "live",
         validate: (value) => {
           const list = value?.enabled;
@@ -254,6 +396,9 @@ export function apply(ctx, config) {
           }
         },
       });
+      // 设置段一就绪就把定时事项开关对齐真实偏好：base 默认是「开」，而用户可能早就关过 ——
+      // 不对齐的话，插件每次启动都会先把已经关掉的功能重新跑起来。
+      applyScheduleArmed(scope?.get?.());
     });
   }
   const enabledSet = () => new Set(
@@ -737,10 +882,56 @@ export function apply(ctx, config) {
     }
   }
 
+  /**
+   * 读界面偏好（任务徽章 + 定时事项按钮）。
+   * 读当前值走 `scope.get()`（register 返回的句柄），与 enabledSet() 同一写法——
+   * 直接调 settingsService.get().value 在本机版本的设置服务上不成立（读到 undefined 抛错）。
+   *
+   * 两个键都**必有**且缺省为 true：设置文件里没有这个键时保持与默认一致，
+   * 客户端于是不必到处兜 undefined（wire schema 也是这么声明的）。
+   */
+  function getUiPrefs() {
+    const current = scope?.get?.();
+    return {
+      showTaskBadge: current?.showTaskBadge !== false,
+      showScheduleButton: current?.showScheduleButton !== false,
+    };
+  }
+
+  /** 只取 patch 里**确实是 boolean** 的键（其余一律忽略：坏值不该被写成"关"）。 */
+  function normalizePrefsPatch(patch) {
+    const source = patch !== null && typeof patch === "object" ? patch : {};
+    return {
+      ...(typeof source.showTaskBadge === "boolean" ? { showTaskBadge: source.showTaskBadge } : {}),
+      ...(typeof source.showScheduleButton === "boolean" ? { showScheduleButton: source.showScheduleButton } : {}),
+    };
+  }
+
+  /**
+   * 写界面偏好（局部更新，不碰 enabled）。
+   *
+   * 写成功后再把「定时事项」那一位落到调度上：面板开关与后台定时器必须是同一个事实，
+   * 否则用户关了开关、cron 还在后台开新会话。
+   */
+  async function setUiPrefs(patch) {
+    const next = { ...getUiPrefs(), ...normalizePrefsPatch(patch) };
+    await settingsService.mutate(
+      SETTINGS_NAMESPACE,
+      [
+        { op: "set", path: ["showTaskBadge"], value: next.showTaskBadge },
+        { op: "set", path: ["showScheduleButton"], value: next.showScheduleButton },
+      ],
+      revision(),
+    );
+    applyScheduleArmed(next);
+    return getUiPrefs();
+  }
+
   const catalogService = {
     snapshot, prompt, setEnabled, root: config.root,
     createExpert, updateExpert, deleteExpert,
     createCategory, updateCategory, deleteCategory,
+    getUiPrefs, setUiPrefs,
   };
   ctx.reflect.provide(CATALOG_SERVICE, catalogService);
 

package/lib/remote-schemas.js

@@ -73,6 +73,23 @@ export const enabledStateSchema = z.object({
   revision: z.number().int().min(0),
 });
 
+/**
+ * 界面偏好（宿主持久化，客户端只读展示 + 写入）。
+ *
+ * 两个键都是 `boolean` 且**必有**：host 侧读取时缺省一律补 true，客户端因此不必到处兜 undefined。
+ * 加新键要同时改 host（lib/index.js 的 settingsSchema 与 getUiPrefs）与客户端消费处。
+ */
+export const uiPrefsSchema = z.object({
+  showTaskBadge: z.boolean(),
+  showScheduleButton: z.boolean(),
+});
+
+/** `setUiPrefs` 的入参：想改哪个传哪个（未传的键保持原值）。 */
+export const uiPrefsPatchSchema = z.object({
+  showTaskBadge: z.boolean().optional(),
+  showScheduleButton: z.boolean().optional(),
+});
+
 export const promptSchema = z.object({ prompt: z.string() });
 
 export const squadMemberSchema = z.object({
@@ -154,3 +171,68 @@ export const squadInputSchema = z.object({
   enabled: z.boolean(),
   members: z.array(z.string()),
 });
+
+// ---------------------------------------------------------------- 定时事项
+// 与 @weibaohui/dsh-tasks 的线格式**刻意不同名**：两个插件可以同时安装，各自的 schema / 服务名 /
+// 数据文件互不相干，谁先加载都不会影响对方。
+
+/** 一次执行尝试：什么时候跑的、开出哪个会话、成败与失败原因。 */
+export const scheduleRunSchema = z.object({
+  at: z.string(),
+  ok: z.boolean(),
+  sessionId: z.string().optional(),
+  error: z.string().optional(),
+});
+
+/** 一条定时事项。 */
+export const scheduleItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  prompt: z.string(),
+  cron: z.string(),
+  enabled: z.boolean(),
+  workspaceId: z.string().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  lastRunAt: z.string().optional(),
+  lastRunError: z.string().optional(),
+  runs: z.array(scheduleRunSchema),
+});
+
+/** 面板一次性拿全的数据：事项 + 开关 + 工作区选项 + 宿主能力探测。 */
+export const scheduleSnapshotSchema = z.object({
+  items: z.array(scheduleItemSchema),
+  /** 定时事项功能是否启用（= 设置页那个开关的当前值）。 */
+  armed: z.boolean(),
+  /** 数据文件绝对路径（面板把它显示在说明里，便于用户备份）。 */
+  file: z.string(),
+  /** 正在执行中的事项 id（面板据此显示「执行中…」）。 */
+  running: z.array(z.string()),
+  capabilities: z.object({ agents: z.boolean(), presets: z.boolean() }),
+  /** 可选工作区（下拉选项）；path 是目录，面板显示给用户看落地位置。 */
+  workspaces: z.array(z.object({ id: z.string(), title: z.string(), path: z.string().optional() })),
+});
+
+/** 新建/编辑表单提交的字段。 */
+export const scheduleInputSchema = z.object({
+  title: z.string().min(1).max(200),
+  prompt: z.string().min(1).max(20000),
+  cron: z.string().min(1).max(120),
+  enabled: z.boolean(),
+  /** 空串 = 不绑定工作区（显式解绑也走这个值）。 */
+  workspaceId: z.string().max(200).optional(),
+});
+
+/** 编辑时的局部更新（未传的键保持原值）。 */
+export const schedulePatchSchema = scheduleInputSchema.partial();
+
+/** `previewSchedule` 的结果：接下来几次触发时间（ISO）。 */
+export const schedulePreviewSchema = z.object({ fires: z.array(z.string()) });
+
+/** `setArmed` 的结果。 */
+export const scheduleArmedSchema = z.object({ armed: z.boolean() });
+
+/** `ensureScheduleWorkspace` 的返回：定时任务要绑定的工作区（默认「定时任务」工作区或自定义目录）。 */
+export const scheduleWorkspaceSchema = z.object({
+  workspace: z.object({ id: z.string(), title: z.string(), path: z.string() }),
+});

package/lib/remote.js

@@ -7,7 +7,7 @@
  */
 import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { z } from "zod";
-import { CATALOG_SERVICE, SETTINGS_NAMESPACE, SQUAD_SERVICE, TEAM_SERVICE, UNKNOWN_SLUG_ERROR_CODE } from "./index.js";
+import { CATALOG_SERVICE, SCHEDULE_SERVICE, SETTINGS_NAMESPACE, SQUAD_SERVICE, TEAM_SERVICE, UNKNOWN_SLUG_ERROR_CODE } from "./index.js";
 
 /**
  * 领域码形态：`<domain>/<reason>`（如 `tTeam/squads-invalid`）。
@@ -29,6 +29,11 @@ import {
   expertSchema,
   promptSchema,
   rosterExpertSchema,
+  scheduleInputSchema,
+  schedulePatchSchema,
+  schedulePreviewSchema,
+  scheduleWorkspaceSchema,
+  scheduleSnapshotSchema,
   squadInputSchema,
   squadMemberSchema,
   squadSchema,
@@ -38,6 +43,8 @@ import {
   teamMemberSchema,
   teamSchema,
   teamsSnapshotSchema,
+  uiPrefsPatchSchema,
+  uiPrefsSchema,
 } from "./remote-schemas.js";
 
 
@@ -56,6 +63,73 @@ function descriptor(method, parameters, typeSymbol, schema) {
 
 const DESCRIPTORS = [
   descriptor("getCatalog", [], "TTeamCatalog", catalogSnapshotSchema),
+  descriptor("getUiPrefs", [], "TTeamUiPrefs", uiPrefsSchema),
+  // 入参从「单个 boolean」改成 patch 对象：界面偏好不再只有任务徽章一项，
+  // 加键不必再加方法（未传的键保持原值，host 侧做兜底）。
+  descriptor("setUiPrefs", [
+    {
+      name: "patch",
+      wire: "patch",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "TTeamUiPrefsPatch", schema: uiPrefsPatchSchema },
+    },
+  ], "TTeamUiPrefs", uiPrefsSchema),
+  // 定时事项：全部写操作都回传刷新后的整份快照，面板拿到就能直接重绘（与名册/小队同一口径）。
+  descriptor("getSchedule", [], "TTeamSchedule", scheduleSnapshotSchema),
+  descriptor("createScheduleItem", [
+    {
+      name: "input",
+      wire: "input",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "TTeamScheduleInput", schema: scheduleInputSchema },
+    },
+  ], "TTeamSchedule", scheduleSnapshotSchema),
+  descriptor("updateScheduleItem", [
+    {
+      name: "id",
+      wire: "id",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128) },
+    },
+    {
+      name: "patch",
+      wire: "patch",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "TTeamSchedulePatch", schema: schedulePatchSchema },
+    },
+  ], "TTeamSchedule", scheduleSnapshotSchema),
+  descriptor("deleteScheduleItem", [
+    {
+      name: "id",
+      wire: "id",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128) },
+    },
+  ], "TTeamSchedule", scheduleSnapshotSchema),
+  descriptor("runScheduleItem", [
+    {
+      name: "id",
+      wire: "id",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128) },
+    },
+  ], "TTeamSchedule", scheduleSnapshotSchema),
+  descriptor("previewSchedule", [
+    {
+      name: "cron",
+      wire: "cron",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(120) },
+    },
+  ], "TTeamSchedulePreview", schedulePreviewSchema),
+  descriptor("ensureScheduleWorkspace", [
+    {
+      name: "path",
+      wire: "path",
+      source: "json",
+      codec: { mode: "strict", typeSymbol: "string", schema: z.string().max(1024) },
+    },
+  ], "TTeamScheduleWorkspace", scheduleWorkspaceSchema),
   descriptor("setEnabled", [
     {
       name: "enabled",
@@ -287,6 +361,111 @@ class TTeamRemote extends TypertRemoteService {
   }
 
   /** 整体替换启用列表；过期修订号由 settings 服务拒绝。 */
+  async getUiPrefs() {
+    try {
+      return await this.catalog().getUiPrefs();
+    } catch (error) {
+      throw this.businessError(error, "tTeam/ui-prefs-unreadable");
+    }
+  }
+
+  async setUiPrefs(patch) {
+    try {
+      return await this.catalog().setUiPrefs(patch);
+    } catch (error) {
+      throw this.businessError(error, "tTeam/ui-prefs-unwritable");
+    }
+  }
+
+  /**
+   * 定时事项服务（T专家 自己的引擎，与 @weibaohui/dsh-tasks 完全独立）。
+   *
+   * 与 `teams()` 同理：缺服务时给的是**功能语境的**错误码（`tTeam/schedule-unavailable`
+   * 读起来就是「定时事项用不了」），而不是笼统的 host-unavailable。
+   */
+  schedule() {
+    const service = this.ctx.get(SCHEDULE_SERVICE);
+    if (service === undefined) {
+// @ts-expect-error 上游类型缺口：同上，tTeam/* 业务码不在闭合的 RemoteErrorDetailsMap 里。
+      throw new RemoteError("tTeam/schedule-unavailable", "T专家 定时事项服务不可用（host 插件未加载或已卸载）", { service: SCHEDULE_SERVICE });
+    }
+    return service;
+  }
+
+  /** 定时事项快照：事项列表 + 开关状态 + 工作区选项 + 宿主能力探测。 */
+  async getSchedule() {
+    try {
+      return this.schedule().snapshot();
+    } catch (error) {
+      throw this.businessError(error, "tTeam/schedule-unreadable");
+    }
+  }
+
+  /** 新建一条定时事项。 */
+  async createScheduleItem(input) {
+    try {
+      const service = this.schedule();
+      await service.create(input);
+      return service.snapshot();
+    } catch (error) {
+      throw this.businessError(error, "tTeam/schedule-invalid");
+    }
+  }
+
+  /** 改一条定时事项（局部更新）。 */
+  async updateScheduleItem(id, patch) {
+    try {
+      const service = this.schedule();
+      await service.update(id, patch);
+      return service.snapshot();
+    } catch (error) {
+      throw this.businessError(error, "tTeam/schedule-invalid");
+    }
+  }
+
+  /** 删一条定时事项。 */
+  async deleteScheduleItem(id) {
+    try {
+      const service = this.schedule();
+      await service.remove(id);
+      return service.snapshot();
+    } catch (error) {
+      throw this.businessError(error, "tTeam/schedule-invalid");
+    }
+  }
+
+  /** 立即执行一条定时事项（等价于等它到点）。 */
+  async runScheduleItem(id) {
+    try {
+      const service = this.schedule();
+      await service.runNow(id);
+      return service.snapshot();
+    } catch (error) {
+      throw this.businessError(error, "tTeam/schedule-run-failed");
+    }
+  }
+
+  /**
+   * 确保定时任务要绑定的工作区存在：空 path = 配置里的默认「定时任务」工作区（目录 <默认目录>/tesk）；
+   * 给了 path = 面板里填的自定义目录（不存在会建出来）。宿主的工作区 create 对同路径是幂等复用。
+   */
+  async ensureScheduleWorkspace(path) {
+    try {
+      return { workspace: await this.schedule().ensureWorkspace(String(path ?? ""), undefined) };
+    } catch (error) {
+      throw this.businessError(error, "tTeam/schedule-workspace-failed");
+    }
+  }
+
+  /** 预览某个 cron 表达式接下来的 5 次触发时间（宿主用 croner 算，客户端不打包 cron 解析器）。 */
+  async previewSchedule(cron) {
+    try {
+      return this.schedule().preview(cron);
+    } catch (error) {
+      throw this.businessError(error, "tTeam/schedule-invalid");
+    }
+  }
+
   async setEnabled(enabled, expectedRevision) {
     try {
       return await this.catalog().setEnabled(enabled, expectedRevision);
@@ -480,6 +659,8 @@ class TTeamRemote extends TypertRemoteService {
 
 exposeRemoteMethods(TTeamRemote, [
   "getCatalog", "setEnabled", "getPrompt", "getSquads", "saveSquads", "getTeams", "stopTeam", "startSquad",
+  "getUiPrefs", "setUiPrefs",
+  "getSchedule", "createScheduleItem", "updateScheduleItem", "deleteScheduleItem", "runScheduleItem", "previewSchedule", "ensureScheduleWorkspace",
   "createExpert", "updateExpert", "deleteExpert",
   "createCategory", "updateCategory", "deleteCategory",
 ]);