dsh-plugin-t-expert 0.3.89 → 0.3.91

package/lib/i18n.js

@@ -48,19 +48,6 @@ 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.disabled": "定时任务功能当前已关闭：请在 设置 → T专家 里重新打开「显示定时任务按钮」",
 };
 
 const EN = {
@@ -108,19 +95,6 @@ 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.disabled": "Scheduled tasks are currently turned off: re-enable \"Show scheduled tasks button\" in Settings → T Expert",
 };
 
 /** 取文案并按 {name} 占位替换。 */

package/lib/index.js

@@ -42,9 +42,7 @@ import { localized, NS, readLocale, renderList, renderSummonResults, t, toRender
 import { seedData } from "./bootstrap.js";
 import { installBundledSkills } from "./skill.js";
 import { SNAPSHOT_DIR } from "./bootstrap.js";
-// 定时事项引擎：T专家 自己的实现（JSON 文件 + croner），与 @weibaohui/dsh-tasks 零共享 ——
 // 两个插件允许同时安装同时可用，所以存储、服务名、错误码、消息来源全都各走各的。
-import { SCHEDULE_FILE_NAME, SCHEDULE_SERVICE, createScheduleEngine } from "./schedule.js";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 
 export const name = NS;
@@ -114,16 +112,6 @@ export const Config = schema.object({
   summonTaskMaxChars: schema.natural().min(1).default(8000),
   /** list_t_experts 里简介的截断长度。 */
   descriptionLimit: schema.natural().min(1).default(120),
-  /**
-   * 定时任务默认绑定的工作区（首次使用时自动建/复用）。
-   *
-   * 为什么要有它：定时任务跑出来的会话如果"不绑定工作区"，在侧栏里就没有归属，
-   * 一堆自动会话会散在工作区列表外面；给它们一个固定去处（默认「定时任务」工作区、
-   * 目录 <默认目录>/tesk）最好找。目录不存在会被建出来 —— 宿主的工作区 create
-   * 只接受已存在的目录。
-   */
-  scheduleWorkspaceTitle: schema.string().default("定时任务"),
-  scheduleWorkspaceDir: schema.string().default(join(homedir(), "tesk")),
 
   /**
    * 以下五个是**用户偏好**（专家启停 + 界面开关），不是部署配置。
@@ -143,7 +131,6 @@ export const Config = schema.object({
   /** 「默认全部启用」已按哪一版策略播种过；+1 即对所有用户重新播种一次。 */
   enabledSeedVersion: volatileField(schema.number().default(0)),
   /** 是否显示侧栏「定时事项」按钮（关掉 = 定时功能整体停用）。 */
-  showScheduleButton: volatileField(schema.boolean().default(true)),
   /** 是否显示窗口右上角的「活跃指示」。 */
   showActivePulse: volatileField(schema.boolean().default(true)),
 });
@@ -151,12 +138,6 @@ export const Config = schema.object({
 /** 供 remote 服务读取名册的服务名。 */
 export const CATALOG_SERVICE = "tTeamCatalog";
 /**
- * 定时事项服务（remote 侧与服务访问器共用）。
- *
- * 定义在 `lib/schedule.js`（引擎与常量同处一地），这里**再导出**一次：`lib/remote.js` 与本文件
- * 都从同一处取常量，避免出现两个字面量各写一遍、改名时漏改一处的经典漂移。
- */
-export { SCHEDULE_SERVICE };
 /** 设置命名空间（= 插件名）。 */
 export const SETTINGS_NAMESPACE = NS;
 
@@ -189,9 +170,8 @@ const settingsSchema = schema.object({
    * 是否显示侧栏「定时事项」按钮（界面偏好）。
    *
    * 语义（用户口径）：**关掉 = 定时事项功能整体停用** —— 不只是藏按钮，还要停掉全部定时触发
-   * （见 apply 里的 applyScheduleArmed）。任务与执行记录完整保留，重新打开即恢复调度。
+   * 任务数据完整保留，重新打开即恢复调度。
    */
-  showScheduleButton: schema.boolean().default(true),
   /**
    * 是否显示窗口右上角的「活跃指示」（心电图图标，界面偏好）。
    *
@@ -283,98 +263,8 @@ export function apply(ctx, config) {
     ctx.logger?.error?.(`[t-team] 名册快照同步失败，将按已有数据继续：${seeded.error}`);
   }
 
-  // ---- 定时事项引擎（T专家 自己的数据文件 + croner 调度）----
-  // 数据落在**本插件自己的数据根**里（`~/.t-team/schedule.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(),
-    // 提示词**原样提交**，不做任何改写：定时任务开的新会话与手动开的会话挂同一份
-    // system prompt（那节只在子会话里返回空串），里面已经写着「看到 `@专家名` 就
-    // summon_t_expert FIRST」。以前这里会把 `@名字` 翻译成一段"请用 summon_t_expert
-    // 召唤专家「…」"的指令，导致同一个任务在定时任务里显示成一长段模板、在手动对话里
-    // 却只是 `@名字` —— 两条入口观感不一致（用户实测反馈）。现在统一按原文提交。
-    // 工作区需求：定时任务默认绑到「定时任务」工作区（目录 <默认目录>/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);
 
-  /**
-   * 确保一个工作区存在，并返回工作区实体。
-   *
-   * 顺序：目录不存在先 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 custom = typeof path === "string" && path.trim() !== "";
-    // 默认工作区（调用方没指定目录）：已经有同名工作区就直接复用，不再按默认目录另起一个。
-    if (!custom) {
-      const existing = findWorkspaceByTitle(registry, config.scheduleWorkspaceTitle);
-      if (existing !== undefined) return existing;
-    }
-    const raw = custom ? path.trim() : config.scheduleWorkspaceDir;
-    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);
-    // 把 entity 透出去：执行路径要调 entity.attachSession 把新建的 session 挂回工作区 sessionIds
-    // （侧栏的"工作区 → 会话"分组就是从这条列表里取的；不挂上用户感知是"任务跑了但侧栏没新会话"）。
-    return entity;
-  }
 
-  /**
-   * 在宿主的工作区注册表里按标题找第一个工作区（找不到 / 宿主没提供 list 就返回 undefined）。
-   *
-   * 用于「默认工作区只有一个」这条保证：同名工作区已经存在时复用它，而不是按当前默认目录
-   * 再建一个。`WorkspaceEntity` 自带 id / path / title / attachSession，正是执行路径需要的形状。
-   *
-   * @param registry - 宿主的 workspaceRegistry。
-   * @param title - 要匹配的工作区标题。
-   */
-  function findWorkspaceByTitle(registry, title) {
-    if (typeof registry?.list !== "function") return undefined;
-    try {
-      return registry.list().find((entity) => entity?.title === title);
-    } catch {
-      // list 不可用（宿主版本差异）不致命：退回"按路径 create"，最多是没享受到复用。
-      return undefined;
-    }
-  }
-
-  /**
-   * 把界面偏好里的「显示定时事项按钮」落到调度上。
-   *
-   * 为什么不是纯界面开关：用户口径是**关掉即功能整体停用** —— 只藏按钮却让 cron 继续在后台
-   * 开新会话干活，是最糟的一种"以为关了"。所以关掉就停掉全部定时触发，重开按 stored enabled 重建。
-   * @param prefs - 界面前缀（缺省视为开）。
-   */
-  function applyScheduleArmed(prefs) {
-    const armed = prefs?.showScheduleButton !== false;
-    scheduleEngine.setArmed(armed);
-  }
 
   // ---- 设置段（T专家 自己的命名空间，与其它插件不冲突）----
   // `settings` 是**可选**服务（见文件顶部的 inject 注释）：宿主没挂它时本插件仍要能加载并工作，
@@ -413,7 +303,7 @@ export function apply(ctx, config) {
       if (typeof settingsService?.register === "function") {
         // ── 旧宿主（≤0.1.6）：按命名空间注册，读写都走返回的句柄。
         scope = settingsService.register(SETTINGS_NAMESPACE, settingsSchema, {
-          base: { enabled: [], enabledSeeded: false, enabledSeedVersion: 0, showScheduleButton: true, showActivePulse: true },
+          base: { enabled: [], enabledSeeded: false, enabledSeedVersion: 0, showActivePulse: true },
           applies: "live",
           validate: (value) => {
             const list = value?.enabled;
@@ -423,9 +313,6 @@ export function apply(ctx, config) {
           },
         });
         prefsMode = "scope";
-        // 设置段一就绪就把定时事项开关对齐真实偏好：base 默认是「开」，而用户可能早就关过 ——
-        // 不对齐的话，插件每次启动都会先把已经关掉的功能重新跑起来。
-        applyScheduleArmed(scope?.get?.());
         return;
       }
       if (typeof settingsService?.mutate === "function") {
@@ -443,11 +330,7 @@ export function apply(ctx, config) {
           );
         }
         if (typeof ctx.on === "function") {
-          // volatile 字段的变更不会重挂插件，只发这个事件。定时开关必须跟着走：
-          // 否则用户在面板里关掉「定时事项」后，后台定时器还在开新会话。
-          ctx.on("loader/volatile-update", () => { applyScheduleArmed(readPrefs()); });
         }
-        applyScheduleArmed(readPrefs());
         return;
       }
       ctx.logger?.warn?.("[t-team] settings 服务既没有 register 也没有 mutate：专家启停不可用（名册与召唤不受影响）。");
@@ -468,7 +351,6 @@ export function apply(ctx, config) {
         enabled: unwrapVolatile(source.enabled),
         enabledSeeded: unwrapVolatile(source.enabledSeeded),
         enabledSeedVersion: unwrapVolatile(source.enabledSeedVersion),
-        showScheduleButton: unwrapVolatile(source.showScheduleButton),
         showActivePulse: unwrapVolatile(source.showActivePulse),
       };
     }
@@ -1002,7 +884,6 @@ export function apply(ctx, config) {
   function getUiPrefs() {
     const current = readPrefs();
     return {
-      showScheduleButton: current?.showScheduleButton !== false,
       showActivePulse: current?.showActivePulse !== false,
     };
   }
@@ -1011,7 +892,6 @@ export function apply(ctx, config) {
   function normalizePrefsPatch(patch) {
     const source = patch !== null && typeof patch === "object" ? patch : {};
     return {
-      ...(typeof source.showScheduleButton === "boolean" ? { showScheduleButton: source.showScheduleButton } : {}),
       ...(typeof source.showActivePulse === "boolean" ? { showActivePulse: source.showActivePulse } : {}),
     };
   }
@@ -1027,12 +907,10 @@ export function apply(ctx, config) {
     await settingsService.mutate(
       SETTINGS_NAMESPACE,
       [
-        { op: "set", path: ["showScheduleButton"], value: next.showScheduleButton },
         { op: "set", path: ["showActivePulse"], value: next.showActivePulse },
       ],
       revision(),
     );
-    applyScheduleArmed(next);
     return getUiPrefs();
   }
 
@@ -1215,7 +1093,7 @@ export function apply(ctx, config) {
 
   ctx.tools.register(defineTool({
     name: "summon_t_experts",
-    description: `Summon multiple T专家 experts in parallel for one mission. At most ${config.maxSummonBatch} experts run with concurrency ${config.summonConcurrency}; successful answers are returned even when some fail. Each expert is usually pre-named by the caller (a composer @ chip, or an explicit @专家名 anywhere in the text — including a scheduled task's stored prompt) — when so, summon directly without list_t_experts; only call list_t_experts when no expert is named.`,
+    description: `Summon multiple T专家 experts in parallel for one mission. At most ${config.maxSummonBatch} experts run with concurrency ${config.summonConcurrency}; successful answers are returned even when some fail. Each expert is usually pre-named by the caller (a composer @ chip, or an explicit @专家名 anywhere in the text — including a stored prompt from elsewhere) — when so, summon directly without list_t_experts; only call list_t_experts when no expert is named.`,
     // 预算声明：批量最坏是 ceil(批大小 / 并发) 轮串行，给 20 分钟。
     // 与单次召唤同理，它只是声明，强制 deadline 需要宿主装配 timeout-policy wrapper。
     timeoutMs: 1_200_000,

package/lib/remote-schemas.js

@@ -77,85 +77,13 @@ export const enabledStateSchema = z.object({
  * 加新键要同时改 host（lib/index.js 的 settingsSchema 与 getUiPrefs）与客户端消费处。
  */
 export const uiPrefsSchema = z.object({
-  showScheduleButton: z.boolean(),
   // 窗口右上角「活跃指示」是否显示。宿主**总是**返回布尔（缺省按 true 算），所以这里必填。
   showActivePulse: z.boolean(),
 });
 
 /** `setUiPrefs` 的入参：想改哪个传哪个（未传的键保持原值）。 */
 export const uiPrefsPatchSchema = z.object({
-  showScheduleButton: z.boolean().optional(),
   showActivePulse: z.boolean().optional(),
 });
 
 export const promptSchema = z.object({ prompt: 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(),
-  /** 绑定时记下的工作区目录：工作区被删后凭它「重建」回到原路径。面板也会在编辑表单里显示它。 */
-  workspacePath: 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(),
-  /** 绑定时记下的工作区目录；老数据可缺省，按当前选中的 workspace 自动补。 */
-  workspacePath: z.string().max(1024).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,10 +7,10 @@
  */
 import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { z } from "zod";
-import { CATALOG_SERVICE, SCHEDULE_SERVICE, SETTINGS_NAMESPACE, UNKNOWN_SLUG_ERROR_CODE } from "./index.js";
+import { CATALOG_SERVICE, SETTINGS_NAMESPACE, UNKNOWN_SLUG_ERROR_CODE } from "./index.js";
 
 /**
- * 领域码形态：`<domain>/<reason>`（如 `tTeam/schedule-invalid`）。
+ * 领域码形态：`<domain>/<reason>`（如 `tTeam/unknown-expert`）。
  *
  * 只有通过它校验的 `error.code` 才允许当 wire code 透传 —— 系统 errno（`EACCES`…）不是领域码，
  * 透传出去会让客户端按 code 分支时把「文件权限」误认成业务失败类型（D-17）。口径与宿主网关一致
@@ -28,11 +28,6 @@ import {
   enabledStateSchema,
   expertSchema,
   promptSchema,
-  scheduleInputSchema,
-  schedulePatchSchema,
-  schedulePreviewSchema,
-  scheduleWorkspaceSchema,
-  scheduleSnapshotSchema,
   uiPrefsPatchSchema,
   uiPrefsSchema,
 } from "./remote-schemas.js";
@@ -64,62 +59,6 @@ const DESCRIPTORS = [
       codec: { mode: "strict", typeSymbol: "TTeamUiPrefsPatch", schema: uiPrefsPatchSchema, create: () => uiPrefsPatchSchema },
     },
   ], "TTeamUiPrefs", uiPrefsSchema),
-  // 定时事项：全部写操作都回传刷新后的整份快照，面板拿到就能直接重绘（与名册同一口径）。
-  descriptor("getSchedule", [], "TTeamSchedule", scheduleSnapshotSchema),
-  descriptor("createScheduleItem", [
-    {
-      name: "input",
-      wire: "input",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "TTeamScheduleInput", schema: scheduleInputSchema, create: () => scheduleInputSchema },
-    },
-  ], "TTeamSchedule", scheduleSnapshotSchema),
-  descriptor("updateScheduleItem", [
-    {
-      name: "id",
-      wire: "id",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128), create: () => z.string().min(1).max(128) },
-    },
-    {
-      name: "patch",
-      wire: "patch",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "TTeamSchedulePatch", schema: schedulePatchSchema, create: () => schedulePatchSchema },
-    },
-  ], "TTeamSchedule", scheduleSnapshotSchema),
-  descriptor("deleteScheduleItem", [
-    {
-      name: "id",
-      wire: "id",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128), create: () => 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), create: () => 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), create: () => 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), create: () => z.string().max(1024) },
-    },
-  ], "TTeamScheduleWorkspace", scheduleWorkspaceSchema),
   descriptor("setEnabled", [
     {
       name: "enabled",
@@ -322,94 +261,13 @@ class TTeamRemote extends TypertRemoteService {
     }
   }
 
-  /**
-   * 定时事项服务（T专家 自己的引擎，与 @weibaohui/dsh-tasks 完全独立）。
-   *
-   * 与 `catalog()` 同理：缺服务时给的是**功能语境的**错误码（`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 {
@@ -532,7 +390,6 @@ class TTeamRemote extends TypertRemoteService {
 exposeRemoteMethods(TTeamRemote, [
   "getCatalog", "setEnabled", "getPrompt",
   "getUiPrefs", "setUiPrefs",
-  "getSchedule", "createScheduleItem", "updateScheduleItem", "deleteScheduleItem", "runScheduleItem", "previewSchedule", "ensureScheduleWorkspace",
   "createExpert", "updateExpert", "deleteExpert",
   "createCategory", "updateCategory", "deleteCategory",
 ]);