hiwork-core 0.0.18 → 0.0.19

package/lib/index.js

@@ -3137,7 +3137,7 @@ function isUnloading(ctx) {
 }
 
 // src/version.ts
-var PKG_VERSION = false ? "dev" : "0.0.18";
+var PKG_VERSION = false ? "dev" : "0.0.19";
 
 // src/ai-router-client.ts
 var AUTH_AUTHORIZE_PATH = "/api/auth/authorize";
@@ -5446,6 +5446,850 @@ function registerWorkbenchRpc(ctx, deps, store) {
   };
 }
 
+// src/pms-client.ts
+var PMS_BASE_URL = "https://pms.hivery.cn";
+var AUTH_LOGIN_PATH = "/api/auth/login";
+var AUTH_REFRESH_PATH = "/api/auth/refresh";
+var TODO_TODAY_PATH = "/api/todo/today";
+var TODO_STATISTICS_PATH = "/api/todo/statistics";
+var TASK_LIST_PATH = "/api/task/tasks";
+var PMS_REQUEST_TIMEOUT_MS = 1e4;
+var PMS_ACCESS_TOKEN_TTL_MS = 10 * 60 * 60 * 1e3;
+var PMS_RESULT_SUCCESS_CODE = 200;
+var PMS_RESULT_UNAUTHORIZED_CODE = 401;
+var PMS_AUTH_FAILURE_KEYWORDS = [
+  "\u7528\u6237\u540D\u6216\u5BC6\u7801\u9519\u8BEF",
+  "\u7528\u6237\u540D\u4E0D\u80FD\u4E3A\u7A7A",
+  "\u5BC6\u7801\u4E0D\u80FD\u4E3A\u7A7A",
+  "\u7528\u6237\u5DF2\u88AB\u7981\u7528",
+  "\u7528\u6237\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u7981\u7528",
+  "\u5237\u65B0Token\u65E0\u6548\u6216\u5DF2\u8FC7\u671F",
+  "\u65E0\u6CD5\u4ECEToken\u4E2D\u83B7\u53D6\u7528\u6237\u4FE1\u606F"
+];
+function isAuthFailureMessage(message) {
+  if (typeof message !== "string") return false;
+  return PMS_AUTH_FAILURE_KEYWORDS.some((keyword) => message.includes(keyword));
+}
+var PMS_PERMISSION_DENIED_MESSAGES = ["\u60A8\u6CA1\u6709\u8BE5\u64CD\u4F5C\u7684\u6743\u9650\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5206\u914D\u6743\u9650"];
+function isPermissionDeniedMessage(message) {
+  if (typeof message !== "string") return false;
+  return PMS_PERMISSION_DENIED_MESSAGES.some((text) => message.includes(text));
+}
+var PmsError = class extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "PmsError";
+  }
+};
+var PMS_UNAUTHORIZED_MESSAGE = "\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u8F93\u5165 PMS \u8D26\u53F7\u5BC6\u7801";
+var PMS_GENERIC_FAILURE_MESSAGE = "PMS \u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var PMS_FORBIDDEN_MESSAGE = "\u5728 HiWork \u91CC\u6CA1\u6709\u5B8C\u6210\u4EFB\u52A1\u7684\u6743\u9650\uFF0C\u8BF7\u5230 PMS \u64CD\u4F5C";
+var PMS_TASK_STATUS_COMPLETED = 2;
+var PMS_TASK_OPEN_STATUSES = [0, 1, 3];
+var PMS_TASK_PAGE_SIZE = 50;
+var PmsClient = class {
+  baseURL;
+  timeoutMs;
+  now;
+  log;
+  constructor(options = {}) {
+    this.baseURL = (options.baseURL ?? PMS_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? PMS_REQUEST_TIMEOUT_MS;
+    this.now = options.now ?? (() => Date.now());
+    this.log = options.log;
+  }
+  /**
+   * `POST /api/auth/login`：用账号密码换 JWT（access + refresh）。
+   *
+   * 失败语义（由 {@link PmsClient.call} 统一给出）：
+   *  - 账号密码不对 → `UNAUTHORIZED`（HTTP 401 **或** 信封 `code:401`，两者同义）；
+   *  - 其余（网络 / 超时 / 5xx / 非业务信封）→ `UPSTREAM_UNAVAILABLE`。
+   * **本方法不重试**，调用方也不许替它重试（§7：避免用错密码连续触发 PMS 的失败锁定）。
+   */
+  async login(username, password) {
+    const envelope = await this.call(AUTH_LOGIN_PATH, { method: "POST", body: { username, password } });
+    return this.tokenSet(envelope.data);
+  }
+  /**
+   * `POST /api/auth/refresh`：用 refresh token 续一次 access token。
+   *
+   * refresh token 失效（7 天到期 / 已被 PMS 撤销）→ `UNAUTHORIZED`，此时**只能**重新输入账号密码；
+   * 网络问题 → `UPSTREAM_UNAVAILABLE`（那是「稍后重试」，不是「要重新登录」——两者对用户是两件事）。
+   */
+  async refresh(refreshToken) {
+    const envelope = await this.call(AUTH_REFRESH_PATH, { method: "POST", body: { refreshToken } });
+    return this.tokenSet(envelope.data);
+  }
+  /**
+   * `GET /api/todo/today`：今日待办（⚠️ 口径比名字宽：**今天 + 明天 + 无截止日期**都算，spec §D4）。
+   *
+   * `data` 必须是数组；不是数组时按**上游不可用**处理（绝不读成「今天没有待办」——那是把中间层的
+   * 维护页当成空清单，用户会以为自己清空了所有待办）。缺 `id` 的条目跳过：没有 id 就没法勾选，
+   * 渲染出来只会是一个点了没反应的复选框。
+   */
+  async today(accessToken) {
+    const envelope = await this.call(TODO_TODAY_PATH, { method: "GET", accessToken });
+    if (!Array.isArray(envelope.data)) {
+      this.log?.("hiwork-core: PMS \u4ECA\u65E5\u5F85\u529E\u54CD\u5E94\u4E0D\u662F\u6570\u7EC4\uFF08\u53EF\u80FD\u7684\u4E2D\u95F4\u5C42\uFF09\uFF0C\u6309\u4E0A\u6E38\u4E0D\u53EF\u7528\u5904\u7406");
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
+    }
+    const items = [];
+    for (const raw of envelope.data) {
+      const item = toTodoItem(raw);
+      if (item === void 0) {
+        this.log?.("hiwork-core: PMS \u4ECA\u65E5\u5F85\u529E\u91CC\u6709\u4E00\u6761\u7F3A id \u7684\u6761\u76EE\uFF0C\u5DF2\u8DF3\u8FC7");
+        continue;
+      }
+      items.push(item);
+    }
+    return items;
+  }
+  /** `GET /api/todo/statistics`：total / pending / completed / overdue 四个计数。 */
+  async statistics(accessToken) {
+    const envelope = await this.call(TODO_STATISTICS_PATH, { method: "GET", accessToken });
+    if (!isRecord3(envelope.data)) {
+      this.log?.("hiwork-core: PMS \u5F85\u529E\u7EDF\u8BA1\u54CD\u5E94\u4E0D\u662F\u5BF9\u8C61\uFF08\u53EF\u80FD\u7684\u4E2D\u95F4\u5C42\uFF09\uFF0C\u6309\u4E0A\u6E38\u4E0D\u53EF\u7528\u5904\u7406");
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
+    }
+    return {
+      total: countOf(envelope.data["totalCount"]),
+      pending: countOf(envelope.data["pendingCount"]),
+      completed: countOf(envelope.data["completedCount"]),
+      overdue: countOf(envelope.data["overdueCount"])
+    };
+  }
+  /**
+   * `PUT /api/todo/{id}/status?status=PENDING|COMPLETED`：勾完成 / 取消完成。
+   *
+   * `status` 走 **query**（PMS 侧就是这么定的），所以必须 `encodeURIComponent`——虽然本层只放行
+   * 两个字面量、编码后与原值相同，但「拼进 URL 的值一律编码」是纪律：少一次编码在参数集合变化时
+   * 就是一个注入面。
+   *
+   * ⚠️ 副作用（spec §D5）：勾完成时若来源是项目任务且该任务下再无 PENDING 待办，**PMS 会把项目
+   * 任务一并标记完成**；反向不成立。本层只负责发请求，提示文案属 UI 的职责。
+   *
+   * 返回值以服务端回声为准（`data.id` / `data.status`），`data` 为空（PMS 这个接口可能回 void）
+   * 时回退成请求里的 id / status——调用方要的是「我勾的是哪条、现在是什么状态」，两者都知道。
+   */
+  async setStatus(accessToken, id, status) {
+    const path = `/api/todo/${encodeURIComponent(String(id))}/status?status=${encodeURIComponent(status)}`;
+    const envelope = await this.call(path, { method: "PUT", accessToken });
+    const data = envelope.data;
+    const completedTime = isRecord3(data) ? textOf(data["completedTime"]) : void 0;
+    return {
+      id: isRecord3(data) && isInteger(data["id"]) ? data["id"] : id,
+      status: isRecord3(data) && isTodoStatusValue(data["status"]) ? data["status"] : status,
+      ...completedTime === void 0 ? {} : { completedTime }
+    };
+  }
+  /**
+   * `GET /api/task/tasks?assigneeId={userId}&status=0&status=1&status=3&current=1&size=50`
+   * （spec §3 D7）：**我的未完成项目任务**。
+   *
+   * 为什么必须直接查任务而不是只读待办：PMS 只在**任务创建那一刻**生成待办
+   * （`TaskService.createFromTask`），转派、走 SQL 批量建的历史任务、以及机制上线前的任务都
+   * 没有待办——只读 `todo_task` 会让这些任务在面板上凭空消失（§3 D7 的缺口表）。
+   *
+   * `status` 在 PMS 侧是 `List<Integer>`，所以是**多个同名参数**而不是逗号分隔（`status=0&status=1&status=3`）；
+   * 顺序按 {@link PMS_TASK_OPEN_STATUSES}，`assigneeId` 是**当前登录人的 PMS userId**
+   * （由调用方从凭据记录里取，见 `src/pms-todo-bridge.ts`）。
+   *
+   * ⚠️ 响应的 `data` 是**分页对象**（`{records, total, current, size}`）**不是数组**：
+   * 不是对象或 `records` 不是数组时按**上游不可用**处理（绝不读成「我没有任务」——那会让用户
+   * 以为活都干完了，而这正是本次最要避免的误读）。
+   *
+   * @param accessToken - Host 内存里的 PMS JWT。
+   * @param userId - 我的 PMS userId（凭据记录里的 `userId`）。
+   * @param opts - 见 {@link PmsMyTasksOptions}。
+   */
+  async myTasks(accessToken, userId, opts = {}) {
+    const size = isPositiveInteger(opts.size) ? opts.size : PMS_TASK_PAGE_SIZE;
+    const query = new URLSearchParams();
+    query.append("assigneeId", String(userId));
+    for (const status of PMS_TASK_OPEN_STATUSES) query.append("status", String(status));
+    query.append("current", "1");
+    query.append("size", String(size));
+    const path = `${TASK_LIST_PATH}?${query.toString()}`;
+    const envelope = await this.call(path, { method: "GET", accessToken });
+    const data = envelope.data;
+    if (!isRecord3(data) || !Array.isArray(data["records"])) {
+      this.log?.(`hiwork-core: PMS \u6211\u7684\u4EFB\u52A1\u54CD\u5E94\u7684 data \u4E0D\u662F\u5206\u9875\u5BF9\u8C61\uFF08\u53EF\u80FD\u7684\u4E2D\u95F4\u5C42\uFF09\uFF0C\u6309\u4E0A\u6E38\u4E0D\u53EF\u7528\u5904\u7406`);
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
+    }
+    const items = [];
+    for (const raw of data["records"]) {
+      const item = toTaskItem(raw);
+      if (item === void 0) {
+        this.log?.("hiwork-core: PMS \u6211\u7684\u4EFB\u52A1\u91CC\u6709\u4E00\u6761\u7F3A id \u7684\u4EFB\u52A1\uFF0C\u5DF2\u8DF3\u8FC7");
+        continue;
+      }
+      items.push(item);
+    }
+    return {
+      items,
+      // 分页元数据缺失时给一个**自洽**的回退：总数 = 这次拿到的条数，页码 1，页大小 = 请求值。
+      total: countOr(data["total"], items.length),
+      current: countOr(data["current"], 1),
+      size: countOr(data["size"], size)
+    };
+  }
+  /**
+   * `PUT /api/task/tasks/{taskId}/status?status=2`：**完成一条项目任务**（spec §3 D7）。
+   *
+   * 与 {@link PmsClient.setStatus} 同款：`status` 走 **query** 且被编码；要求业务 `code === 200`，
+   * `data` 容许为 `null`（PMS 这个接口的返回类型是 `Result<Void>`，实测就是 null），此时回退成
+   * 请求里的 id / 状态数字——调用方要的是「我完成的是哪条、现在是什么状态」，两者都知道。
+   *
+   * ⚠️ 权限：这个端点带 `@PreAuthorize("hasAuthority('task:list:edit')")`，没有该权限的角色会失败
+   * （`FORBIDDEN`，见 {@link PMS_FORBIDDEN_MESSAGE}）。这与待办那条不同——**不要**把它当成「凭据
+   * 过期」让用户重新登录。
+   */
+  async completeTask(accessToken, taskId) {
+    const path = `${TASK_LIST_PATH}/${encodeURIComponent(String(taskId))}/status?status=${encodeURIComponent(String(PMS_TASK_STATUS_COMPLETED))}`;
+    const envelope = await this.call(path, { method: "PUT", accessToken });
+    const data = envelope.data;
+    return {
+      id: isRecord3(data) && isInteger(data["id"]) ? data["id"] : taskId,
+      status: isRecord3(data) && isInteger(data["status"]) ? data["status"] : PMS_TASK_STATUS_COMPLETED
+    };
+  }
+  /**
+   * 发一次调用并解开 `Result` 信封。**所有错误都在这里收敛**，返回值只有 `data`。
+   *
+   * 顺序是刻意的：**先看 HTTP 401，再解信封**——PMS 未登录时回的是 Spring Security 形状
+   * （`{path, code:"AUTH_001", message}`），它的 `message` 是给浏览器看跳登录页的，既不是业务文案
+   * 也可能带 `path` 等实现细节。把它当业务信封解析，轻则文案变成一句英文，重则把「凭据失效」
+   * 误判成「上游故障」而让用户不知道要重新输入密码。
+   */
+  async call(path, opts) {
+    let response;
+    try {
+      const headers = {
+        "user-agent": `hiwork-core/${PKG_VERSION}`,
+        accept: "application/json"
+      };
+      if (opts.body !== void 0) headers["content-type"] = "application/json";
+      if (opts.accessToken !== void 0) headers["authorization"] = `Bearer ${opts.accessToken}`;
+      const init = {
+        method: opts.method,
+        headers,
+        signal: AbortSignal.timeout(this.timeoutMs)
+      };
+      if (opts.body !== void 0) init.body = JSON.stringify(opts.body);
+      response = await fetch(`${this.baseURL}${path}`, init);
+    } catch {
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
+    }
+    if (response.status === 401) {
+      throw new PmsError("UNAUTHORIZED", PMS_UNAUTHORIZED_MESSAGE, 401);
+    }
+    if (response.status === 403) {
+      this.log?.(`hiwork-core: PMS ${path} \u62D2\u7EDD\u6388\u6743\uFF08HTTP 403\uFF09`);
+      throw new PmsError("FORBIDDEN", PMS_FORBIDDEN_MESSAGE, 403);
+    }
+    const payload = await readJson2(response);
+    if (!isRecord3(payload)) {
+      this.log?.(`hiwork-core: PMS ${path} \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94\uFF08HTTP ${response.status}\uFF09`);
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE, response.status);
+    }
+    const code = payload["code"];
+    if (typeof code !== "number" || !Number.isFinite(code)) {
+      this.log?.(`hiwork-core: PMS ${path} \u54CD\u5E94\u7F3A\u4E1A\u52A1 code\uFF08\u53EF\u80FD\u7684\u4E2D\u95F4\u5C42\uFF09`);
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE, response.status);
+    }
+    if (code === PMS_RESULT_UNAUTHORIZED_CODE || isAuthFailureMessage(payload["message"])) {
+      this.log?.(`hiwork-core: PMS ${path} \u62D2\u7EDD\u51ED\u636E\uFF08code=${code}\uFF09`);
+      throw new PmsError("UNAUTHORIZED", PMS_UNAUTHORIZED_MESSAGE, response.status);
+    }
+    if (code !== PMS_RESULT_SUCCESS_CODE) {
+      if (isPermissionDeniedMessage(payload["message"])) {
+        this.log?.(`hiwork-core: PMS ${path} \u62D2\u7EDD\u6388\u6743\uFF08code=${code}\uFF09`);
+        throw new PmsError("FORBIDDEN", PMS_FORBIDDEN_MESSAGE, response.status);
+      }
+      this.log?.(`hiwork-core: PMS ${path} \u8FD4\u56DE\u4E1A\u52A1\u5931\u8D25\uFF08code=${code}\uFF09`);
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE, response.status);
+    }
+    return { code, data: payload["data"] };
+  }
+  /** 登录 / 刷新的 `data` → {@link PmsTokenSet}。200 却不给 token 视为契约破坏（上游不可用）。 */
+  tokenSet(data) {
+    if (!isRecord3(data)) {
+      this.log?.("hiwork-core: PMS \u8BA4\u8BC1\u54CD\u5E94\u7F3A data\uFF08\u5951\u7EA6\u7834\u574F\uFF09\uFF0C\u6309\u4E0A\u6E38\u4E0D\u53EF\u7528\u5904\u7406");
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
+    }
+    const accessToken = textOf(data["token"]);
+    if (accessToken === void 0) {
+      this.log?.("hiwork-core: PMS \u8BA4\u8BC1\u54CD\u5E94\u7F3A token\uFF08\u5951\u7EA6\u7834\u574F\uFF09\uFF0C\u6309\u4E0A\u6E38\u4E0D\u53EF\u7528\u5904\u7406");
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
+    }
+    const refreshToken = textOf(data["refreshToken"]);
+    const expiresIn = data["expiresIn"];
+    const ttlMs = typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn * 1e3 : PMS_ACCESS_TOKEN_TTL_MS;
+    const userId = isInteger(data["userId"]) ? data["userId"] : void 0;
+    return {
+      accessToken,
+      ...refreshToken === void 0 ? {} : { refreshToken },
+      ...userId === void 0 ? {} : { userId },
+      expiresAt: this.now() + ttlMs
+    };
+  }
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textOf(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function isInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function isPositiveInteger(value) {
+  return isInteger(value) && value > 0;
+}
+function isTodoStatusValue(value) {
+  return value === "PENDING" || value === "COMPLETED";
+}
+function countOf(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function countOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function numberOf(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function toTodoItem(raw) {
+  if (!isRecord3(raw)) return void 0;
+  const id = raw["id"];
+  if (!isInteger(id)) return void 0;
+  const item = {
+    id,
+    title: textOf(raw["title"]) ?? "",
+    status: textOf(raw["status"]) ?? ""
+  };
+  const description = textOf(raw["description"]);
+  if (description !== void 0) item.description = description;
+  const category = textOf(raw["category"]);
+  if (category !== void 0) item.category = category;
+  const priority = textOf(raw["priority"]);
+  if (priority !== void 0) item.priority = priority;
+  const startDate = textOf(raw["startDate"]);
+  if (startDate !== void 0) item.startDate = startDate;
+  const dueDate = textOf(raw["dueDate"]);
+  if (dueDate !== void 0) item.dueDate = dueDate;
+  const completedTime = textOf(raw["completedTime"]);
+  if (completedTime !== void 0) item.completedTime = completedTime;
+  if (typeof raw["isOverdue"] === "boolean") item.isOverdue = raw["isOverdue"];
+  if (typeof raw["isDueSoon"] === "boolean") item.isDueSoon = raw["isDueSoon"];
+  return item;
+}
+function toTaskItem(raw) {
+  if (!isRecord3(raw)) return void 0;
+  const id = raw["id"];
+  if (!isInteger(id)) return void 0;
+  const item = {
+    id,
+    taskName: textOf(raw["taskName"]) ?? "",
+    description: textOf(raw["description"]) ?? "",
+    projectId: numberOf(raw["projectId"]),
+    projectName: textOf(raw["projectName"]) ?? "",
+    assigneeId: numberOf(raw["assigneeId"]),
+    assigneeName: textOf(raw["assigneeName"]) ?? "",
+    deadline: textOf(raw["deadline"]) ?? "",
+    status: numberOf(raw["status"]),
+    statusName: textOf(raw["statusName"]) ?? "",
+    priority: numberOf(raw["priority"]),
+    priorityName: textOf(raw["priorityName"]) ?? "",
+    taskType: textOf(raw["taskType"]) ?? "",
+    taskTypeName: textOf(raw["taskTypeName"]) ?? "",
+    auditStatus: numberOf(raw["auditStatus"]),
+    auditStatusName: textOf(raw["auditStatusName"]) ?? ""
+  };
+  const projectStageName = textOf(raw["projectStageName"]);
+  if (projectStageName !== void 0) item.projectStageName = projectStageName;
+  const requirementName = textOf(raw["requirementName"]);
+  if (requirementName !== void 0) item.requirementName = requirementName;
+  const moduleName = textOf(raw["moduleName"]);
+  if (moduleName !== void 0) item.moduleName = moduleName;
+  const estimatedHours = raw["estimatedHours"];
+  if (typeof estimatedHours === "number" && Number.isFinite(estimatedHours)) item.estimatedHours = estimatedHours;
+  const actualHours = raw["actualHours"];
+  if (typeof actualHours === "number" && Number.isFinite(actualHours)) item.actualHours = actualHours;
+  return item;
+}
+async function readJson2(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+
+// src/pms-todo-bridge.ts
+var PMS_TODO_RPC_CHANNEL = "/hiwork-pms-todo";
+var PMS_TODO_RPC_ENDPOINTS = [
+  "status",
+  "login",
+  "logout",
+  "today",
+  "statistics",
+  "setStatus",
+  "myTasks",
+  "completeTask"
+];
+var PMS_CREDENTIALS_REF = "HIWORK_PMS_CREDENTIALS";
+var PMS_TODO_ACCESS_TOKEN_TTL_MS = 10 * 60 * 60 * 1e3;
+var PMS_TODO_NOT_CONFIGURED_MESSAGE = "\u5C1A\u672A\u914D\u7F6E PMS \u8D26\u53F7\uFF0C\u8BF7\u5148\u8F93\u5165\u8D26\u53F7\u5BC6\u7801";
+var PMS_TODO_UNAUTHORIZED_MESSAGE = PMS_UNAUTHORIZED_MESSAGE;
+var PMS_TODO_FORBIDDEN_MESSAGE = PMS_FORBIDDEN_MESSAGE;
+var PMS_TODO_GENERIC_FAILURE_MESSAGE = PMS_GENERIC_FAILURE_MESSAGE;
+var PMS_TODO_CANCELLED_MESSAGE = "PMS \u5F85\u529E\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002";
+var PmsTodoRequestError = class extends Error {
+  code = "BAD_REQUEST";
+  constructor(message) {
+    super(message);
+    this.name = "PmsTodoRequestError";
+  }
+};
+function isPmsTodoRpcEndpoint(endpoint) {
+  return PMS_TODO_RPC_ENDPOINTS.includes(endpoint);
+}
+function asRecord(endpoint, raw) {
+  if (raw === void 0 || raw === null) return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new PmsTodoRequestError(`PMS \u5F85\u529E\u7AEF\u70B9 '${endpoint}' \u7684\u8BF7\u6C42\u53C2\u6570\u4E0D\u5408\u6CD5\u3002`);
+  }
+  return raw;
+}
+function rejectUnknownKeys(endpoint, record, allowed) {
+  for (const key of Object.keys(record)) {
+    if (!allowed.includes(key)) {
+      throw new PmsTodoRequestError(`PMS \u5F85\u529E\u7AEF\u70B9 '${endpoint}' \u7684\u8BF7\u6C42\u5305\u542B\u672A\u77E5\u5B57\u6BB5 '${key}'\u3002`);
+    }
+  }
+}
+function parsePmsTodoPayload(endpoint, raw) {
+  const record = asRecord(endpoint, raw);
+  if (endpoint === "status" || endpoint === "logout" || endpoint === "today" || endpoint === "statistics" || endpoint === "myTasks") {
+    rejectUnknownKeys(endpoint, record, []);
+    return { endpoint };
+  }
+  if (endpoint === "login") {
+    rejectUnknownKeys(endpoint, record, ["username", "password", "remember"]);
+    const username = typeof record["username"] === "string" ? record["username"].trim() : "";
+    if (username === "") throw new PmsTodoRequestError("PMS \u767B\u5F55\u8BF7\u6C42\u7F3A\u5C11 username\u3002");
+    const password = record["password"];
+    if (typeof password !== "string" || password === "") {
+      throw new PmsTodoRequestError("PMS \u767B\u5F55\u8BF7\u6C42\u7F3A\u5C11 password\u3002");
+    }
+    const remember = record["remember"];
+    if (remember !== void 0 && typeof remember !== "boolean") {
+      throw new PmsTodoRequestError("PMS \u767B\u5F55\u8BF7\u6C42\u7684 remember \u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002");
+    }
+    return { endpoint, username, password, remember: remember === true };
+  }
+  if (endpoint === "completeTask") {
+    rejectUnknownKeys(endpoint, record, ["id"]);
+    const id2 = record["id"];
+    if (typeof id2 !== "number" || !Number.isSafeInteger(id2) || id2 <= 0) {
+      throw new PmsTodoRequestError("PMS \u4EFB\u52A1 completeTask \u7684 id \u5FC5\u987B\u662F\u6B63\u6574\u6570\u3002");
+    }
+    return { endpoint, id: id2 };
+  }
+  rejectUnknownKeys(endpoint, record, ["id", "status"]);
+  const id = record["id"];
+  if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) {
+    throw new PmsTodoRequestError("PMS \u5F85\u529E setStatus \u7684 id \u5FC5\u987B\u662F\u6B63\u6574\u6570\u3002");
+  }
+  const status = record["status"];
+  if (status !== "PENDING" && status !== "COMPLETED") {
+    throw new PmsTodoRequestError("PMS \u5F85\u529E setStatus \u7684 status \u53EA\u80FD\u662F 'PENDING' \u6216 'COMPLETED'\u3002");
+  }
+  return { endpoint, id, status };
+}
+function pmsTodoErrorOf(error) {
+  if (error instanceof PmsTodoRequestError) return { code: error.code, message: error.message, details: {} };
+  if (error instanceof PmsTodoError) {
+    return { code: error.code, message: error.message, details: {} };
+  }
+  if (error instanceof PmsError) {
+    if (error.code === "UNAUTHORIZED") {
+      return { code: "UNAUTHORIZED", message: PMS_TODO_UNAUTHORIZED_MESSAGE, details: {} };
+    }
+    if (error.code === "FORBIDDEN") {
+      return { code: "FORBIDDEN", message: PMS_TODO_FORBIDDEN_MESSAGE, details: {} };
+    }
+    return { code: "UPSTREAM_UNAVAILABLE", message: displayPmsTodoMessage(error.code, error.message), details: {} };
+  }
+  return { code: "INTERNAL", message: PMS_TODO_GENERIC_FAILURE_MESSAGE, details: {} };
+}
+var PMS_TODO_MESSAGE_FALLBACK = {
+  UNAUTHORIZED: PMS_TODO_UNAUTHORIZED_MESSAGE,
+  FORBIDDEN: PMS_TODO_FORBIDDEN_MESSAGE,
+  UPSTREAM_UNAVAILABLE: PMS_TODO_GENERIC_FAILURE_MESSAGE
+};
+function displayPmsTodoMessage(code, message) {
+  const text = typeof message === "string" ? message.trim() : "";
+  if (text === "") return PMS_TODO_MESSAGE_FALLBACK[code] ?? PMS_TODO_GENERIC_FAILURE_MESSAGE;
+  const leaksImplementationDetail = /https?:\/\//i.test(text) || /\bHTTP\s*\d{3}\b/i.test(text) || /\bbaseURL\b/i.test(text);
+  if (leaksImplementationDetail) return PMS_TODO_MESSAGE_FALLBACK[code] ?? PMS_TODO_GENERIC_FAILURE_MESSAGE;
+  return text;
+}
+var PmsTodoError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PmsTodoError";
+  }
+};
+function errorName(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+function parseCredentialsRecord(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  const record = parsed;
+  const username = typeof record["username"] === "string" ? record["username"].trim() : "";
+  if (username === "") return void 0;
+  const password = typeof record["password"] === "string" && record["password"] !== "" ? record["password"] : void 0;
+  const refreshToken = typeof record["refreshToken"] === "string" && record["refreshToken"] !== "" ? record["refreshToken"] : void 0;
+  const expiresAt = typeof record["expiresAt"] === "number" && Number.isFinite(record["expiresAt"]) ? record["expiresAt"] : void 0;
+  const userId = typeof record["userId"] === "number" && Number.isSafeInteger(record["userId"]) ? record["userId"] : void 0;
+  return {
+    username,
+    ...password === void 0 ? {} : { password },
+    ...refreshToken === void 0 ? {} : { refreshToken },
+    ...expiresAt === void 0 ? {} : { expiresAt },
+    ...userId === void 0 ? {} : { userId }
+  };
+}
+function serializeCredentialsRecord(record) {
+  return JSON.stringify({
+    username: record.username,
+    ...record.password === void 0 ? {} : { password: record.password },
+    ...record.refreshToken === void 0 ? {} : { refreshToken: record.refreshToken },
+    ...record.expiresAt === void 0 ? {} : { expiresAt: record.expiresAt },
+    ...record.userId === void 0 ? {} : { userId: record.userId }
+  });
+}
+var PmsTodoStore = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** 内存里的凭据记录（不 remember 时它是这份凭据唯一的家）。 */
+  record;
+  /** 是否已经从 credentials 服务读过一次（避免每次调用都读盘）。 */
+  loaded = false;
+  /**
+   * 当前会话是否**属于磁盘上的那条记录**（remember=true 的登录、或启动时从记录里恢复）。
+   * 只有它为真时，refresh 换来的新 token 才回写记录——否则一次「不记住」的登录会顺手把
+   * refresh token 写给下一个人（登出后磁盘上仍有可用凭据，这正是不 remember 的相反面）。
+   */
+  persisted = false;
+  /** access token（**只在内存**）。 */
+  access;
+  /** 世代号：`login` / `logout` 各 +1，用来作废它之前发起的在飞请求（换账号的语义同工作台）。 */
+  generation = 0;
+  /** 在飞请求**连同世代与端点**记账：同一世代 + 同一端点才允许合并。 */
+  inFlight;
+  now() {
+    return this.deps.now?.() ?? Date.now();
+  }
+  /** 当前状态（同步语义的取数，异步实现：可能读一次 credentials）。**永不抛**。 */
+  async status() {
+    const record = await this.currentRecord();
+    return this.statusOf(record);
+  }
+  /**
+   * 用账号密码登录并**换取** JWT。
+   *
+   * ⚠️ **绝不自动重试**（spec §7 的硬要求）：PMS 对连续失败登录有锁定策略，而「自动重试」正是
+   * 最容易不小心连打两次的地方——用户手一抖打错一位密码，第二次尝试就会把账号推向锁定。
+   * 所以本方法**只发一次**请求，失败即返回错误（UI 引导用户自己再输一次）。
+   *
+   * `remember` 为真才落盘（§4.4）。落盘写的是**完整**记录（含密码），因为下次启动时要靠它
+   * 继续换 token——这不是「记住密码」的 UI 便利，而是 v1 认证方案本身（§3 D2）。
+   */
+  async login(input) {
+    const tokens = await this.deps.pms.login(input.username, input.password);
+    const record = {
+      username: input.username,
+      password: input.password,
+      ...tokens.refreshToken === void 0 ? {} : { refreshToken: tokens.refreshToken },
+      expiresAt: tokens.expiresAt,
+      // §3 D7：登录响应里的 `userId` 必须**在这里**捕获——「我的任务」要用它当 `assigneeId`，
+      // 而除了登录/刷新没有别的地方能拿到它（不猜、不按用户名反查）。
+      ...tokens.userId === void 0 ? {} : { userId: tokens.userId }
+    };
+    this.generation += 1;
+    this.record = record;
+    this.loaded = true;
+    this.access = { token: tokens.accessToken, expiresAt: tokens.expiresAt };
+    this.persisted = input.remember;
+    if (input.remember) {
+      await this.persist(record);
+    } else {
+      await this.forgetStored();
+    }
+    this.deps.log?.("hiwork-core: PMS \u8D26\u53F7\u5DF2\u767B\u5F55\uFF08\u51ED\u636E\u53EA\u5B58\u4E8E Host\uFF09");
+    return this.statusOf(record);
+  }
+  /**
+   * 登出：清内存 + 清凭据记录（spec §4.1 的 `logout`）。
+   *
+   * 不清 PMS 侧的服务端会话：PMS 的 JWT 是无状态签发的（没有「撤销单个 token」的接口），
+   * 我们能做且该做的是**不再持有**它——删掉本地凭据后，下一次取数一定要求重新输入。
+   */
+  async logout() {
+    this.generation += 1;
+    this.record = void 0;
+    this.loaded = true;
+    this.persisted = false;
+    this.access = void 0;
+    await this.forgetStored();
+    this.deps.log?.("hiwork-core: PMS \u51ED\u636E\u5DF2\u6E05\u9664");
+    return this.statusOf(void 0);
+  }
+  /** `GET /api/todo/today` + 本次拉取时刻。同一时刻的并发调用合并成一次 PMS 请求。 */
+  async today() {
+    return await this.dedupe("today", async () => {
+      const token = await this.authorize();
+      const items = await this.deps.pms.today(token);
+      return { items, fetchedAt: new Date(this.now()).toISOString() };
+    });
+  }
+  /** `GET /api/todo/statistics`。并发调用同样合并。 */
+  async statistics() {
+    return await this.dedupe("statistics", async () => {
+      const token = await this.authorize();
+      return await this.deps.pms.statistics(token);
+    });
+  }
+  /**
+   * `PUT /api/todo/{id}/status`。
+   *
+   * **不合并**并发调用：这是命令（用户点了两次就是两次动作），合并会让第二次点击被悄悄吞掉。
+   * 顺序也不由本层控制（谁先到谁先发），UI 侧要的是「失败就回滚那一条」，不是「服务端按我提交
+   * 的顺序处理」——那个语义 PMS 也不提供。
+   */
+  async setStatus(input) {
+    const token = await this.authorize();
+    return await this.deps.pms.setStatus(token, input.id, input.status);
+  }
+  /**
+   * `GET /api/task/tasks`：**我的未完成项目任务**（spec §3 D7）。
+   *
+   * `userId` 只从凭据记录里取（客户端传不进来，见 `parsePmsTodoPayload` 的注释）——这是
+   * 「只能查自己」唯一可靠的落点：端点白名单里也没有任何「按 id 查别人」的形状。
+   *
+   * 记录里**没有** `userId`（2026-09-18 之前登录的旧记录）时收敛成 `UNAUTHORIZED`：用户重新登录
+   * 一次即可拿到它。这里刻意**不**回退成「按用户名去查用户列表」之类的动作——那需要额外的接口与
+   * 权限，而且会在 Host 里凭空多一条拿别人数据的路径。
+   *
+   * 并发调用合并（同 `today`）：这是**取数**，同一时刻问两遍没有意义。
+   */
+  async myTasks(opts = {}) {
+    return await this.dedupe("myTasks", async () => {
+      const token = await this.authorize();
+      const userId = (await this.currentRecord())?.userId;
+      if (userId === void 0) {
+        this.deps.log?.("hiwork-core: PMS \u51ED\u636E\u8BB0\u5F55\u91CC\u6CA1\u6709 userId\uFF0C\u6211\u7684\u4EFB\u52A1\u9700\u8981\u91CD\u65B0\u767B\u5F55\u4E00\u6B21");
+        throw new PmsTodoError("UNAUTHORIZED", PMS_TODO_UNAUTHORIZED_MESSAGE);
+      }
+      return await this.deps.pms.myTasks(token, userId, opts);
+    });
+  }
+  /**
+   * `PUT /api/task/tasks/{id}/status?status=2`：完成一条项目任务。
+   *
+   * **不合并**并发调用（与 {@link PmsTodoStore.setStatus} 同理）：这是命令，用户点了两次就是两次
+   * 动作，合并会让第二次点击被悄悄吞掉。
+   *
+   * ⚠️ 权限：没有 `task:list:edit` 的角色会拿到 `FORBIDDEN`（`PmsError` → RPC 面的同名码），
+   * UI 按 §3 D7 提示「请到 PMS 操作」——**不是**重新登录。
+   */
+  async completeTask(input) {
+    const token = await this.authorize();
+    return await this.deps.pms.completeTask(token, input.id);
+  }
+  /**
+   * 取一个能用的 access token（凭证获取的唯一入口，spec §3 D3 说 v2 只替换这里）。
+   *
+   * 顺序是刻意的：
+   *  1. 内存里有未过期的 access token → 直接用（零网络请求）；
+   *  2. 过期了 → 先试 `refresh(refreshToken)`（§D2：refresh 有效就完全不必打扰用户）；
+   *     refresh 成功会**顺手**把新的 access / refresh token 写回内存（原来是持久化的会话则一并落盘）；
+   *  3. refresh 失败（401 / 记录里根本没有 refresh token）→ `UNAUTHORIZED`，UI 要求重新输入。
+   *
+   * ⚠️ 这里**没有**「拿存下来的密码重新登录」这一支，而且是刻意的：§7 要求凭据失效时
+   * **不自动重试**——用存下来的密码自动重登 = 每次 token 过期都自动替用户登一次，密码一旦改成
+   * 别的，就会变成一条稳定的「定时用错密码打 PMS」的流水，直到账号被锁。密码只在用户**明确**
+   * 提交一次 `login` 时才用（那时它也确实是用户刚输入的）。
+   */
+  async authorize() {
+    const access = this.access;
+    if (access !== void 0 && this.now() < access.expiresAt) return access.token;
+    const record = await this.currentRecord();
+    if (record === void 0) {
+      throw new PmsTodoError("NOT_CONFIGURED", PMS_TODO_NOT_CONFIGURED_MESSAGE);
+    }
+    const refreshToken = record.refreshToken;
+    if (refreshToken === void 0) {
+      throw new PmsTodoError("UNAUTHORIZED", PMS_TODO_UNAUTHORIZED_MESSAGE);
+    }
+    const tokens = await this.deps.pms.refresh(refreshToken);
+    const next = {
+      ...record,
+      ...tokens.refreshToken === void 0 ? {} : { refreshToken: tokens.refreshToken },
+      expiresAt: tokens.expiresAt
+    };
+    this.record = next;
+    this.access = { token: tokens.accessToken, expiresAt: tokens.expiresAt };
+    if (this.persisted) await this.persist(next);
+    return tokens.accessToken;
+  }
+  /**
+   * 状态投影（不读盘、不发网络）。
+   *
+   * `expiresAt` **只报还没过期的那个时刻**：记录里那份可能是上一次会话留下的（进程重启后内存里
+   * 没有 access token，只有磁盘上的旧 `expiresAt`），把它照实报出去，界面就会显示一个已经过去的
+   * 「有效期至」，看着像还能用。过期了就不写这个键——refresh 会顺手把它换成新的。
+   */
+  statusOf(record) {
+    const now = this.now();
+    const access = this.access;
+    const hasAccess = access !== void 0 && now < access.expiresAt;
+    const hasRefresh = record?.refreshToken !== void 0 && record.refreshToken !== "";
+    const expiresAt = access?.expiresAt ?? record?.expiresAt;
+    const freshExpiry = expiresAt !== void 0 && expiresAt > now ? expiresAt : void 0;
+    return {
+      configured: record !== void 0,
+      loggedIn: hasAccess || hasRefresh,
+      ...record === void 0 ? {} : { username: record.username },
+      ...freshExpiry === void 0 ? {} : { expiresAt: new Date(freshExpiry).toISOString() }
+    };
+  }
+  /**
+   * 当前凭据记录：内存优先，首次调用时从 credentials 服务读一次。
+   *
+   * 「读一次就记住 `loaded`」是有意的：凭据的写入方只有本类（`login` / `logout` / refresh 回写），
+   * 因此在同一进程里，读盘只需要一次。跨进程变更（别的进程写了同一个 ref）本就不可观测，
+   * 硬要每次重新读只会让「不 remember 的登录」被磁盘上的旧记录当场覆盖。
+   */
+  async currentRecord() {
+    if (this.loaded) return this.record;
+    this.loaded = true;
+    try {
+      const hit = await this.deps.credentials.resolve(PMS_CREDENTIALS_REF);
+      if (hit === void 0 || hit.value === "") return void 0;
+      const record = parseCredentialsRecord(hit.value);
+      this.record = record;
+      this.persisted = record !== void 0;
+      return record;
+    } catch (error) {
+      this.deps.log?.(`hiwork-core: PMS \u51ED\u636E\u8BFB\u53D6\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+      return void 0;
+    }
+  }
+  /**
+   * 落盘（**唯一**写 credentials 的地方，只在 remember 为真时被调用）。
+   *
+   * 失败**不**把一次成功的登录判为失败：会话已经拿到了，内存里照常可用；密码存不下的后果只是
+   * 「重启后要重新输入」。反过来把登录判为失败会让用户以为密码错了。
+   */
+  async persist(record) {
+    try {
+      await this.deps.credentials.set(PMS_CREDENTIALS_REF, serializeCredentialsRecord(record));
+      this.persisted = true;
+    } catch (error) {
+      this.deps.log?.(`hiwork-core: PMS \u51ED\u636E\u843D\u76D8\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+    }
+  }
+  /**
+   * 抹掉磁盘上的记录（logout / 不记住的登录）。
+   *
+   * 先 `resolve` 一次再 `unset`：没有记录时一次写都不做（测试与磁盘都清清爽爽），有记录时
+   * **必须**清掉——否则一条旧的 account+refresh token 会在下次启动时被当成「这个人配置过凭据」，
+   * 用户明明刚选了「不记住」却在重启后仍是登录态。
+   */
+  async forgetStored() {
+    try {
+      const hit = await this.deps.credentials.resolve(PMS_CREDENTIALS_REF);
+      if (hit === void 0 || hit.value === "") return;
+      await this.deps.credentials.unset(PMS_CREDENTIALS_REF);
+    } catch (error) {
+      this.deps.log?.(`hiwork-core: PMS \u51ED\u636E\u6E05\u9664\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+    }
+  }
+  /**
+   * 并发合并：同一世代 + 同一端点的在飞请求共用一次调用与同一个返回值。
+   *
+   * 世代判据与 `src/client/managed-workbench.ts` 的 `dedupe` 同形：`login` / `logout` 之后
+   * 账上那条属于**上一个人**，谁都不许复用（复用等于把上一个人的待办显示给新账号）。
+   */
+  async dedupe(key, task) {
+    const inFlight = this.inFlight;
+    if (inFlight !== void 0 && inFlight.generation === this.generation && inFlight.key === key) {
+      return await inFlight.task;
+    }
+    const generation = this.generation;
+    const promise = task();
+    this.inFlight = { generation, key, task: promise };
+    try {
+      return await promise;
+    } finally {
+      if (this.inFlight?.task === promise) this.inFlight = void 0;
+    }
+  }
+};
+async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, signal) {
+  try {
+    if (signal?.aborted === true) return failure7("BAD_REQUEST", PMS_TODO_CANCELLED_MESSAGE);
+    if (!isPmsTodoRpcEndpoint(endpoint)) {
+      throw new PmsTodoRequestError(`\u672A\u77E5\u7684 PMS \u5F85\u529E\u7AEF\u70B9 '${endpoint}'`);
+    }
+    const payload = parsePmsTodoPayload(endpoint, rawPayload);
+    switch (payload.endpoint) {
+      case "status":
+        return { ok: true, value: await store.status() };
+      case "login":
+        return { ok: true, value: await store.login({ username: payload.username, password: payload.password, remember: payload.remember }) };
+      case "logout":
+        return { ok: true, value: await store.logout() };
+      case "today":
+        return { ok: true, value: await store.today() };
+      case "statistics":
+        return { ok: true, value: await store.statistics() };
+      case "setStatus":
+        return { ok: true, value: await store.setStatus({ id: payload.id, status: payload.status }) };
+      case "myTasks":
+        return { ok: true, value: await store.myTasks() };
+      case "completeTask":
+        return { ok: true, value: await store.completeTask({ id: payload.id }) };
+    }
+  } catch (error) {
+    deps.log?.(`hiwork-core: PMS \u5F85\u529E RPC '${endpoint}' \u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+    return { ok: false, error: pmsTodoErrorOf(error) };
+  }
+}
+function failure7(code, message) {
+  return { ok: false, error: { code, message, details: {} } };
+}
+function registerPmsTodoRpc(ctx, deps, store) {
+  const handler = (endpoint, payload, signal) => handlePmsTodoEndpoint(endpoint, payload, deps, store, signal);
+  const remove = ctx.connection.rpc.handle(PMS_TODO_RPC_CHANNEL, handler, { authority: "loopback" });
+  return async () => {
+    await remove();
+  };
+}
+
 // src/plugin-updates-rpc.ts
 var PLUGIN_UPDATES_RPC_CHANNEL = "/hiwork-plugin-updates";
 var PLUGIN_UPDATES_RPC_ENDPOINTS = ["snapshot", "apply"];
@@ -5460,7 +6304,7 @@ var PLUGIN_UPDATES_GENERIC_FAILURE_MESSAGE = "\u63D2\u4EF6\u66F4\u65B0\u72B6\u60
 function isPluginUpdatesRpcEndpoint(endpoint) {
   return PLUGIN_UPDATES_RPC_ENDPOINTS.includes(endpoint);
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textOrUndefined4(value) {
@@ -5482,7 +6326,7 @@ function parsePluginUpdatesPayload(endpoint, raw) {
   return {};
 }
 function toPackageUpdate(raw) {
-  if (!isRecord3(raw)) return void 0;
+  if (!isRecord4(raw)) return void 0;
   const packageName = textOrUndefined4(raw["packageName"]);
   if (packageName === void 0) return void 0;
   return {
@@ -5493,7 +6337,7 @@ function toPackageUpdate(raw) {
   };
 }
 function toSnapshot(raw) {
-  if (!isRecord3(raw)) return void 0;
+  if (!isRecord4(raw)) return void 0;
   const packages = [];
   for (const item of Array.isArray(raw["packages"]) ? raw["packages"] : []) {
     const normalized = toPackageUpdate(item);
@@ -5509,7 +6353,7 @@ function toSnapshot(raw) {
 }
 async function handlePluginUpdatesEndpoint(endpoint, rawPayload, deps, signal) {
   try {
-    if (isAborted7(signal)) return failure7("cancelled", "\u63D2\u4EF6\u66F4\u65B0\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted7(signal)) return failure8("cancelled", "\u63D2\u4EF6\u66F4\u65B0\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isPluginUpdatesRpcEndpoint(endpoint)) {
       throw new PluginUpdatesRequestError("bad-request", `\u672A\u77E5\u7684\u63D2\u4EF6\u66F4\u65B0\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -5525,12 +6369,12 @@ async function handlePluginUpdatesEndpoint(endpoint, rawPayload, deps, signal) {
     await plugins.applyNow();
     return { ok: true, value: { requested: true } };
   } catch (error) {
-    if (error instanceof PluginUpdatesRequestError) return failure7(error.code, error.message);
+    if (error instanceof PluginUpdatesRequestError) return failure8(error.code, error.message);
     deps.log?.(`hiwork-core: \u63D2\u4EF6\u66F4\u65B0 RPC '${endpoint}' \u5931\u8D25\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
-    return failure7("internal", PLUGIN_UPDATES_GENERIC_FAILURE_MESSAGE);
+    return failure8("internal", PLUGIN_UPDATES_GENERIC_FAILURE_MESSAGE);
   }
 }
-function failure7(code, message) {
+function failure8(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerPluginUpdatesRpc(ctx, deps) {
@@ -5820,7 +6664,7 @@ function parseDeviceInfo(message) {
     ...version === void 0 || version === "" ? {} : { appVersion: version }
   };
 }
-function errorName(error) {
+function errorName2(error) {
   return error instanceof Error ? error.name : typeof error;
 }
 function registerIpcMessageHandler(ports) {
@@ -5847,12 +6691,12 @@ function registerIpcMessageHandler(ports) {
       authInFlight = true;
       try {
         void Promise.resolve(ports.complete(input)).catch((error) => {
-          log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5904\u7406\u5F02\u5E38\uFF08${errorName(error)}\uFF09`);
+          log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5904\u7406\u5F02\u5E38\uFF08${errorName2(error)}\uFF09`);
         }).finally(() => {
           authInFlight = false;
         });
       } catch (error) {
-        log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5206\u53D1\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+        log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5206\u53D1\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
         authInFlight = false;
       }
       return;
@@ -5900,12 +6744,12 @@ async function projectLoginMode(opts) {
       }
     }
   } catch (error) {
-    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u62C9\u53D6\u5931\u8D25\uFF0C\u767B\u5F55\u65B9\u5F0F\u56DE\u9000 both\uFF08${errorName(error)}\uFF09`);
+    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u62C9\u53D6\u5931\u8D25\uFF0C\u767B\u5F55\u65B9\u5F0F\u56DE\u9000 both\uFF08${errorName2(error)}\uFF09`);
   }
   try {
     await opts.state.patch({ set: { loginMode, passwordLogin } });
   } catch (error) {
-    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u5199\u5165\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u5199\u5165\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
   }
   return loginMode;
 }
@@ -6127,6 +6971,20 @@ function apply(ctx, config) {
       clearInterval(timer);
     };
   }, "hiwork-core: workbench warmup");
+  const pmsTodoDeps = {
+    credentials: ports.credentials,
+    pms: new PmsClient({ log: (message) => {
+      ctx.logger.warn(message);
+    } }),
+    log: (message) => {
+      ctx.logger.warn(message);
+    }
+  };
+  const pmsTodo = new PmsTodoStore(pmsTodoDeps);
+  ctx.effect(
+    () => registerPmsTodoRpc({ connection, logger: ctx.logger }, pmsTodoDeps, pmsTodo),
+    "hiwork-core: pms todo rpc"
+  );
   ctx.effect(() => provideOfficeCredentials(ctx, {
     resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
     gateway: () => {