hiwork-core 0.0.22 → 0.0.24

package/lib/pms-todo-bridge.js

@@ -1,70 +1,86 @@
 /**
- * `/hiwork-pms-todo` loopback RPC 的 Host 实现：PMS 个人待办的取数 + 勾完成/取消 + 凭据托管。
+ * `/hiwork-pms-todo` loopback RPC 的 Host 实现：PMS 个人待办的取数 + 勾完成，凭据链是
+ * **网关身份断言 → PMS 换 10 小时 JWT**（用户零输入）。
  *
- * 契约见 spec `docs/superpowers/specs/2026-09-17-pms-todo-integration-design.md`：
- *  - §3 D2 —— 认证 v1 是**凭据托管**：用户在 HiWork 里填一次 PMS 账号密码，Host 用它换 PMS JWT
- *    （10 小时），并把 refresh token（7 天）一并存下；凭据获取的全部逻辑收敛在本文件的
- *    {@link PmsTodoStore.authorize} 里，v2 换 IAM SSO 时只替换它，UI 与 RPC 契约不动（§3 D3）；
- *  - §3 D4 / §4.2 —— 待办的三条现有接口（today / statistics / setStatus），未知枚举原样透传；
- *  - §3 D7 —— **我的任务**：`todo_task` 之外的未完成项目任务（`GET /api/task/tasks`，`myTasks`）+ 完成任务
- *    （`PUT /api/task/tasks/{id}/status`，`completeTask`）。为什么必须有它：PMS 只在**任务创建那一刻**
- *    生成待办，转派 / 走 SQL 建的历史任务没有待办——只读待办会让这些任务在面板上消失；
- *  - §3 D6 —— **JWT、账号密码一律只存在于 Host 半边**：客户端只发端点调用，c1 拿不到任何凭据；
- *  - §4.1 —— 八个端点（v1 的六个 + §3 D7 的两个）、`{ok,value}` / `{ok,error:{code,message}}` 信封、
- *    **永不抛**、六个稳定错误码（多了 `FORBIDDEN`，见 §3 D7 的权限提示要求）；
- *  - §4.4 —— 凭据 ref `HIWORK_PMS_CREDENTIALS`，**只在 `remember` 为真时持久化**；
- *  - §7 —— 凭据失效走 `UNAUTHORIZED` 且**不自动重试**（避免用错密码连续触发 PMS 失败锁定）。
+ * 契约见 spec `docs/superpowers/specs/2026-09-21-pms-zero-input-login-design.md`（本文件取代
+ * `2026-09-17-pms-todo-integration-design.md` 的 §3 D2 / §3 D3 与 §4.4 口径）：
+ *  - §3 D1 —— 桌面端不再是「填一次 PMS 账号密码」，而是从网关分配清单里取出 `pms` 那条，
+ *    签一张 **120 秒**身份断言，打分配的 mint 端点换一张 **10 小时** PMS JWT；
+ *  - §3 D9 —— 分配**按 slug 精确匹配 `pms`** 取出（清单里可能还有 visio-mcp 等其它服务），
+ *    绝不取「第一条断言分配」：顺序必须来自我们写死的常量，不来自清单返回顺序；
+ *  - §3 D4 / §4.5 —— 令牌**完全不落盘**（只在进程内存里活，重启后静默重换）；账号密码通道整体
+ *    删除（`login` / `logout` 端点、凭据记录、凭据读写路径一律不再有）；首启把 v1 落在
+ *    credentials 里的明文密码抹掉一次（{@link clearLegacyCredentials}）；
+ *  - §3 D8 —— 失败语义分两类：网关里没有 `pms` 分配 → `NOT_CONFIGURED`（找管理员）；网关会话失效 /
+ *    mint 被拒 → `UNAUTHORIZED`（动作在 HiWork，不在 PMS）；PMS 或网关不可达 → `UPSTREAM_UNAVAILABLE`；
+ *  - §4.4 —— `status` 的字段名沿用 v1（把跨仓扰动压到最小）但语义重定义：`configured` = 网关里存在
+ *    `slug='pms'` 的分配，`loggedIn` = 手上有一张未过期的 JWT；新增 `reason`（`no-assignment` /
+ *    `gateway-signed-out` / `unavailable`）供面板选文案；
+ *  - §4.3 —— 端点白名单**六项**（v1 的八项减去 `login` / `logout`，顺序即字面量）；
+ *  - §6 与 plan 全局约束 2 —— mint 的 **4xx 不自动重试**（403 是「断言无效」，重打只会连打）；
+ *    网络 / 5xx 才**换一张新断言**重试一次（断言是一次性的，重发同一张只会换来第二个 403）；
+ *  - §3 D7 —— `myTasks` 的 `assigneeId` 取 mint 响应里的 `userId`（**不由客户端传**，也不解析 JWT）；
+ *  - §7 —— 断言与令牌**不进日志、不进任何 RPC 响应**：日志里只有事件、状态码与 assignmentId。
  *
  * 与 `/hiwork-workbench`、`/hiwork-managed-*` 那几条链的关系：信封、端点白名单、错误码收敛、
- * 「永不抛」的形状沿用同一副骨架（`src/workbench-bridge.ts`），但这一条**多了一个别人没有的
- * 东西**——凭据生命周期（存什么、什么时候写盘、什么时候 refresh、什么时候要求人重新输入）。
- * 那也是本文件唯一复杂的部分，其余都是投影与校验。
- *
- * 三条铁律：
- *  - **token 只在 Host 内存（+ 可选的加密凭据记录）**：本文件没有任何返回值带 token，日志里也
- *    不许出现 token / 密码 / refresh token（§7、§8 第 8 条由测试把守）；
- *  - **不自动重试登录**：见 {@link PmsTodoStore.login} 的注释——用错密码连打两次就可能触发 PMS 的
- *    失败锁定，而「自动重试」正是最常见的那种不小心连打；
- *  - **失败不清空已有会话**：refresh 失败只把这一次调用判为 `UNAUTHORIZED`，不把凭据记录删掉
- *    （用户可能是临时改密 / 网络抽风；删掉记录等于把「重新输入」变成「重新配置」）。
+ * 「永不抛」的形状沿用同一副骨架（`src/workbench-bridge.ts`），差别是本条链多了一段凭据获取
+ * （分配 → 断言 → 令牌）——它收敛在 {@link PmsTodoStore.authorize} **一处**，RPC 面与 UI 不感知
+ * 凭据形态（§3 D10）。
  *
  * 本模块不 import cordis 运行时，只依赖结构化的 {@link PmsTodoRpcDeps} 端口，便于单测直接伪造。
  */
-import { PmsError, PMS_FORBIDDEN_MESSAGE, PMS_GENERIC_FAILURE_MESSAGE, PMS_UNAUTHORIZED_MESSAGE, } from "./pms-client.js";
+import { GatewayError, } from "./ai-router-client.js";
+import { PmsError, PMS_FORBIDDEN_MESSAGE, PMS_GENERIC_FAILURE_MESSAGE, } from "./pms-client.js";
 /** RPC 频道；必须与 client 半边 `src/client/pms-todo.ts` 的 `PMS_TODO_CHANNEL` 一致（由测试锁定）。 */
 export const PMS_TODO_RPC_CHANNEL = '/hiwork-pms-todo';
 /**
- * 端点白名单（**顺序即字面量**，由测试钉死；v1 的六个 + §3 D7 追加的两个 = 八个）。
+ * 端点白名单（**顺序即字面量**，由测试钉死；v1 的八项减去 `login` / `logout` = 六项）。
+ *
+ * `status` 是能力状态，`today` / `statistics` / `setStatus` 是待办数据，`myTasks` / `completeTask`
+ * 是**项目任务**（§3 D7：待办之外的未完成任务，以及完成它）。
  *
- * `status` / `login` / `logout` 是凭据生命周期，`today` / `statistics` / `setStatus` 是待办数据，
- * `myTasks` / `completeTask` 是**项目任务**（§3 D7：待办之外的未完成任务，以及完成它）。
+ * ⚠️ 六项与 v1 的八项**刻意不同**——那是版本闸口：老 client 拿八项去比对新 Host 会对不上，于是走
+ * 「请升级 HiWork 客户端」的降级，而不是带着一个已经删掉的账号密码表单硬跑（spec §4.3）。
  * 白名单是客户端可用的**能力边界**：v1 不做新建 / 编辑 / 删除待办（§5.3），所以这里也没有
  * `create` / `update` / `remove`——别为了「一次写完」提前登记一个没有实现的承诺。
- *
- * ⚠️ 两个新端点是**追加**在末尾的：client 半边（`src/client/pms-todo.ts`）的常量与这里逐字相等，
- * 老 client 拿一个只有六项的清单去比对新 Host 的八项会不等——那是**有意的**（版本闸口），
- * 消费方按可选成员降级，见 `PmsTodoFace.myTasks` 的注释。
  */
 export const PMS_TODO_RPC_ENDPOINTS = [
-    'status', 'login', 'logout', 'today', 'statistics', 'setStatus', 'myTasks', 'completeTask',
+    'status', 'today', 'statistics', 'setStatus', 'myTasks', 'completeTask',
 ];
 /**
- * 凭据 ref（spec §4.4，credentials 服务，加密落盘）。
- *
- * 值是一段 JSON：`{username, password?, refreshToken?, expiresAt?}`。**只有 `remember` 为真时
- * 才写这个 ref**；不记住时凭据只活在进程内存里。别把它挪进 settings —— settings 是明文 YAML，
- * 而且会出现在设置页快照里（§7 第一条）。
+ * 分配匹配的**唯一**依据（spec §3 D9）：`GET /api/me/mcp-assignments` 里 `slug` 逐字等于它的那条。
+ * 它就是断言的 `aud`（网关侧注释：`aud` = 目标服务的 slug），也是网关连接器的 id。
+ */
+export const PMS_ASSIGNMENT_SLUG = 'pms';
+/**
+ * v1 遗留的凭据 ref（spec §4.5 / D4）。**本文件不再读写它**——值只被
+ * {@link clearLegacyCredentials} 用来做首启的一次性清理；随后它就从配置面消失了。
  */
 export const PMS_CREDENTIALS_REF = 'HIWORK_PMS_CREDENTIALS';
 /**
- * 凭据记录里 `expiresAt` 缺失时的兜底有效期：10 小时（与 `src/pms-client.ts` 同值）。
- * 正常路径一律写服务端给的 `expiresIn` 算出来的绝对时刻。
+ * 令牌的**兜底**有效期：10 小时（= PMS `jwt.expiration=36000000`）。
+ * 正常路径一律用 mint 响应给的 `expiresAt`；只有它解析不了时才用它兜底（见 `sessionOf`）。
  */
 export const PMS_TODO_ACCESS_TOKEN_TTL_MS = 10 * 60 * 60 * 1000;
-/** 从未配置凭据的文案（UI 据此渲染引导卡片，不做静默失败）。 */
-export const PMS_TODO_NOT_CONFIGURED_MESSAGE = '尚未配置 PMS 账号，请先输入账号密码';
-/** 凭据失效的文案（UI 据此要求重新输入，且保留上次数据可见）。 */
-export const PMS_TODO_UNAUTHORIZED_MESSAGE = PMS_UNAUTHORIZED_MESSAGE;
+/**
+ * 令牌复用口径（spec §4.5）：剩余寿命不低于原寿命这个比例时复用，否则重换。
+ *
+ * 值与 `hiwork-capabilities/src/connectors/assignments.ts` 的 `REUSE_MIN_REMAINING_RATIO` 相同
+ * ——那是受管连接器的同一条通道，两处口径必须一致（跨仓不能 import，所以值在这里复写一份并说明）。
+ * 一半是权衡：太低（5%）意味着下一次取数很可能正好撞在过期瞬间；太高（95%）等于每次取数都白换一次。
+ */
+export const PMS_TODO_REUSE_MIN_REMAINING_RATIO = 0.5;
+/**
+ * 网关里没有 `pms` 分配时的文案（spec §6 第一行：纯提示「联系管理员」，**不给任何手工入口**）。
+ */
+export const PMS_TODO_NOT_CONFIGURED_MESSAGE = '管理员尚未把 PMS 接入这台客户端，请联系管理员';
+/**
+ * 网关会话失效 / mint 被拒（403）的文案：动作在 **HiWork**，不是在 PMS（spec §3 D8）。
+ *
+ * ⚠️ 不再复用 `pms-client.ts` 的 `PMS_UNAUTHORIZED_MESSAGE`：那句还写着「请重新输入 PMS 账号密码」，
+ * 而密码通道正是本次要拆掉的东西——把它留给 PMS 网页端，桌面端一律引导重新登录 HiWork 客户端。
+ */
+export const PMS_TODO_UNAUTHORIZED_MESSAGE = '登录已过期，请重新登录 HiWork 客户端';
 /**
  * 权限不足的文案（spec §3 D7 逐字要求；`PmsError` 的 `FORBIDDEN` 原样抬到 RPC 面）。
  * UI 必须明说它，而不是静默失败或回滚得莫名其妙。
@@ -87,10 +103,29 @@ export class PmsTodoRequestError extends Error {
         this.name = 'PmsTodoRequestError';
     }
 }
+/**
+ * 本频道内部的凭据 / 会话错误（`NOT_CONFIGURED` / `UNAUTHORIZED` / `UPSTREAM_UNAVAILABLE`）。
+ *
+ * 用一个枚举样式的小类比裸字符串好：`PmsError` 只覆盖「上游说了什么」，而「没有 pms 分配」/
+ * 「没有网关会话」/「网关地址都没配」是 Host 自己的结论，两者混在一个类型里会让 `pmsTodoErrorOf`
+ * 不得不用字符串猜。
+ */
+export class PmsTodoError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'PmsTodoError';
+    }
+}
 /** 是否为白名单端点。 */
 export function isPmsTodoRpcEndpoint(endpoint) {
     return PMS_TODO_RPC_ENDPOINTS.includes(endpoint);
 }
+/** 非空字符串或 undefined（一个字段坏了不该让整条链路失败）。 */
+function textOf(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
+}
 /** 入参必须是对象（缺省 = 空对象）。风格照 `parseWorkbenchPayload`。 */
 function asRecord(endpoint, raw) {
     if (raw === undefined || raw === null)
@@ -120,32 +155,16 @@ function rejectUnknownKeys(endpoint, record, allowed) {
  * 而 `PENDING` / `COMPLETED` 是 PMS 侧唯一接受的两个值（其余的传过去只会得到一次业务失败）。
  * `completeTask` 的 `id` 同理（会被拼进**路径**，更要先收敛成正整数）。
  *
- * `myTasks` **不接受任何入参**（尤其不接受 `userId`）：查询的「谁」必须由 Host 从凭据记录里取，
+ * `myTasks` **不接受任何入参**（尤其不接受 `userId`）：查询的「谁」必须由 Host 从 mint 响应里取，
  * 否则客户端就能拿任意的 assigneeId 去查别人的任务——那正是 `PMS_TODO_RPC_ENDPOINTS` 白名单
  * 想守住的能力边界（§3 D6 / §3 D7）。
  */
 export 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 登录请求缺少 username。');
-        // 密码**不 trim**：前后空格可能是密码的一部分，改了就成了「密码错误」。
-        const password = record['password'];
-        if (typeof password !== 'string' || password === '') {
-            throw new PmsTodoRequestError('PMS 登录请求缺少 password。');
-        }
-        const remember = record['remember'];
-        if (remember !== undefined && typeof remember !== 'boolean') {
-            throw new PmsTodoRequestError('PMS 登录请求的 remember 必须是布尔值。');
-        }
-        return { endpoint, username, password, remember: remember === true };
-    }
     if (endpoint === 'completeTask') {
         rejectUnknownKeys(endpoint, record, ['id']);
         const id = record['id'];
@@ -181,7 +200,7 @@ export function pmsTodoErrorOf(error) {
         }
         if (error.code === 'FORBIDDEN') {
             // 权限不足是**自己的一个码**（不是上游故障、更不是凭据问题）：UI 按 §3 D7 给出
-            // 「在 HiWork 里没有完成任务的权限，请到 PMS 操作」，而不是让用户去改密码或重试。
+            // 「在 HiWork 里没有完成任务的权限，请到 PMS 操作」，而不是让用户重新登录或重试。
             return { code: 'FORBIDDEN', message: PMS_TODO_FORBIDDEN_MESSAGE, details: {} };
         }
         return { code: 'UPSTREAM_UNAVAILABLE', message: displayPmsTodoMessage(error.code, error.message), details: {} };
@@ -212,107 +231,72 @@ export function displayPmsTodoMessage(code, message) {
         return PMS_TODO_MESSAGE_FALLBACK[code] ?? PMS_TODO_GENERIC_FAILURE_MESSAGE;
     return text;
 }
-/**
- * 本频道内部的凭据/会话错误（`NOT_CONFIGURED` / `UNAUTHORIZED`）。
- *
- * 用一个枚举样式的小类比裸字符串好：`PmsError` 只覆盖「上游说了什么」，而「本地判断出来
- * 没有凭据 / 没有 refresh token」是 Host 自己的结论，两者混在一个类型里会让 `pmsTodoErrorOf`
- * 不得不用字符串猜。
- */
-export class PmsTodoError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'PmsTodoError';
-    }
-}
 /** 任意异常的名字（日志只记类型，不记 message）。 */
 function errorName(error) {
     return error instanceof Error ? error.name : typeof error;
 }
+/** 网关异常的稳定 code（日志用；非 `GatewayError` 时退化成异常名）。 */
+function gatewayCodeOf(error) {
+    return error instanceof GatewayError ? error.code : errorName(error);
+}
 // ---------------------------------------------------------------------------
-// 凭据记录解析 / 序列化
+// 首启清理（v1 遗留凭据）
 // ---------------------------------------------------------------------------
 /**
- * 解析凭据记录。
+ * 首启清理：抹掉 v1 落在 credentials 里的**明文 PMS 账号密码**（spec §3 D4 / §4.5）。
+ *
+ * 新链路没有任何凭据要落盘，所以这条记录之后就不该再存在——**幂等**（`resolve` 非空才 `unset`，
+ * 没有记录时一次写都不做）、**失败只记日志不抛**（清理失败绝不该拦住插件启动）。
+ * 调用方（`src/index.ts` 的 apply）只调一次；进程重启后再调也只会做一次没有记录的读。
  *
- * 记录是我们自己写的，但磁盘上的字节仍可能来自**旧版本的自己**，所以逐字段校验、
- * **未知字段忽略**（演进纪律），坏字段丢掉而不是让整条记录作废——一次 `format` 变更不该把用户
- * 变成「从未配置」。
+ * @param credentials - 凭据服务（只用到 `resolve` / `unset`）。
+ * @param log - Host 日志出口（只记事件与异常类型，不记 ref 里的值）。
  */
-export function parseCredentialsRecord(raw) {
-    let parsed;
+export async function clearLegacyCredentials(credentials, log) {
     try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
-        return undefined;
-    const record = parsed;
-    const username = typeof record['username'] === 'string' ? record['username'].trim() : '';
-    if (username === '')
-        return undefined;
-    const password = typeof record['password'] === 'string' && record['password'] !== '' ? record['password'] : undefined;
-    const refreshToken = typeof record['refreshToken'] === 'string' && record['refreshToken'] !== ''
-        ? record['refreshToken']
-        : undefined;
-    const expiresAt = typeof record['expiresAt'] === 'number' && Number.isFinite(record['expiresAt'])
-        ? record['expiresAt']
-        : undefined;
-    // `userId` 必须是**安全整数**：它会被拼进 query（`assigneeId`），形态不对就当没有这个字段
-    // ——`myTasks` 会据此引导用户重新登录一次，比拿一个脏 id 去查询好。
-    const userId = typeof record['userId'] === 'number' && Number.isSafeInteger(record['userId'])
-        ? record['userId']
-        : undefined;
-    return {
-        username,
-        ...(password === undefined ? {} : { password }),
-        ...(refreshToken === undefined ? {} : { refreshToken }),
-        ...(expiresAt === undefined ? {} : { expiresAt }),
-        ...(userId === undefined ? {} : { userId }),
-    };
-}
-/** 序列化凭据记录（**唯一**写盘路径）。缺字段不写键，避免把 `undefined` 变成 JSON 里的 `null`。 */
-export function serializeCredentialsRecord(record) {
-    return JSON.stringify({
-        username: record.username,
-        ...(record.password === undefined ? {} : { password: record.password }),
-        ...(record.refreshToken === undefined ? {} : { refreshToken: record.refreshToken }),
-        ...(record.expiresAt === undefined ? {} : { expiresAt: record.expiresAt }),
-        ...(record.userId === undefined ? {} : { userId: record.userId }),
-    });
+        const hit = await credentials.resolve(PMS_CREDENTIALS_REF);
+        if (hit === undefined || hit.value === '')
+            return;
+        await credentials.unset(PMS_CREDENTIALS_REF);
+        // 只记事件：磁盘上那份记录里有明文密码，任何值都不许进日志。
+        log?.('hiwork-core: 已清除 v1 遗留的 PMS 凭据记录');
+    }
+    catch (error) {
+        log?.(`hiwork-core: PMS 遗留凭据清除失败（${errorName(error)}）`);
+    }
 }
 // ---------------------------------------------------------------------------
 // 会话与取数
 // ---------------------------------------------------------------------------
+/** 一次 mint 结果的投影：把 ISO 串折成绝对时刻，并记下「什么时候换到的」。 */
+function sessionOf(result, now) {
+    const parsed = Date.parse(result.expiresAt);
+    return {
+        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,
+    };
+}
 /**
- * PMS 待办的状态仓库：持有凭据记录与 access token，按需续期，并暴露五个取数 / 命令动作
+ * PMS 待办的状态仓库：持有内存里的 PMS JWT，按分配 → 断言 → mint 拿令牌，并暴露五个取数 / 命令动作
  * （today / statistics / setStatus + §3 D7 的 myTasks / completeTask）。
  *
- * 一个刻意的分工：**凭据（账号密码 / refresh token）与 access token 只在本类里出现**。
- * 端点处理函数（{@link handlePmsTodoEndpoint}）只把返回值转发出去，因此「响应里没有 token」
- * 这件事是**结构上成立**的，而不是靠每一处返回值自觉。
+ * 一个刻意的分工：**断言与令牌只在本类里出现**。端点处理函数（{@link handlePmsTodoEndpoint}）
+ * 只把返回值转发出去，因此「响应里没有 token」这件事是**结构上成立**的，而不是靠每一处返回值自觉。
  */
 export class PmsTodoStore {
     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;
     constructor(deps) {
         this.deps = deps;
@@ -320,76 +304,54 @@ export class PmsTodoStore {
     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 === undefined ? {} : { refreshToken: tokens.refreshToken }),
-            expiresAt: tokens.expiresAt,
-            // §3 D7：登录响应里的 `userId` 必须**在这里**捕获——「我的任务」要用它当 `assigneeId`，
-            // 而除了登录/刷新没有别的地方能拿到它（不猜、不按用户名反查）。
-            ...(tokens.userId === undefined ? {} : { 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);
+    async status() {
+        const session = this.session;
+        if (session !== undefined && this.now() < session.expiresAt) {
+            return {
+                configured: true,
+                loggedIn: true,
+                username: session.username,
+                expiresAt: new Date(session.expiresAt).toISOString(),
+                userId: session.userId,
+                ...(this.reason === undefined ? {} : { reason: this.reason }),
+            };
         }
-        else {
-            await this.forgetStored();
+        try {
+            const cookie = await this.sessionCookie();
+            const gateway = this.gatewayPort();
+            await this.ensureAssignment(gateway, cookie);
+            return { configured: true, loggedIn: false, ...(this.reason === undefined ? {} : { reason: this.reason }) };
+        }
+        catch {
+            // 原因已经由失败那一层记下（`fail`）：这里只把它投影出来，不重新判断一次。
+            return { configured: false, loggedIn: false, reason: this.reason ?? 'unavailable' };
         }
-        this.deps.log?.('hiwork-core: PMS 账号已登录（凭据只存于 Host）');
-        return this.statusOf(record);
-    }
-    /**
-     * 登出：清内存 + 清凭据记录（spec §4.1 的 `logout`）。
-     *
-     * 不清 PMS 侧的服务端会话：PMS 的 JWT 是无状态签发的（没有「撤销单个 token」的接口），
-     * 我们能做且该做的是**不再持有**它——删掉本地凭据后，下一次取数一定要求重新输入。
-     */
-    async logout() {
-        this.generation += 1;
-        this.record = undefined;
-        this.loaded = true;
-        this.persisted = false;
-        this.access = undefined;
-        await this.forgetStored();
-        this.deps.log?.('hiwork-core: PMS 凭据已清除');
-        return this.statusOf(undefined);
     }
     /** `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);
         });
     }
     /**
@@ -400,31 +362,21 @@ export class PmsTodoStore {
      * 的顺序处理」——那个语义 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 === undefined) {
-                // 只记事件（账号名都不记）：这是一次本地结论，用户重新登录就能拿到 userId。
-                this.deps.log?.('hiwork-core: PMS 凭据记录里没有 userId，我的任务需要重新登录一次');
-                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);
         });
     }
     /**
@@ -437,148 +389,219 @@ export class PmsTodoStore {
      * 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 !== undefined && this.now() < access.expiresAt)
-            return access.token;
-        const record = await this.currentRecord();
-        if (record === undefined) {
-            throw new PmsTodoError('NOT_CONFIGURED', PMS_TODO_NOT_CONFIGURED_MESSAGE);
-        }
-        const refreshToken = record.refreshToken;
-        if (refreshToken === undefined) {
-            throw new PmsTodoError('UNAUTHORIZED', PMS_TODO_UNAUTHORIZED_MESSAGE);
-        }
-        const tokens = await this.deps.pms.refresh(refreshToken);
-        // ⚠️ `userId` **不从刷新响应里取**：刷新换的是 token，不改变「我是谁」（§3 D7）。
-        // `...record` 用来把它（以及用户名 / 密码）原样带过去。
-        const next = {
-            ...record,
-            ...(tokens.refreshToken === undefined ? {} : { 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 !== undefined && 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 !== undefined && now < access.expiresAt;
-        const hasRefresh = record?.refreshToken !== undefined && record.refreshToken !== '';
-        const expiresAt = access?.expiresAt ?? record?.expiresAt;
-        const freshExpiry = expiresAt !== undefined && expiresAt > now ? expiresAt : undefined;
-        return {
-            configured: record !== undefined,
-            loggedIn: hasAccess || hasRefresh,
-            ...(record === undefined ? {} : { username: record.username }),
-            ...(freshExpiry === undefined ? {} : { 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 === undefined || 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 === undefined) {
+            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 !== undefined)
+            return cached;
+        let view;
         try {
-            const hit = await this.deps.credentials.resolve(PMS_CREDENTIALS_REF);
-            if (hit === undefined || hit.value === '')
-                return undefined;
-            const record = parseCredentialsRecord(hit.value);
-            // 从记录里恢复 = 这是一个 remember 过的会话：refresh 的新 token 要跟着回写。
-            this.record = record;
-            this.persisted = record !== undefined;
-            return record;
+            view = await gateway.getMyMcpAssignments(cookie);
         }
         catch (error) {
-            this.deps.log?.(`hiwork-core: PMS 凭据读取失败（${errorName(error)}）`);
-            return undefined;
+            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 = textOf(item.assignmentId);
+            if (assignmentId === undefined)
+                continue;
+            const assignment = { assignmentId };
+            this.assignment = assignment;
+            this.reason = undefined;
+            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 凭据落盘失败（${errorName(error)}）`);
+            throw this.gatewayFailure(error);
         }
+        const assertion = textOf(ticket?.assertion);
+        const mintUrl = textOf(ticket?.mintUrl);
+        if (assertion === undefined || mintUrl === undefined) {
+            // 形状不符的票据不值得当成成功（与 `managed-mcp.ts` 同款判据）。
+            this.deps.log?.('hiwork-core: PMS 取断言收到无效响应（缺 assertion / mintUrl）');
+            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 = undefined;
+                return session;
+            }
+            catch (error) {
+                if (error instanceof PmsError && error.code === 'UNAUTHORIZED') {
+                    this.deps.log?.(`hiwork-core: PMS 换令牌被拒（分配 ${assignment.assignmentId}）`);
+                    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 换令牌失败（分配 ${assignment.assignmentId}），换一张新断言重试一次`);
+                    continue;
+                }
+                // 重试后仍失败 / 非预期异常：收敛成稳定错误，原始 message（可能含内网地址）不外泄。
+                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 === undefined || hit.value === '')
-                return;
-            await this.deps.credentials.unset(PMS_CREDENTIALS_REF);
+            return await this.deps.resolveDeviceId();
         }
         catch (error) {
-            this.deps.log?.(`hiwork-core: PMS 凭据清除失败（${errorName(error)}）`);
+            this.deps.log?.(`hiwork-core: 设备标识解析失败（${errorName(error)}），deviceRef 留空`);
+            return '';
         }
     }
     /**
-     * 并发合并：同一世代 + 同一端点的在飞请求共用一次调用与同一个返回值。
+     * 网关异常 → 本频道的稳定错误（spec §3 D8）。
+     *
+     * 关键的分法：**会话失效**与**分配被撤销/停用**要分开。前者是用户自己的动作（重新登录 HiWork），
+     * 后者是管理员那边的动作（重新分配）——归到同一句话，用户就会对着一个自己修不了的问题反复重试。
+     */
+    gatewayFailure(error) {
+        this.deps.log?.(`hiwork-core: PMS 网关调用失败（${gatewayCodeOf(error)}）`);
+        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') {
+                // 分配在网关侧被撤销 / 停用（或改成了不可下发的凭据方式）：与「没有这条分配」同一个动作面
+                // （找管理员），并且要把内存里那条分配丢掉——不丢的话每次取数都会重打一次注定 404 的断言。
+                this.assignment = undefined;
+                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 !== undefined && inFlight.generation === this.generation && inFlight.key === key) {
+        if (inFlight !== undefined && 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 {
-            // 只有自己那次还在账上才清：登出后新发起的那条不该被这一笔收尾抹掉。
+            // 只有自己那次还在账上才清（后发起的那条不该被这一笔收尾抹掉）。
             if (this.inFlight?.task === promise)
                 this.inFlight = undefined;
         }
@@ -591,8 +614,8 @@ export class PmsTodoStore {
  * 处理一次端点调用：返回 DSH Connection 的结果信封，**永不抛异常**。
  * 导出以便单测直接驱动（无需伪造 `ctx.connection`）。
  *
- * 日志纪律：只记**端点名 + 异常类型**。入参里有 `password`（`login`），返回值里有 access token 的
- * 派生状态，两者都不许进日志（§7）。
+ * 日志纪律：只记**端点名 + 异常类型**。返回值里有会话的派生状态（过期时刻 / 账号名 / userId），
+ * 令牌与断言本身一律不进日志（§7）。
  */
 export async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, signal) {
     try {
@@ -605,10 +628,6 @@ export async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, s
         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':