hiwork-core 0.0.22 → 0.0.24

package/lib/index.js

@@ -3137,7 +3137,7 @@ function isUnloading(ctx) {
 }
 
 // src/version.ts
-var PKG_VERSION = false ? "dev" : "0.0.22";
+var PKG_VERSION = false ? "dev" : "0.0.24";
 
 // src/ai-router-client.ts
 var AUTH_AUTHORIZE_PATH = "/api/auth/authorize";
@@ -5448,8 +5448,6 @@ 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";
@@ -5501,26 +5499,60 @@ var PmsClient = class {
     this.log = options.log;
   }
   /**
-   * `POST /api/auth/login`：用账号密码换 JWT（access + refresh）。
+   * `POST {mintUrl}`：用一张网关签发的 **120 秒身份断言**换一把 **10 小时 PMS JWT**
+   * （spec `2026-09-21-pms-zero-input-login-design.md` §4.1b）。
    *
-   * 失败语义（由 {@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。
+   * 与其余方法的两处形状差异都是契约给定的，不是本层偷懒：
+   *  - **`mintUrl` 是绝对地址**，来自网关的连接器分配（`auth.mintUrl`）——它**不拼** {@link PMS_BASE_URL}：
+   *    那个常量是「PMS 部署地址」，而兑换端点由网关的分配清单说了算（本层不猜也不改写，见
+   *    {@link PmsClient.send}）；
+   *  - **不解 `Result` 信封**：成功体就是 `{token, expiresAt, userId, username}`，失败体是
+   *    `{error:"assertion_rejected"}` 这类——两者都不是业务信封。
+   *
+   * 失败语义：
+   *  - HTTP 401 / 403（断言过期、`aud` 不符、签名不过、工号在 PMS 不存在）→ `UNAUTHORIZED`：用户该做的
+   *    是**重新登录 HiWork 客户端**（断言来自网关会话），不是再输一次 PMS 密码（spec D8）；
+   *  - 其余（网络 / 超时 / 400 / 503 / 非 JSON / 2xx 却形状不符）→ `UPSTREAM_UNAVAILABLE`。
    *
-   * refresh token 失效（7 天到期 / 已被 PMS 撤销）→ `UNAUTHORIZED`，此时**只能**重新输入账号密码；
-   * 网络问题 → `UPSTREAM_UNAVAILABLE`（那是「稍后重试」，不是「要重新登录」——两者对用户是两件事）。
+   * **本方法不重试**：断言是一次性的（PMS 侧拿 `jti` 做 2 分钟防重放），要重试必须由调用方**换一张新
+   * 断言**再调——重发同一张只会换来第二个 403（spec §6）。
+   *
+   * @param mintUrl - 网关分配里的 `auth.mintUrl`（绝对 URL）。
+   * @param assertion - 网关签发的短命断言（**不进日志、不落盘**，用完即弃）。
+   * @param deviceRef - 设备标识串（可空；只进 PMS 侧审计，不参与鉴权）。
+   * @returns 令牌与它的元数据（`token` 交给 Host 内存，见 `src/pms-todo-bridge.ts`）。
    */
-  async refresh(refreshToken) {
-    const envelope = await this.call(AUTH_REFRESH_PATH, { method: "POST", body: { refreshToken } });
-    return this.tokenSet(envelope.data);
+  async exchangeAssertion(mintUrl, assertion, deviceRef) {
+    const response = await this.send(mintUrl, { method: "POST", body: { assertion, deviceRef } });
+    if (response.status === 401 || response.status === 403) {
+      this.log?.(`hiwork-core: PMS \u6362\u4EE4\u724C\u88AB\u62D2\uFF08HTTP ${response.status}\uFF09`);
+      throw new PmsError("UNAUTHORIZED", PMS_UNAUTHORIZED_MESSAGE, response.status);
+    }
+    if (response.status < 200 || response.status >= 300) {
+      this.log?.(`hiwork-core: PMS \u6362\u4EE4\u724C\u5931\u8D25\uFF08HTTP ${response.status}\uFF09`);
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE, response.status);
+    }
+    const payload = await readJson2(response);
+    if (!isRecord3(payload)) {
+      this.log?.("hiwork-core: PMS \u6362\u4EE4\u724C\u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94\uFF08\u53EF\u80FD\u7684\u4E2D\u95F4\u5C42\uFF09");
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE, response.status);
+    }
+    const token = textOf(payload["token"]);
+    if (token === void 0) {
+      this.log?.("hiwork-core: PMS \u6362\u4EE4\u724C\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, response.status);
+    }
+    if (!isInteger(payload["userId"])) {
+      this.log?.("hiwork-core: PMS \u6362\u4EE4\u724C\u54CD\u5E94\u7F3A userId / \u5F62\u6001\u4E0D\u5BF9\uFF08\u5951\u7EA6\u7834\u574F\uFF09\uFF0C\u6309\u4E0A\u6E38\u4E0D\u53EF\u7528\u5904\u7406");
+      throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE, response.status);
+    }
+    return {
+      token,
+      // 两个非关键字段按容错处理：令牌已经拿到了，不为一个坏字段让用户重来一次。
+      expiresAt: expiresAtOr(payload["expiresAt"], this.now() + PMS_ACCESS_TOKEN_TTL_MS),
+      userId: payload["userId"],
+      username: textOf(payload["username"]) ?? ""
+    };
   }
   /**
    * `GET /api/todo/today`：今日待办（⚠️ 口径比名字宽：**今天 + 明天 + 无截止日期**都算，spec §D4）。
@@ -5656,15 +5688,18 @@ var PmsClient = class {
     };
   }
   /**
-   * 发一次调用并解开 `Result` 信封。**所有错误都在这里收敛**，返回值只有 `data`。
+   * 发一次请求：拼地址、塞请求头、按 {@link PmsClientOptions.timeoutMs} 超时。**只有传输**。
    *
-   * 顺序是刻意的：**先看 HTTP 401，再解信封**——PMS 未登录时回的是 Spring Security 形状
-   * （`{path, code:"AUTH_001", message}`），它的 `message` 是给浏览器看跳登录页的，既不是业务文案
-   * 也可能带 `path` 等实现细节。把它当业务信封解析，轻则文案变成一句英文，重则把「凭据失效」
-   * 误判成「上游故障」而让用户不知道要重新输入密码。
+   * 与 {@link PmsClient.call} 的分工：`call` 负责 `Result` 信封与业务码，本方法不管响应体是什么形状
+   * ——换令牌那条路（{@link PmsClient.exchangeAssertion}）既不解信封也不认业务码，但**超时口径与请求头
+   * 必须与其余调用逐字相同**（spec §7：统一 10s、令牌只在有身份时发），所以两条路共用这一处，
+   * 而不是各抄一份、将来各自漂移。
+   *
+   * @param url - 相对路径（拼 {@link PmsClient.baseURL}）或**绝对 URL**（原样使用）。
+   * @param opts - 方法 / 可选 JSON 体 / 可选 Bearer 令牌。
+   * @returns 原始 `Response`：状态码由调用方判定，本方法不把任何状态码当成错误。
    */
-  async call(path, opts) {
-    let response;
+  async send(url, opts) {
     try {
       const headers = {
         "user-agent": `hiwork-core/${PKG_VERSION}`,
@@ -5678,10 +5713,22 @@ var PmsClient = class {
         signal: AbortSignal.timeout(this.timeoutMs)
       };
       if (opts.body !== void 0) init.body = JSON.stringify(opts.body);
-      response = await fetch(`${this.baseURL}${path}`, init);
+      return await fetch(isAbsoluteUrl(url) ? url : `${this.baseURL}${url}`, init);
     } catch {
       throw new PmsError("UPSTREAM_UNAVAILABLE", PMS_GENERIC_FAILURE_MESSAGE);
     }
+  }
+  /**
+   * 发一次调用并解开 `Result` 信封。**PMS 的业务错误都在这里收敛**，返回值只有 `data`
+   * （传输层的失败已在 {@link PmsClient.send} 收敛）。
+   *
+   * 顺序是刻意的：**先看 HTTP 401，再解信封**——PMS 未登录时回的是 Spring Security 形状
+   * （`{path, code:"AUTH_001", message}`），它的 `message` 是给浏览器看跳登录页的，既不是业务文案
+   * 也可能带 `path` 等实现细节。把它当业务信封解析，轻则文案变成一句英文，重则把「凭据失效」
+   * 误判成「上游故障」而让用户不知道要重新输入密码。
+   */
+  async call(path, opts) {
+    const response = await this.send(path, opts);
     if (response.status === 401) {
       throw new PmsError("UNAUTHORIZED", PMS_UNAUTHORIZED_MESSAGE, 401);
     }
@@ -5713,32 +5760,17 @@ var PmsClient = class {
     }
     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 isAbsoluteUrl(url) {
+  return /^https?:\/\//i.test(url);
+}
+function expiresAtOr(value, fallbackMs) {
+  if (typeof value === "string" && value !== "" && Number.isFinite(Date.parse(value))) return value;
+  return new Date(fallbackMs).toISOString();
+}
 function textOf(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
@@ -5831,18 +5863,18 @@ async function readJson2(response) {
 var PMS_TODO_RPC_CHANNEL = "/hiwork-pms-todo";
 var PMS_TODO_RPC_ENDPOINTS = [
   "status",
-  "login",
-  "logout",
   "today",
   "statistics",
   "setStatus",
   "myTasks",
   "completeTask"
 ];
+var PMS_ASSIGNMENT_SLUG = "pms";
 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_REUSE_MIN_REMAINING_RATIO = 0.5;
+var PMS_TODO_NOT_CONFIGURED_MESSAGE = "\u7BA1\u7406\u5458\u5C1A\u672A\u628A PMS \u63A5\u5165\u8FD9\u53F0\u5BA2\u6237\u7AEF\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458";
+var PMS_TODO_UNAUTHORIZED_MESSAGE = "\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55 HiWork \u5BA2\u6237\u7AEF";
 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";
@@ -5853,9 +5885,19 @@ var PmsTodoRequestError = class extends Error {
     this.name = "PmsTodoRequestError";
   }
 };
+var PmsTodoError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PmsTodoError";
+  }
+};
 function isPmsTodoRpcEndpoint(endpoint) {
   return PMS_TODO_RPC_ENDPOINTS.includes(endpoint);
 }
+function textOf2(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
 function asRecord(endpoint, raw) {
   if (raw === void 0 || raw === null) return {};
   if (typeof raw !== "object" || Array.isArray(raw)) {
@@ -5872,24 +5914,10 @@ function rejectUnknownKeys(endpoint, record, allowed) {
 }
 function parsePmsTodoPayload(endpoint, raw) {
   const record = asRecord(endpoint, raw);
-  if (endpoint === "status" || endpoint === "logout" || endpoint === "today" || endpoint === "statistics" || endpoint === "myTasks") {
+  if (endpoint === "status" || 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"];
@@ -5937,139 +5965,95 @@ function displayPmsTodoMessage(code, message) {
   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;
+function gatewayCodeOf(error) {
+  return error instanceof GatewayError ? error.code : errorName(error);
+}
+async function clearLegacyCredentials(credentials, log) {
   try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return void 0;
+    const hit = await credentials.resolve(PMS_CREDENTIALS_REF);
+    if (hit === void 0 || hit.value === "") return;
+    await credentials.unset(PMS_CREDENTIALS_REF);
+    log?.("hiwork-core: \u5DF2\u6E05\u9664 v1 \u9057\u7559\u7684 PMS \u51ED\u636E\u8BB0\u5F55");
+  } catch (error) {
+    log?.(`hiwork-core: PMS \u9057\u7559\u51ED\u636E\u6E05\u9664\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
   }
-  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;
+}
+function sessionOf(result, now) {
+  const parsed = Date.parse(result.expiresAt);
   return {
-    username,
-    ...password === void 0 ? {} : { password },
-    ...refreshToken === void 0 ? {} : { refreshToken },
-    ...expiresAt === void 0 ? {} : { expiresAt },
-    ...userId === void 0 ? {} : { userId }
+    token: result.token,
+    // `PmsClient` 已保证 `expiresAt` 可解析（缺失时它自己兜底成 now + 10 小时）；这里再兜一次
+    // 是为了「上游回了一个解析不了的串」时不至于把过期时刻变成 NaN（那会让复用判据永远为假）。
+    expiresAt: Number.isFinite(parsed) ? parsed : now + PMS_TODO_ACCESS_TOKEN_TTL_MS,
+    issuedAt: now,
+    userId: result.userId,
+    username: result.username
   };
 }
-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;
-  /** 在飞请求**连同世代与端点**记账：同一世代 + 同一端点才允许合并。 */
+  /** 内存里的会话（**唯一的家**，不落盘；重启后自然重换）。 */
+  session;
+  /** 网关分配清单里那条 `pms` 分配（只在内存里记住，免得每次取数都拉一遍清单）。 */
+  assignment;
+  /** 最近一次「为什么还没就绪」（进 `status` 的 `reason`；成功换到令牌时清空）。 */
+  reason;
+  /** 在飞请求按端点记账：同一端点才允许合并。 */
   inFlight;
   now() {
     return this.deps.now?.() ?? Date.now();
   }
-  /** 当前状态（同步语义的取数，异步实现：可能读一次 credentials）。**永不抛**。 */
-  async status() {
-    const record = await this.currentRecord();
-    return this.statusOf(record);
-  }
   /**
-   * 用账号密码登录并**换取** JWT。
+   * 当前状态（spec §4.4）。**永不抛**：失败在快照里表现为 `configured=false` + `reason`。
    *
-   * ⚠️ **绝不自动重试**（spec §7 的硬要求）：PMS 对连续失败登录有锁定策略，而「自动重试」正是
-   * 最容易不小心连打两次的地方——用户手一抖打错一位密码，第二次尝试就会把账号推向锁定。
-   * 所以本方法**只发一次**请求，失败即返回错误（UI 引导用户自己再输一次）。
+   * 顺序是刻意的：
+   *  1. 手上有一张未过期的 JWT → 直接报 `loggedIn`，**一次网络都不发**（面板每次挂载都读它）；
+   *  2. 没有 → 问一次网关「到底有没有 `pms` 分配」。`configured` 的判据只能是它：用户填没填过
+   *     账号密码这件事已经不存在了（D3），而「有没有分配」只有网关知道。第二次起走内存里的那条
+   *     分配，不再打网关。
    *
-   * `remember` 为真才落盘（§4.4）。落盘写的是**完整**记录（含密码），因为下次启动时要靠它
-   * 继续换 token——这不是「记住密码」的 UI 便利，而是 v1 认证方案本身（§3 D2）。
+   * `reason` 只在「还没就绪」时出现：`no-assignment` / `gateway-signed-out` / `unavailable` 三种，
+   * 分别对应「找管理员」/「重新登录 HiWork」/「稍后重试」（spec §3 D8 的 UI 动作各不相同）。
    */
-  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();
+  async status() {
+    const session = this.session;
+    if (session !== void 0 && this.now() < session.expiresAt) {
+      return {
+        configured: true,
+        loggedIn: true,
+        username: session.username,
+        expiresAt: new Date(session.expiresAt).toISOString(),
+        userId: session.userId,
+        ...this.reason === void 0 ? {} : { reason: this.reason }
+      };
+    }
+    try {
+      const cookie = await this.sessionCookie();
+      const gateway = this.gatewayPort();
+      await this.ensureAssignment(gateway, cookie);
+      return { configured: true, loggedIn: false, ...this.reason === void 0 ? {} : { reason: this.reason } };
+    } catch {
+      return { configured: false, loggedIn: false, reason: this.reason ?? "unavailable" };
     }
-    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);
+      const session = await this.authorize();
+      const items = await this.deps.pms.today(session.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);
+      const session = await this.authorize();
+      return await this.deps.pms.statistics(session.token);
     });
   }
   /**
@@ -6080,30 +6064,21 @@ var PmsTodoStore = class {
    * 的顺序处理」——那个语义 PMS 也不提供。
    */
   async setStatus(input) {
-    const token = await this.authorize();
-    return await this.deps.pms.setStatus(token, input.id, input.status);
+    const session = await this.authorize();
+    return await this.deps.pms.setStatus(session.token, input.id, input.status);
   }
   /**
    * `GET /api/task/tasks`：**我的未完成项目任务**（spec §3 D7）。
    *
-   * `userId` 只从凭据记录里取（客户端传不进来，见 `parsePmsTodoPayload` 的注释）——这是
+   * `userId` 只从 mint 响应里取（客户端传不进来，见 `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);
+      const session = await this.authorize();
+      return await this.deps.pms.myTasks(session.token, session.userId, opts);
     });
   }
   /**
@@ -6116,132 +6091,203 @@ var PmsTodoStore = class {
    * UI 按 §3 D7 提示「请到 PMS 操作」——**不是**重新登录。
    */
   async completeTask(input) {
-    const token = await this.authorize();
-    return await this.deps.pms.completeTask(token, input.id);
+    const session = await this.authorize();
+    return await this.deps.pms.completeTask(session.token, input.id);
   }
   /**
-   * 取一个能用的 access token（凭证获取的唯一入口，spec §3 D3 说 v2 只替换这里）。
+   * 取一个能用的 PMS JWT（凭据获取的**唯一入口**，spec §3 D10）。
    *
    * 顺序是刻意的：
-   *  1. 内存里有未过期的 access token → 直接用（零网络请求）；
-   *  2. 过期了 → 先试 `refresh(refreshToken)`（§D2：refresh 有效就完全不必打扰用户）；
-   *     refresh 成功会**顺手**把新的 access / refresh token 写回内存（原来是持久化的会话则一并落盘）；
-   *  3. refresh 失败（401 / 记录里根本没有 refresh token）→ `UNAUTHORIZED`，UI 要求重新输入。
+   *  1. 内存里有一张「剩余寿命 ≥ 50%」的令牌 → 直接用（零网络请求）；
+   *  2. 否则：解析网关会话 → 从分配清单里取 `slug='pms'` 那条（D9）→ 签一张 120 秒断言 →
+   *     打分配的 mint 端点换一张 10 小时 JWT → 存回内存（{@link PmsTodoStore.mint}）。
    *
-   * ⚠️ 这里**没有**「拿存下来的密码重新登录」这一支，而且是刻意的：§7 要求凭据失效时
-   * **不自动重试**——用存下来的密码自动重登 = 每次 token 过期都自动替用户登一次，密码一旦改成
-   * 别的，就会变成一条稳定的「定时用错密码打 PMS」的流水，直到账号被锁。密码只在用户**明确**
-   * 提交一次 `login` 时才用（那时它也确实是用户刚输入的）。
+   * ⚠️ **断言绝不缓存**：它只有 120 秒、且 PMS 侧拿 `jti` 做一次性防重放，缓存下来只会是一张废纸。
+   * ⚠️ 这里**没有**「拿存下来的账号密码重新登一次」这一支，而且是结构上没有：账号密码通道已删
+   * （spec §3 D3），本文件里也搜不到任何密码字段（§7 的验收项）。
    */
   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;
+    const cached = this.session;
+    if (cached !== void 0 && this.reusable(cached)) return cached;
+    const cookie = await this.sessionCookie();
+    const gateway = this.gatewayPort();
+    const assignment = await this.ensureAssignment(gateway, cookie);
+    return await this.mint(gateway, cookie, assignment);
   }
   /**
-   * 状态投影（不读盘、不发网络）。
+   * 这张令牌还能不能接着用（spec §4.5：剩余寿命 ≥ 50% 才复用）。
    *
-   * `expiresAt` **只报还没过期的那个时刻**：记录里那份可能是上一次会话留下的（进程重启后内存里
-   * 没有 access token，只有磁盘上的旧 `expiresAt`），把它照实报出去，界面就会显示一个已经过去的
-   * 「有效期至」，看着像还能用。过期了就不写这个键——refresh 会顺手把它换成新的。
+   * 判据与 `hiwork-capabilities/src/connectors/assignments.ts` 的 `isCredentialReusable` 同口径：
+   * 分母是**这张令牌自己的寿命**（`expiresAt - issuedAt`），不是某个写死的 10 小时——服务端将来
+   * 改短有效期，复用口径跟着它走。
    */
-  statusOf(record) {
+  reusable(session) {
     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() }
-    };
+    if (now >= session.expiresAt) return false;
+    const lifetime = session.expiresAt - session.issuedAt;
+    if (lifetime <= 0) return false;
+    return session.expiresAt - now >= lifetime * PMS_TODO_REUSE_MIN_REMAINING_RATIO;
+  }
+  /** 网关会话 cookie；缺失即 `UNAUTHORIZED`（动作在 HiWork：重新登录客户端）。 */
+  async sessionCookie() {
+    const cookie = await this.deps.resolveSession();
+    if (cookie === void 0 || cookie === "") {
+      this.fail("gateway-signed-out");
+      throw new PmsTodoError("UNAUTHORIZED", PMS_TODO_UNAUTHORIZED_MESSAGE);
+    }
+    return cookie;
+  }
+  /** 当前 baseURL 对应的网关客户端；没配置 baseURL 时同样是「去 HiWork 登录」这一类动作。 */
+  gatewayPort() {
+    const gateway = this.deps.gateway();
+    if (gateway === void 0) {
+      this.fail("gateway-signed-out");
+      throw new PmsTodoError("UNAUTHORIZED", PMS_TODO_UNAUTHORIZED_MESSAGE);
+    }
+    return gateway;
   }
   /**
-   * 当前凭据记录：内存优先，首次调用时从 credentials 服务读一次。
+   * 取出这条客户端**被分配**的 `pms` 服务（spec §3 D9）。
+   *
+   * 匹配依据只有 slug（逐字等于 {@link PMS_ASSIGNMENT_SLUG}）：清单里还有 visio-mcp 之类的分配，
+   * 「取第一条断言分配」在分配多起来之后会随机串台。**不看 `auth.kind`**：那是服务端演进的开放
+   * 集合，我们只认自己写死的 slug（D9 的原文就是「唯一匹配依据」）。
    *
-   * 「读一次就记住 `loaded`」是有意的：凭据的写入方只有本类（`login` / `logout` / refresh 回写），
-   * 因此在同一进程里，读盘只需要一次。跨进程变更（别的进程写了同一个 ref）本就不可观测，
-   * 硬要每次重新读只会让「不 remember 的登录」被磁盘上的旧记录当场覆盖。
+   * 没有这条分配 → `NOT_CONFIGURED`：UI 提示「找管理员」，**不给任何手工配置入口**（spec §6）。
    */
-  async currentRecord() {
-    if (this.loaded) return this.record;
-    this.loaded = true;
+  async ensureAssignment(gateway, cookie) {
+    const cached = this.assignment;
+    if (cached !== void 0) return cached;
+    let view;
     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;
+      view = await gateway.getMyMcpAssignments(cookie);
     } catch (error) {
-      this.deps.log?.(`hiwork-core: PMS \u51ED\u636E\u8BFB\u53D6\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
-      return void 0;
+      throw this.gatewayFailure(error);
+    }
+    const list = Array.isArray(view?.assignments) ? view.assignments : [];
+    for (const item of list) {
+      if (item?.slug !== PMS_ASSIGNMENT_SLUG) continue;
+      const assignmentId = textOf2(item.assignmentId);
+      if (assignmentId === void 0) continue;
+      const assignment = { assignmentId };
+      this.assignment = assignment;
+      this.reason = void 0;
+      return assignment;
     }
+    this.fail("no-assignment");
+    throw new PmsTodoError("NOT_CONFIGURED", PMS_TODO_NOT_CONFIGURED_MESSAGE);
   }
   /**
-   * 落盘（**唯一**写 credentials 的地方，只在 remember 为真时被调用）。
+   * 签一张断言（120 秒、一次性），并取出它的 `mintUrl`。
    *
-   * 失败**不**把一次成功的登录判为失败：会话已经拿到了，内存里照常可用；密码存不下的后果只是
-   * 「重启后要重新输入」。反过来把登录判为失败会让用户以为密码错了。
+   * `mintUrl` 由**门票**给（`auth.mintUrl` 的权威副本在网关侧），本层不猜也不改写它。
    */
-  async persist(record) {
+  async assertionTicket(gateway, cookie, assignment) {
+    let ticket;
     try {
-      await this.deps.credentials.set(PMS_CREDENTIALS_REF, serializeCredentialsRecord(record));
-      this.persisted = true;
+      ticket = await gateway.issueMyMcpAssertion(cookie, assignment.assignmentId);
     } catch (error) {
-      this.deps.log?.(`hiwork-core: PMS \u51ED\u636E\u843D\u76D8\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+      throw this.gatewayFailure(error);
     }
+    const assertion = textOf2(ticket?.assertion);
+    const mintUrl = textOf2(ticket?.mintUrl);
+    if (assertion === void 0 || mintUrl === void 0) {
+      this.deps.log?.("hiwork-core: PMS \u53D6\u65AD\u8A00\u6536\u5230\u65E0\u6548\u54CD\u5E94\uFF08\u7F3A assertion / mintUrl\uFF09");
+      this.fail("unavailable");
+      throw new PmsTodoError("INTERNAL", PMS_TODO_GENERIC_FAILURE_MESSAGE);
+    }
+    return { assertion, mintUrl };
   }
   /**
-   * 抹掉磁盘上的记录（logout / 不记住的登录）。
+   * 断言 → 令牌（spec §4.1b 的客户端侧），失败语义按 §6 / plan 全局约束 2 分两类：
+   *
+   *  - **被拒（401 / 403）→ 不重试**：断言过期 / `aud` 不符 / 签名不过 / 工号在 PMS 不存在，
+   *    四种原因在 PMS 侧都是同一个 403（防账号探测），重发只会连打；动作是「重新登录 HiWork」。
+   *  - **网络 / 5xx → 换一张新断言重试一次**：断言可能是在途耗掉的（120 秒的门票），而同一张断言
+   *    是一次性的（`jti` 防重放），所以重试必须重新签一张。仍失败 → `UPSTREAM_UNAVAILABLE`。
    *
-   * 先 `resolve` 一次再 `unset`：没有记录时一次写都不做（测试与磁盘都清清爽爽），有记录时
-   * **必须**清掉——否则一条旧的 account+refresh token 会在下次启动时被当成「这个人配置过凭据」，
-   * 用户明明刚选了「不记住」却在重启后仍是登录态。
+   * 日志只记 assignmentId 与事件（**不记断言、不记令牌**，spec §7）。
    */
-  async forgetStored() {
+  async mint(gateway, cookie, assignment) {
+    const deviceRef = await this.deviceRef();
+    let attempt = 0;
+    while (attempt < 2) {
+      attempt += 1;
+      const ticket = await this.assertionTicket(gateway, cookie, assignment);
+      try {
+        const session = sessionOf(
+          await this.deps.pms.exchangeAssertion(ticket.mintUrl, ticket.assertion, deviceRef),
+          this.now()
+        );
+        this.session = session;
+        this.reason = void 0;
+        return session;
+      } catch (error) {
+        if (error instanceof PmsError && error.code === "UNAUTHORIZED") {
+          this.deps.log?.(`hiwork-core: PMS \u6362\u4EE4\u724C\u88AB\u62D2\uFF08\u5206\u914D ${assignment.assignmentId}\uFF09`);
+          this.fail("gateway-signed-out");
+          throw new PmsTodoError("UNAUTHORIZED", PMS_TODO_UNAUTHORIZED_MESSAGE);
+        }
+        if (error instanceof PmsError && error.code === "UPSTREAM_UNAVAILABLE" && attempt === 1) {
+          this.deps.log?.(`hiwork-core: PMS \u6362\u4EE4\u724C\u5931\u8D25\uFF08\u5206\u914D ${assignment.assignmentId}\uFF09\uFF0C\u6362\u4E00\u5F20\u65B0\u65AD\u8A00\u91CD\u8BD5\u4E00\u6B21`);
+          continue;
+        }
+        this.fail("unavailable");
+        throw error instanceof PmsError ? error : new PmsTodoError("INTERNAL", PMS_TODO_GENERIC_FAILURE_MESSAGE);
+      }
+    }
+    this.fail("unavailable");
+    throw new PmsTodoError("UPSTREAM_UNAVAILABLE", PMS_TODO_GENERIC_FAILURE_MESSAGE);
+  }
+  /** 设备标识（只进 PMS 侧审计、不参与鉴权）：解析失败留空，不拦登录。 */
+  async deviceRef() {
     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);
+      return await this.deps.resolveDeviceId();
     } catch (error) {
-      this.deps.log?.(`hiwork-core: PMS \u51ED\u636E\u6E05\u9664\u5931\u8D25\uFF08${errorName(error)}\uFF09`);
+      this.deps.log?.(`hiwork-core: \u8BBE\u5907\u6807\u8BC6\u89E3\u6790\u5931\u8D25\uFF08${errorName(error)}\uFF09\uFF0CdeviceRef \u7559\u7A7A`);
+      return "";
+    }
+  }
+  /**
+   * 网关异常 → 本频道的稳定错误（spec §3 D8）。
+   *
+   * 关键的分法：**会话失效**与**分配被撤销/停用**要分开。前者是用户自己的动作（重新登录 HiWork），
+   * 后者是管理员那边的动作（重新分配）——归到同一句话，用户就会对着一个自己修不了的问题反复重试。
+   */
+  gatewayFailure(error) {
+    this.deps.log?.(`hiwork-core: PMS \u7F51\u5173\u8C03\u7528\u5931\u8D25\uFF08${gatewayCodeOf(error)}\uFF09`);
+    if (error instanceof GatewayError) {
+      if (error.code === "SESSION_EXPIRED") {
+        this.fail("gateway-signed-out");
+        return new PmsTodoError("UNAUTHORIZED", PMS_TODO_UNAUTHORIZED_MESSAGE);
+      }
+      if (error.code === "MCP_ASSIGNMENT_GONE" || error.code === "MCP_NOT_DELIVERABLE") {
+        this.assignment = void 0;
+        this.fail("no-assignment");
+        return new PmsTodoError("NOT_CONFIGURED", PMS_TODO_NOT_CONFIGURED_MESSAGE);
+      }
     }
+    this.fail("unavailable");
+    return new PmsTodoError("UPSTREAM_UNAVAILABLE", PMS_TODO_GENERIC_FAILURE_MESSAGE);
+  }
+  /** 记下「为什么还没就绪」（只影响 `status` 的 `reason`，不影响错误码）。 */
+  fail(reason) {
+    this.reason = reason;
   }
   /**
-   * 并发合并：同一世代 + 同一端点的在飞请求共用一次调用与同一个返回值。
+   * 并发合并：同一端点的在飞请求共用一次调用与同一个返回值（面板挂载与手动刷新常常同拍）。
    *
-   * 世代判据与 `src/client/managed-workbench.ts` 的 `dedupe` 同形：`login` / `logout` 之后
-   * 账上那条属于**上一个人**，谁都不许复用（复用等于把上一个人的待办显示给新账号）。
+   * v1 还带一个「世代号」（`login` / `logout` 之后账上那条属于上一个人）；现在**身份只有一个来源**
+   * （网关会话），进程内没有换人的入口，所以按端点名合并即可。换账号的清理由客户端半边的
+   * `clear()`（镜像）与会话本身负责。
    */
   async dedupe(key, task) {
     const inFlight = this.inFlight;
-    if (inFlight !== void 0 && inFlight.generation === this.generation && inFlight.key === key) {
+    if (inFlight !== void 0 && inFlight.key === key) {
       return await inFlight.task;
     }
-    const generation = this.generation;
     const promise = task();
-    this.inFlight = { generation, key, task: promise };
+    this.inFlight = { key, task: promise };
     try {
       return await promise;
     } finally {
@@ -6259,10 +6305,6 @@ async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, signal)
     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":
@@ -7194,7 +7236,12 @@ function apply(ctx, config) {
     };
   }, "hiwork-core: workbench warmup");
   const pmsTodoDeps = {
-    credentials: ports.credentials,
+    resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
+    gateway: () => {
+      const baseURL = current().baseURL;
+      return baseURL === void 0 || baseURL === "" ? void 0 : gatewayFor(baseURL);
+    },
+    resolveDeviceId: async () => (await resolveDeviceInfo(ports.credentials)).deviceId,
     pms: new PmsClient({ log: (message) => {
       ctx.logger.warn(message);
     } }),
@@ -7207,6 +7254,9 @@ function apply(ctx, config) {
     () => registerPmsTodoRpc({ connection, logger: ctx.logger }, pmsTodoDeps, pmsTodo),
     "hiwork-core: pms todo rpc"
   );
+  void clearLegacyCredentials(ports.credentials, (message) => {
+    ctx.logger.warn(message);
+  });
   ctx.effect(() => provideOfficeCredentials(ctx, {
     resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
     gateway: () => {