dsh-plugin-t-expert 0.3.88 → 0.3.89

package/lib/remote-schemas.js

@@ -3,14 +3,11 @@
  * Remote 线格式的**单一 schema 源**（A-2 / A-3）。
  *
  * 为什么要有这个文件：这些 schema 过去在 host（`lib/remote.js`）与客户端（`src/client/`）
- * 各写了一份，**13 个同名定义逐字重复**。加一个 remote 方法或改一个字段要改两处，漏改一处
+ * 各写了一份。加一个 remote 方法或改一个字段要改两处，漏改一处
  * 不会在加载期报错，只会在调用期炸（或更糟：静默把字段剥掉）。
  *
  * 权威在 **host**：它同时是生产方与校验方（`lib/remote.js` 的 DESCRIPTORS 用的就是这些对象），
  * 客户端只是消费方。所以统一后 host 的校验强度不变，客户端变严——方向是安全的。
- * 统一过程中修正了两处真实不一致：
- *   1. `squadInputSchema.key` 客户端原来没有 `min(1).max(64)`；
- *   2. 客户端原来把团队快照叫 `catalogSchema`、把 `teamMemberSchema` 内联写了一遍。
  *
  * ⚠️ 本文件只放**纯 schema**，不放 host 专属的 `descriptor()` 或客户端专属的 `direct()` 信封
  * —— 两端信封的字段（`id` 前缀、`result` 形状）本来就不同，强行合并反而更脆。
@@ -80,7 +77,6 @@ export const enabledStateSchema = z.object({
  * 加新键要同时改 host（lib/index.js 的 settingsSchema 与 getUiPrefs）与客户端消费处。
  */
 export const uiPrefsSchema = z.object({
-  showTaskBadge: z.boolean(),
   showScheduleButton: z.boolean(),
   // 窗口右上角「活跃指示」是否显示。宿主**总是**返回布尔（缺省按 true 算），所以这里必填。
   showActivePulse: z.boolean(),
@@ -88,111 +84,12 @@ export const uiPrefsSchema = z.object({
 
 /** `setUiPrefs` 的入参：想改哪个传哪个（未传的键保持原值）。 */
 export const uiPrefsPatchSchema = z.object({
-  showTaskBadge: z.boolean().optional(),
   showScheduleButton: z.boolean().optional(),
   showActivePulse: z.boolean().optional(),
 });
 
 export const promptSchema = z.object({ prompt: z.string() });
 
-export const squadMemberSchema = z.object({
-  slug: z.string(),
-  role: z.string(),
-  name: z.string(),
-  nameZh: z.string(),
-  division: z.string(),
-  divisionZh: z.string(),
-  known: z.boolean(),
-});
-
-export const squadSchema = z.object({
-  key: z.string(),
-  description: z.string(),
-  aliases: z.array(z.string()),
-  taskPlanning: z.enum(["captain", "seed"]),
-  enabled: z.boolean(),
-  members: z.array(squadMemberSchema),
-});
-
-export const rosterExpertSchema = z.object({
-  slug: z.string(),
-  name: z.string(),
-  nameZh: z.string(),
-  division: z.string(),
-  divisionZh: z.string(),
-  enabled: z.boolean(),
-  conflict: z.boolean(),
-});
-
-export const squadsSnapshotSchema = z.object({
-  revision: z.string(),
-  squads: z.array(squadSchema),
-  experts: z.array(rosterExpertSchema),
-  lastBuild: z.object({ at: z.number(), ok: z.boolean(), output: z.string() }),
-});
-
-export const teamMemberSchema = z.object({
-  name: z.string(),
-  role: z.string(),
-  status: z.string(),
-  activity: z.string(),
-  done: z.number(),
-  total: z.number(),
-});
-
-export const teamSchema = z.object({
-  teamId: z.string(),
-  name: z.string(),
-  workspace: z.string(),
-  // 2026-09-15：teamId 是团队名 slug 化的结果，**跨工作区会重名**，客户端把 workspacePath
-  // 回传给 stop/deleteTeam 才能精确定位（strict schema 不声明就会被剥掉）。
-  // 两个字段都 `.optional()` 是**兼容闸门**：客户端产物热重载，host 可能是旧的（不返回它们）——
-  // 那时必需字段会让 `teamsSnapshotSchema.parse` 直接失败、列表**整片空白**。可选之后退化为
-  // 「按 halted 判定按钮 + 按 teamId 全量遍历」的旧行为，而不是白屏。
-  workspacePath: z.string().optional(),
-  /** 队长会话此刻是否在运行：客户端据此决定按钮叫「停止」还是「归档」。 */
-  captainActive: z.boolean().optional(),
-  captainSessionId: z.string(),
-  phase: z.string(),
-  halted: z.boolean(),
-  members: z.array(teamMemberSchema),
-  tasks: z.array(z.object({ id: z.string(), subject: z.string(), status: z.string(), assignee: z.string() })),
-});
-
-export const teamsSnapshotSchema = z.object({ teams: z.array(teamSchema) });
-
-export const startResultSchema = z.object({
-  profile: z.string(),
-  label: z.string(),
-  members: z.number(),
-});
-
-export const stopResultSchema = z.object({
-  teamName: z.string(),
-  cancelledTasks: z.number(),
-  alreadyHalted: z.boolean(),
-  // 2026-09-15 起，「停止」在队长会话已结束（或团队早已 halted）时改为**归档**：
-  // 这个字段让面板知道该报「已停止」还是「已归档」。
-  archived: z.boolean(),
-});
-
-/** 「删除团队」的结果：与「停止/归档」不同，这是不可逆的清理。 */
-export const deleteTeamResultSchema = z.object({
-  teamName: z.string(),
-  deleted: z.boolean(),
-  // 删掉的是归档里那份（而不是还挂在「运行中」的那份）
-  wasArchived: z.boolean(),
-});
-
-/** 面板提交的小队定义（saveSquads 的入参）。 */
-export const squadInputSchema = z.object({
-  key: z.string().min(1).max(64),
-  description: z.string(),
-  aliases: z.array(z.string()),
-  taskPlanning: z.enum(["captain", "seed"]),
-  enabled: z.boolean(),
-  members: z.array(z.string()),
-});
 
 // ---------------------------------------------------------------- 定时事项
 // 与 @weibaohui/dsh-tasks 的线格式**刻意不同名**：两个插件可以同时安装，各自的 schema / 服务名 /
@@ -214,6 +111,8 @@ export const scheduleItemSchema = z.object({
   cron: z.string(),
   enabled: z.boolean(),
   workspaceId: z.string().optional(),
+  /** 绑定时记下的工作区目录：工作区被删后凭它「重建」回到原路径。面板也会在编辑表单里显示它。 */
+  workspacePath: z.string().optional(),
   createdAt: z.string(),
   updatedAt: z.string(),
   lastRunAt: z.string().optional(),
@@ -243,6 +142,8 @@ export const scheduleInputSchema = z.object({
   enabled: z.boolean(),
   /** 空串 = 不绑定工作区（显式解绑也走这个值）。 */
   workspaceId: z.string().max(200).optional(),
+  /** 绑定时记下的工作区目录；老数据可缺省，按当前选中的 workspace 自动补。 */
+  workspacePath: z.string().max(1024).optional(),
 });
 
 /** 编辑时的局部更新（未传的键保持原值）。 */

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, SQUAD_SERVICE, TEAM_SERVICE, UNKNOWN_SLUG_ERROR_CODE } from "./index.js";
+import { CATALOG_SERVICE, SCHEDULE_SERVICE, SETTINGS_NAMESPACE, UNKNOWN_SLUG_ERROR_CODE } from "./index.js";
 
 /**
- * 领域码形态：`<domain>/<reason>`（如 `tTeam/squads-invalid`）。
+ * 领域码形态：`<domain>/<reason>`（如 `tTeam/schedule-invalid`）。
  *
  * 只有通过它校验的 `error.code` 才允许当 wire code 透传 —— 系统 errno（`EACCES`…）不是领域码，
  * 透传出去会让客户端按 code 分支时把「文件权限」误认成业务失败类型（D-17）。口径与宿主网关一致
@@ -28,22 +28,11 @@ import {
   enabledStateSchema,
   expertSchema,
   promptSchema,
-  rosterExpertSchema,
   scheduleInputSchema,
   schedulePatchSchema,
   schedulePreviewSchema,
   scheduleWorkspaceSchema,
   scheduleSnapshotSchema,
-  squadInputSchema,
-  squadMemberSchema,
-  squadSchema,
-  squadsSnapshotSchema,
-  startResultSchema,
-  stopResultSchema,
-  deleteTeamResultSchema,
-  teamMemberSchema,
-  teamSchema,
-  teamsSnapshotSchema,
   uiPrefsPatchSchema,
   uiPrefsSchema,
 } from "./remote-schemas.js";
@@ -65,7 +54,7 @@ function descriptor(method, parameters, typeSymbol, schema) {
 const DESCRIPTORS = [
   descriptor("getCatalog", [], "TTeamCatalog", catalogSnapshotSchema),
   descriptor("getUiPrefs", [], "TTeamUiPrefs", uiPrefsSchema),
-  // 入参从「单个 boolean」改成 patch 对象：界面偏好不再只有任务徽章一项，
+  // 入参从「单个 boolean」改成 patch 对象：界面偏好不止一项，
   // 加键不必再加方法（未传的键保持原值，host 侧做兜底）。
   descriptor("setUiPrefs", [
     {
@@ -75,7 +64,7 @@ const DESCRIPTORS = [
       codec: { mode: "strict", typeSymbol: "TTeamUiPrefsPatch", schema: uiPrefsPatchSchema, create: () => uiPrefsPatchSchema },
     },
   ], "TTeamUiPrefs", uiPrefsSchema),
-  // 定时事项：全部写操作都回传刷新后的整份快照，面板拿到就能直接重绘（与名册/小队同一口径）。
+  // 定时事项：全部写操作都回传刷新后的整份快照，面板拿到就能直接重绘（与名册同一口径）。
   descriptor("getSchedule", [], "TTeamSchedule", scheduleSnapshotSchema),
   descriptor("createScheduleItem", [
     {
@@ -159,80 +148,6 @@ const DESCRIPTORS = [
       codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(64), create: () => z.string().min(1).max(64) },
     },
   ], "TTeamPrompt", promptSchema),
-  descriptor("getSquads", [], "TTeamSquads", squadsSnapshotSchema),
-  descriptor("saveSquads", [
-    {
-      name: "squads",
-      wire: "squads",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "TTeamSquadInput[]", schema: z.array(squadInputSchema).min(1).max(48), create: () => z.array(squadInputSchema).min(1).max(48) },
-    },
-    {
-      name: "expectedRevision",
-      wire: "expectedRevision",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().max(64), create: () => z.string().max(64) },
-    },
-  ], "TTeamSquads", squadsSnapshotSchema),
-  descriptor("startSquad", [
-    {
-      name: "profileKey",
-      wire: "profileKey",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(64), create: () => z.string().min(1).max(64) },
-    },
-    {
-      name: "sessionId",
-      wire: "sessionId",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().max(128), create: () => z.string().max(128) },
-    },
-  ], "TTeamStartResult", startResultSchema),
-  descriptor("getTeams", [
-    {
-      name: "archived",
-      wire: "archived",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "boolean", schema: z.boolean(), create: () => z.boolean() },
-    },
-  ], "TTeamTeams", teamsSnapshotSchema),
-  // teamId 是**团队名 slug 化**的产物，跨工作区会重名；workspacePath 让宿主精确定位到
-  // 「用户点的那一行」所在的工作区。
-  // `acceptsUndefined: true` 是**兼容闸门**：DSH 的客户端产物是热重载的，host 更新后浏览器
-  // 可能还挂着上一版 client bundle —— 那时它只会传 teamId。没有这个标记，gateway 会直接
-  // 判 `arguments-invalid: missing "workspacePath"`，用户点「停止/删除」立刻炸；
-  // 标上之后旧客户端照旧能调，宿主退回「全量遍历」的旧行为。
-  descriptor("stopTeam", [
-    {
-      name: "teamId",
-      wire: "teamId",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128), create: () => z.string().min(1).max(128) },
-    },
-    {
-      name: "workspacePath",
-      wire: "workspacePath",
-      source: "json",
-      acceptsUndefined: true,
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().max(1024), create: () => z.string().max(1024) },
-    },
-  ], "TTeamStopResult", stopResultSchema),
-  // 彻底删除一支团队（运行中的与已归档的都收）：设置页「运行中的团队」那一行的「删除」按钮。
-  descriptor("deleteTeam", [
-    {
-      name: "teamId",
-      wire: "teamId",
-      source: "json",
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().min(1).max(128), create: () => z.string().min(1).max(128) },
-    },
-    {
-      name: "workspacePath",
-      wire: "workspacePath",
-      source: "json",
-      acceptsUndefined: true,
-      codec: { mode: "strict", typeSymbol: "string", schema: z.string().max(1024), create: () => z.string().max(1024) },
-    },
-  ], "TTeamDeleteResult", deleteTeamResultSchema),
   // 自建专家的增删改：都回传刷新后的整份名册快照，面板拿到就能直接重绘。
   descriptor("createExpert", [
     {
@@ -358,7 +273,7 @@ class TTeamRemote extends TypertRemoteService {
   /**
    * host 侧服务缺失的统一领域错误。
    *
-   * 三个访问器（catalog / squads / teams）共用它：**不要**裸抛 `Error` —— 裸 Error 过线会被
+   * 一个访问器（catalog）共用它：**不要**裸抛 `Error` —— 裸 Error 过线会被
    * 网关折成 `gateway/internal`，领域信息全丢；也**不要**把「host 没加载」塞进别的领域码
    * （例如 `tTeam/missing-expert`），那会把「服务不可用」显示成「专家不存在」（D-4）。
    * @param name - 服务名（写进 details，便于面板区分是哪一个）。
@@ -410,7 +325,7 @@ class TTeamRemote extends TypertRemoteService {
   /**
    * 定时事项服务（T专家 自己的引擎，与 @weibaohui/dsh-tasks 完全独立）。
    *
-   * 与 `teams()` 同理：缺服务时给的是**功能语境的**错误码（`tTeam/schedule-unavailable`
+   * 与 `catalog()` 同理：缺服务时给的是**功能语境的**错误码（`tTeam/schedule-unavailable`
    * 读起来就是「定时事项用不了」），而不是笼统的 host-unavailable。
    */
   schedule() {
@@ -527,88 +442,6 @@ class TTeamRemote extends TypertRemoteService {
     }
   }
 
-  /** 小队定义服务（设置页「小队」标签）。 */
-  squads() {
-    const service = this.ctx.get(SQUAD_SERVICE);
-    if (service === undefined) {
-      throw this.hostUnavailable(SQUAD_SERVICE, "T专家 小队服务不可用（host 插件未加载）");
-    }
-    return service;
-  }
-
-  /**
-   * 团队运行服务（设置页「团队」标签）。
-   *
-   * 这一处**刻意偏离**「缺服务一律 tTeam/host-unavailable」的统一口径，原因有两条，都记录在此：
-   * ① 语义上仍准确 —— 对 `startSquad` 来说「host 没挂团队服务」就是「这支小队起不来」，
-   *    `tTeam/start-failed` 是可读的，而 `host-unavailable` 会丢掉「用户点的是启动」这层上下文；
-   * ② 向后兼容 —— 既有自检（verify.mjs 的 "startSquad 未知小队 → tTeam/start-failed"）与客户端都把
-   *    这个码当作「启动失败」的分类键，改成新码会让唯一被断言的分类断裂。
-   * 缺的是 `catalog`/`squads` 那两个访问器（没有等价的历史承诺），它们统一走 hostUnavailable()。
-   */
-  teams() {
-    const service = this.ctx.get(TEAM_SERVICE);
-    if (service === undefined) {
-// @ts-expect-error 上游类型缺口：同上，tTeam/* 业务码不在闭合的 RemoteErrorDetailsMap 里。
-      throw new RemoteError("tTeam/start-failed", "T专家 团队服务不可用（host 插件未加载）", { service: TEAM_SERVICE });
-    }
-    return service;
-  }
-
-  /** 小队定义 + 名册（成员选择器要的数据）。 */
-  async getSquads() {
-    try {
-      return this.squads().list();
-    } catch (error) {
-      throw this.businessError(error, "tTeam/squads-unreadable");
-    }
-  }
-
-  /** 写回小队定义并重编译引擎配置（失败自动回滚）。 */
-  async saveSquads(squads, expectedRevision) {
-    try {
-      return this.squads().save(squads, expectedRevision);
-    } catch (error) {
-      throw this.businessError(error, "tTeam/squads-invalid");
-    }
-  }
-
-  /** 从面板/弹窗里直接拉起一支小队（等价于用户敲 `/t <小队>`）。 */
-  async startSquad(profileKey, sessionId) {
-    try {
-      return await this.teams().start(profileKey, sessionId);
-    } catch (error) {
-      throw this.businessError(error, "tTeam/start-failed");
-    }
-  }
-
-  /** 活动团队 / 归档团队快照。 */
-  async getTeams(archived) {
-    try {
-      const teams = await this.teams().list(archived === true);
-      return { teams };
-    } catch (error) {
-      throw this.businessError(error, "tTeam/teams-unavailable");
-    }
-  }
-
-  /** 停止一个团队（等价于活动面板里的停止）。`workspacePath` 用于同名团队的精确定位。 */
-  async stopTeam(teamId, workspacePath = "") {
-    try {
-      return await this.teams().stop(teamId, workspacePath);
-    } catch (error) {
-      throw this.businessError(error, "tTeam/stop-failed");
-    }
-  }
-
-  /** 彻底删除一个团队（运行中的先停再删；已归档的直接删）。不可逆。 */
-  async deleteTeam(teamId, workspacePath = "") {
-    try {
-      return await this.teams().remove(teamId, workspacePath);
-    } catch (error) {
-      throw this.businessError(error, "tTeam/delete-failed");
-    }
-  }
 
   /**
    * 业务错误统一转 RemoteError（裸 Error 过线会退化成 gateway/internal 并丢掉 code）。
@@ -697,7 +530,7 @@ class TTeamRemote extends TypertRemoteService {
 }
 
 exposeRemoteMethods(TTeamRemote, [
-  "getCatalog", "setEnabled", "getPrompt", "getSquads", "saveSquads", "getTeams", "stopTeam", "deleteTeam", "startSquad",
+  "getCatalog", "setEnabled", "getPrompt",
   "getUiPrefs", "setUiPrefs",
   "getSchedule", "createScheduleItem", "updateScheduleItem", "deleteScheduleItem", "runScheduleItem", "previewSchedule", "ensureScheduleWorkspace",
   "createExpert", "updateExpert", "deleteExpert",

package/lib/schedule.js

@@ -9,7 +9,7 @@
  *     提交给会话的提示词用 `source.kind: "user"`（聊天右侧才渲染用户气泡；`plugin` 源会被收成 inject）。
  *
  * 三件事在这里闭环：
- *   1. 持久化：一个 JSON 文件，原子写（与 `teams.json` 同级、同风格）；
+ *   1. 持久化：一个 JSON 文件，原子写（与名册数据同风格）；
  *   2. 调度：每个启用项一个 croner job，宿主启动时全量重建，卸载时全部 stop；
  *   3. 执行：新建 agent 会话 → 挂部署默认 preset（不挂就没有工具）→ 提交提示词。
  *
@@ -23,7 +23,7 @@ import { writeFileAtomic } from "./catalog.js";
 
 /** 定时事项服务名（remote 侧的服务访问器用它）。 */
 export const SCHEDULE_SERVICE = "tTeamSchedule";
-/** 数据文件名（落在 T专家 数据根下，与 teams.json 同级）。 */
+/** 数据文件名（落在 T专家 数据根下）。 */
 export const SCHEDULE_FILE_NAME = "schedule.json";
 /** 每条事项保留的执行记录条数（最旧的先丢）。 */
 export const MAX_RUNS = 20;
@@ -96,7 +96,12 @@ export function normalizeInput(input, t) {
   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 }) };
+  const workspacePath = typeof raw.workspacePath === "string" && raw.workspacePath !== "" ? raw.workspacePath : undefined;
+  return {
+    title, prompt, cron, enabled,
+    ...(workspaceId === undefined ? {} : { workspaceId }),
+    ...(workspacePath === undefined ? {} : { workspacePath }),
+  };
 }
 
 /**
@@ -109,8 +114,6 @@ export function normalizeInput(input, t) {
  * @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]
  *   - 准备定时任务的工作区（默认「定时任务」工作区，或面板里填的自定义目录）。缺省则面板该项不可用。
  */
@@ -118,10 +121,6 @@ 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 */
@@ -157,6 +156,8 @@ export function createScheduleEngine(options) {
           cron: entry.cron,
           enabled: entry.enabled !== false,
           ...(typeof entry.workspaceId === "string" && entry.workspaceId !== "" ? { workspaceId: entry.workspaceId } : {}),
+          // 绑定时同步记下当时的工作区目录：工作区被删后用它「重建」回到原路径，避免要用户重填。
+          ...(typeof entry.workspacePath === "string" && entry.workspacePath !== "" ? { workspacePath: entry.workspacePath } : {}),
           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 } : {}),
@@ -239,11 +240,21 @@ export function createScheduleEngine(options) {
       if (agents === undefined || typeof agents.create !== "function") {
         throw new Error(t("schedule.agentsMissing"));
       }
-      const workspace = item.workspaceId === undefined
+      // 工作区解析：绑过 → 查 registry；查不到 → 按 task 记的路径自动 mkdir + create。
+      // 这是用户口径"工作区目录没了就自动新建"的实现点。recover 已经在内部把 workspaceId 写回 items。
+      let 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 recovered = await tryAutoRecoverWorkspace(item);
+        if (recovered === null || recovered === undefined) {
+          // 实在没路径可恢复（老数据迁移后没记路径）：给个明确报错让面板呈现。
+          const hint = typeof item.workspacePath === "string" && item.workspacePath !== ""
+            ? t("schedule.workspaceMissingWithPath", { id: item.workspaceId, path: item.workspacePath })
+            : t("schedule.workspaceMissing", { id: item.workspaceId });
+          throw new Error(hint);
+        }
+        workspace = recovered;
       }
       const selection = ctx.get("agentDefaultModel")?.currentSelection?.() ?? {};
       const sessionId = `session-${randomUUID()}`;
@@ -276,14 +287,10 @@ export function createScheduleEngine(options) {
       } 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)}`);
-      }
+      // 提示词**原样提交**：定时任务开的新会话与手动会话挂同一份 system prompt，里面已经写着
+      // 「看到 `@专家名` 就 summon_t_expert FIRST」。这里再做一次改写只会让同一个任务在定时任务
+      // 里显示成一长段模板、在手动对话里却只是 `@名字`，两条入口观感不一致（用户实测反馈）。
+      const promptText = item.prompt;
       // 必须用 source.kind: "user"：DSH 聊天把非 user 的 user/message 收成左侧
       // inject/context（plugin 源只显示插件名，正文不进右侧气泡）。定时任务的指令
       // 本身就是用户写的提示词，应当像手打那条一样出现在对话右侧。
@@ -362,12 +369,15 @@ export function createScheduleEngine(options) {
       cron: source.cron === undefined ? current.cron : source.cron,
       enabled: source.enabled === undefined ? current.enabled : source.enabled,
       workspaceId: source.workspaceId === undefined ? current.workspaceId : source.workspaceId,
+      // workspacePath 与 workspaceId 一同从表单过来；老数据没有也不补（创建时记的是绑定那一刻的目录）。
+      workspacePath: source.workspacePath === undefined ? current.workspacePath : source.workspacePath,
     };
     const fields = normalizeInput(merged, t);
     const next = { ...current, ...fields, updatedAt: new Date().toISOString() };
     // 展开旧记录会把旧的 workspaceId 一起带过来：用户把绑定改回「不绑定」时
     // fields 里没有这个键，必须显式删掉，否则界面上看着解绑了、执行时还挂在旧工作区。
     if (fields.workspaceId === undefined) delete next.workspaceId;
+    if (fields.workspacePath === undefined) delete next.workspacePath;
     items.set(id, next);
     scheduleOne(next);
     await persist();
@@ -407,6 +417,59 @@ export function createScheduleEngine(options) {
     return { armed };
   }
 
+  /**
+   * 自动恢复：执行路径发现工作区不见了，但任务里记着目录 → 顺着把工作区建回来。
+   * 这是用户口径"工作区目录没了就自动新建"的实现点：
+   *   - execute 拿到 registry.get 拿不到的 workspace 时，先看 item.workspacePath：
+   *     · 路径已记录：按这个路径 ensureWorkspace（**会顺带 mkdir 目录**，宿主 createCanonical 内部对同路径幂等复用）。
+   *     · 没路径：只能抛错让用户去左侧手动建一次工作区（之后 schedule.json 里的 workspaceId 会被自动建回。
+   *       老数据迁移后第一次失败就属于这种情况）。
+   *   - 恢复成功后顺便把 workspaceId 刷回去（**mutate 传入的 item + items.set 同步**：
+   *     execute 自身就是单飞序列，传入的 item 是 Map 里的那条引用；mutate 后 withRun 能
+   *     拿到最新字段，items.set + persist 保证落盘，调度下次直接命中 registry）。
+   *
+   * @returns 恢复出来的 workspace（已经是 registry 里的实体）；返回 null 表示不可恢复。
+   */
+  async function tryAutoRecoverWorkspace(item) {
+    const finalPath = resolveRebuildPath(item, undefined);
+    if (finalPath === "") return null;
+    try {
+      const workspace = await ensureOrFail(finalPath);
+      // 1) mutate 传入的 item：execute 后面的 withRun(item, ...) 直接看到新 workspaceId/Path。
+      item.workspaceId = workspace.id;
+      item.workspacePath = workspace.path;
+      item.updatedAt = new Date().toISOString();
+      delete item.lastRunError;
+      // 2) items.set 触发 Map 引用更新（与 mutate 实际指向同一对象，但保持语义一致）；
+      //    persist 把这条新字段落到磁盘。
+      items.set(item.id, item);
+      await persist();
+      logger?.info?.(`[t-team] 定时事项「${item.title}」绑定的工作区不存在，已按原路径 ${finalPath} 自动重建（id=${workspace.id}）。`);
+      return workspace;
+    } catch (error) {
+      logger?.warn?.(`[t-team] 定时事项「${item.title}」自动恢复工作区失败：${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+
+  /** 抽取"用哪条 path"的判定：外部传入优先，否则用 task 记的。两边都没有就返回空串。 */
+  function resolveRebuildPath(item, override) {
+    if (typeof override === "string" && override.trim() !== "") return override.trim();
+    if (typeof item?.workspacePath === "string" && item.workspacePath.trim() !== "") return item.workspacePath.trim();
+    return "";
+  }
+
+  /**
+   * 调宿主的工作区准备能力拿实体。宿主若未注入（理论上不会发生，scheduleEngine 必然随插件注入）
+   * 就在这里抛错，调用方自己决定是抛还是降级。
+   */
+  function ensureOrFail(path) {
+    if (ensureWorkspace === undefined) {
+      return Promise.reject(new Error("宿主没有提供工作区准备能力（ensureWorkspace）。"));
+    }
+    return ensureWorkspace(path, undefined);
+  }
+
   /** 卸载：停掉全部定时器（数据留着，下次启动重建）。 */
   function dispose() {
     for (const id of [...jobs.keys()]) stopJob(id);
@@ -421,12 +484,19 @@ export function createScheduleEngine(options) {
     remove,
     runNow,
     preview: (cron) => ({ fires: previewRuns(cron, t) }),
-    /** 给面板用：确保定时任务的默认工作区（或自定义目录）存在，返回 { id, title, path }。 */
-    ensureWorkspace: (path, title) => {
+    /**
+     * 给面板用：确保定时任务的默认工作区（或自定义目录）存在，返回精简 { id, title, path }。
+     *
+     * 注意：这里不直接转发 host 注入的 ensureWorkspace，因为后者现在透的是完整 entity
+     * （含 attachSession 等方法引用），不能塞进 remote 的 zod 严格 schema；面板用不上那些方法，
+     * 拿 id/title/path 就够了。
+     */
+    ensureWorkspace: async (path, title) => {
       if (ensureWorkspace === undefined) {
-        return Promise.reject(new Error("宿主没有提供工作区准备能力（ensureWorkspace）。"));
+        throw new Error("宿主没有提供工作区准备能力（ensureWorkspace）。");
       }
-      return ensureWorkspace(path, title);
+      const entity = await ensureWorkspace(path, title);
+      return { id: String(entity.id), title: String(entity.title ?? ""), path: String(entity.path ?? "") };
     },
     setArmed,
     isArmed: () => armed,

package/lib/skill.js

@@ -2,7 +2,7 @@
 /**
  * 随包发布的 skill：把「T专家 运维」做成**随 npm 包分发**的 skill。
  *
- * 为什么是 skill 而不是再加一段 systemPrompt：这些内容只在特定任务里需要（改名册/小队/装机/发布），
+ * 为什么是 skill 而不是再加一段 systemPrompt：这些内容只在特定任务里需要（改名册/装机/发布），
  * 常驻提示段是纯浪费 token；skill 的 description 本来就是路由面。
  *
  * 形态：`<包根>/skills/<name>/SKILL.md` 是标准 skill 文件（任何 skill 扫描器都能直接发现），

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dsh-plugin-t-expert",
-  "version": "0.3.88",
+  "version": "0.3.89",
   "type": "module",
-  "description": "T Expert — a 323-expert, 22-division roster with full Chinese translations, as a standalone DeepSeek Harness plugin, with a built-in multi-agent team engine (T Team).",
+  "description": "T Expert — a 323-expert, 22-division roster with full Chinese translations, as a standalone DeepSeek Harness plugin.",
   "license": "MIT",
   "author": "jiuaiwo",
   "keywords": [
@@ -10,7 +10,6 @@
     "dsh-plugin",
     "deepseek-harness",
     "t-expert",
-    "t-team",
     "expert-roster",
     "experts",
     "subagent",
@@ -44,15 +43,10 @@
     "data/experts",
     "data/zh",
     "data/source.json",
-    "data/team-profiles.py",
-    "data/teams.json",
-    "data/teams.resolved.json",
-    "data/t-team.config.json",
     "cordis.patch.yml",
     "README.md",
     "LICENSE",
     "THIRD-PARTY-NOTICES",
-    "vendor/dsh-agent-teams/LICENSE",
     "vendor/third-party-licenses"
   ],
   "dsh": {
@@ -79,8 +73,7 @@
     "render-smoke": "node tools/render-smoke.mjs",
     "verify": "node tools/verify.mjs",
     "sync-data": "node tools/sync-data.mjs",
-    "prepublishOnly": "npm run typecheck && npm run check-client && npm run render-smoke && npm run build && npm run verify && npm run invariants && node tools/sync-data.mjs --check",
-    "invariants": "node tools/invariants.mjs"
+    "prepublishOnly": "npm run typecheck && npm run check-client && npm run render-smoke && npm run build && npm run verify && node tools/sync-data.mjs --check"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",

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

@@ -19,4 +19,3 @@
 但**本插件不打包它的任何代码**，只用到了上面这两份 MIT 授权的资产，
 因此这里只需分发这两份 MIT 文本。
 
-内置团队引擎的许可证在 `../dsh-agent-teams/LICENSE`（同样随包分发）。