hiwork-core 0.0.22 → 0.0.29

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.29";
 
 // src/ai-router-client.ts
 var AUTH_AUTHORIZE_PATH = "/api/auth/authorize";
@@ -3157,6 +3157,19 @@ var ME_SKILL_PACKAGES_PATH = "/api/me/skill-packages";
 var ME_WORKBENCH_APPS_PATH = "/api/me/workbench-apps";
 var ME_OFFICE_CONFIG_PATH = "/api/me/office-config";
 var ME_OFFICE_RELAY_DOCUMENTS_PATH = "/api/me/office-relay/documents";
+var ME_VOICE_CONFIG_PATH = "/api/me/voice-config";
+var ME_VOICE_TRANSCRIBE_PATH = "/api/me/voice-transcribe";
+var VOICE_TRANSCRIBE_TIMEOUT_MS = 6e4;
+var VOICE_CONFIG_FALLBACK_MAX_SECONDS = 60;
+var VOICE_ERROR_FALLBACK_MESSAGE = {
+  VOICE_DISABLED: "\u672C\u90E8\u7F72\u672A\u542F\u7528\u8BED\u97F3\u8BC6\u522B\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_NOT_CONFIGURED: "\u672C\u90E8\u7F72\u5C1A\u672A\u914D\u7F6E\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_LIMIT_REACHED: "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  VOICE_AUDIO_TOO_LARGE: "\u5F55\u97F3\u8FC7\u957F\u6216\u6587\u4EF6\u8FC7\u5927\uFF0C\u8BF7\u7F29\u77ED\u540E\u91CD\u8BD5",
+  VOICE_BAD_REQUEST: "\u5F55\u97F3\u6570\u636E\u4E0D\u5408\u6CD5\uFF0C\u8BF7\u91CD\u65B0\u5F55\u5236",
+  VOICE_UPSTREAM: "\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"
+};
+var VOICE_ERROR_DEFAULT_MESSAGE = "\u8BED\u97F3\u8BC6\u522B\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
 var DEFAULT_CLIENT_ID = "hiwork-desktop";
 var DEFAULT_REDIRECT_URI = "hiwork://auth/callback";
 var GatewayError = class extends Error {
@@ -3548,6 +3561,81 @@ var AiRouterClient = class {
     if (!res.ok) throw new GatewayError("GATEWAY_UNREACHABLE", `\u7F51\u5173\u8FD4\u56DE\u9519\u8BEF\uFF08HTTP ${res.status}\uFF09`, res.status);
     return await parseMeJson(res);
   }
+  /**
+   * GET /api/me/voice-config：当前账号的语音识别开关与录音时长上限。
+   *
+   * 与每日一句的 `getMyDailyQuote` 同款，**这两个方法不在 {@link GatewayClient} 接口上**：
+   * 那个接口是编排层的端口，「语音识别」与它无关，加进去只会逼着每处编排层假网关
+   * （tests/orchestration.spec.ts 里一堆）都补两个用不到的桩。频道侧改用结构子集
+   * `VoiceGatewayPort`（见 `src/voice-rpc.ts`），与 usage / daily 三处一致。
+   *
+   * 与 {@link getMyMcpAssignments} 同样的理由**不复用 `getMeJson`**：那条路径把 403 映射成
+   * `NO_KEY_ASSIGNED`（「尚未被分配虚拟 KEY」），而本端点的鉴权只有会话——一个还没被分配
+   * Key 的账号照样应该有语音识别（分能力与分 Key 是两件事）。沿用它的文案会把「没有 Key」
+   * 错报成原因。
+   *
+   * 本端点契约**恒 200**（开关开与关都是 200 + `enabled` 布尔），因此除 401 以外没有任何
+   * 需要单独解释的拒绝语义：403 / 404 / 5xx / 反代错误页一律收敛成 `GATEWAY_UNREACHABLE`。
+   *
+   * 形状收敛（**本层负责**，消费方拿到的永远是一个合法的 {@link GatewayVoiceConfig}）：
+   * 网关线上是 snake_case `max_audio_seconds`，这里转 camelCase；字段缺失 / 类型不符
+   * 按「禁用 + 60 秒」处理——配置读不出来时话筒本就该消失，用一个 undefined 让消费方
+   * 去猜是把形状问题推给下游。真正的「读不到就回落」再往上一层（`src/voice-rpc.ts`）。
+   */
+  async getMyVoiceConfig(sessionCookie) {
+    const res = await this.requestOrUnreachable(ME_VOICE_CONFIG_PATH, { method: "GET", sessionCookie });
+    if (res.status === 401) throw new GatewayError("SESSION_EXPIRED", "\u7F51\u5173\u4F1A\u8BDD\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", 401);
+    if (!res.ok) throw new GatewayError("GATEWAY_UNREACHABLE", `\u7F51\u5173\u8FD4\u56DE\u9519\u8BEF\uFF08HTTP ${res.status}\uFF09`, res.status);
+    const data = await parseMeJson(res);
+    const seconds = data.max_audio_seconds;
+    return {
+      enabled: data.enabled === true,
+      maxDurationSeconds: typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0 ? seconds : VOICE_CONFIG_FALLBACK_MAX_SECONDS
+    };
+  }
+  /**
+   * POST /api/me/voice-transcribe：把一段录音（base64）交给网关转发上游做识别。
+   *
+   * 状态码映射与服务端 handler 一一对应，**不许合并**：
+   *  - 401 = 会话过期（唯一一条能让人做点什么——重新登录——的拒绝）；
+   *  - 503 = 网关自己发的「功能不可用」，再按响应体 `code` 细分：
+   *    `VOICE_NOT_CONFIGURED`（部署没配上游）/ `VOICE_DISABLED`（管理员把开关关了）。
+   *    两者给的提示不同（该找管理员配服务 vs 该找管理员开开关）。
+   *    ⚠️ 响应体没有 `code`（非 JSON / 反代错误页）也归 `VOICE_DISABLED`——这条路由的
+   *    503 语义就是「没开」，而**上游故障走 502**（见下），不会伪装成 503；
+   *  - 429 / 413 / 400 = 配额 / 超长 / 请求体不合法，三种不同的事，分开映射（合并后
+   *    客户端只会看到一句「识别失败」，413 的人不知道该录短一点）；
+   *  - 其余（含 502 = 上游出错）→ `VOICE_UPSTREAM`。
+   *
+   * message 一律取网关响应体里的 `message`（网关侧是冻结的中文文案，会直接展示给用户）；
+   * 响应体不是合法 JSON / 缺 message 时退回本地兜底文案。**绝不把上游 / 网关原文回显**：
+   * 读取响应体走 {@link readVoiceError}（解析失败即空对象），与 `parseMeJson` 不回显原文同源。
+   *
+   * 超时**单独放宽到 60s**（见 {@link VOICE_TRANSCRIBE_TIMEOUT_MS}）：这条要上传录音 +
+   * 等上游识别，构造时的 10s 默认值在这里是误报源。
+   */
+  async transcribeVoice(sessionCookie, audioBase64) {
+    const res = await this.requestOrUnreachable(ME_VOICE_TRANSCRIBE_PATH, {
+      method: "POST",
+      sessionCookie,
+      body: { audio_base64: audioBase64 },
+      timeoutMs: VOICE_TRANSCRIBE_TIMEOUT_MS
+    });
+    if (res.status === 401) throw new GatewayError("SESSION_EXPIRED", "\u7F51\u5173\u4F1A\u8BDD\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", 401);
+    if (!res.ok) {
+      const body = await readVoiceError(res);
+      if (res.status === 503) {
+        const code = body.code === "VOICE_NOT_CONFIGURED" ? "VOICE_NOT_CONFIGURED" : "VOICE_DISABLED";
+        throw new GatewayError(code, voiceMessage(code, body), 503);
+      }
+      if (res.status === 429) throw new GatewayError("VOICE_LIMIT_REACHED", voiceMessage("VOICE_LIMIT_REACHED", body), 429);
+      if (res.status === 413) throw new GatewayError("VOICE_AUDIO_TOO_LARGE", voiceMessage("VOICE_AUDIO_TOO_LARGE", body), 413);
+      if (res.status === 400) throw new GatewayError("VOICE_BAD_REQUEST", voiceMessage("VOICE_BAD_REQUEST", body), 400);
+      throw new GatewayError("VOICE_UPSTREAM", voiceMessage("VOICE_UPSTREAM", body), res.status);
+    }
+    const data = await parseMeJson(res);
+    return { text: typeof data.text === "string" ? data.text : "" };
+  }
   /**
    * /api/me 自助端点的 GET 公共路径：网络异常 → GATEWAY_UNREACHABLE，
    * 401/403/400 映射为稳定 code，响应体非 JSON 时不把原文带进异常。
@@ -3584,7 +3672,7 @@ var AiRouterClient = class {
     const init = {
       method: opts.method,
       headers,
-      signal: AbortSignal.timeout(this.timeoutMs)
+      signal: AbortSignal.timeout(opts.timeoutMs ?? this.timeoutMs)
     };
     if (opts.rawBody !== void 0) {
       init.body = opts.rawBody.buffer.slice(
@@ -3652,6 +3740,18 @@ async function parseMeJson(res) {
   }
   return data;
 }
+async function readVoiceError(res) {
+  const data = await readJson(res);
+  if (typeof data !== "object" || data === null) return {};
+  const record = data;
+  return {
+    ...typeof record.code === "string" && record.code !== "" ? { code: record.code } : {},
+    ...typeof record.message === "string" && record.message.trim() !== "" ? { message: record.message.trim() } : {}
+  };
+}
+function voiceMessage(code, body) {
+  return body.message ?? VOICE_ERROR_FALLBACK_MESSAGE[code] ?? VOICE_ERROR_DEFAULT_MESSAGE;
+}
 function isInvalidGrant(payload) {
   return typeof payload === "object" && payload !== null && payload.error === "invalid_grant";
 }
@@ -4218,8 +4318,8 @@ function parseAppVersionPayload(raw) {
   if (keys.length > 0) throw new AppVersionRequestError("bad-request", `\u684C\u9762\u7AEF\u7248\u672C\u8BF7\u6C42\u5305\u542B\u672A\u77E5\u5B57\u6BB5 '${keys[0]}'\u3002`);
 }
 function normalizedVersion(raw) {
-  const version = typeof raw === "string" ? raw.trim() : "";
-  return version === "" ? null : version;
+  const version2 = typeof raw === "string" ? raw.trim() : "";
+  return version2 === "" ? null : version2;
 }
 async function handleAppVersionEndpoint(endpoint, rawPayload, deps, signal) {
   try {
@@ -4652,6 +4752,123 @@ function registerUsageRpc(ctx, deps) {
   };
 }
 
+// src/voice-rpc.ts
+var VOICE_RPC_CHANNEL = "/hiwork-voice";
+var VOICE_RPC_ENDPOINTS = ["status", "transcribe"];
+var VoiceRequestError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "VoiceRequestError";
+  }
+};
+var VOICE_MESSAGE_FALLBACK = {
+  SESSION_EXPIRED: "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55",
+  GATEWAY_UNREACHABLE: "\u7F51\u5173\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+  VOICE_DISABLED: "\u672C\u90E8\u7F72\u672A\u542F\u7528\u8BED\u97F3\u8BC6\u522B\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_NOT_CONFIGURED: "\u672C\u90E8\u7F72\u5C1A\u672A\u914D\u7F6E\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+  VOICE_LIMIT_REACHED: "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  VOICE_AUDIO_TOO_LARGE: "\u5F55\u97F3\u8FC7\u957F\uFF0C\u8BF7\u7F29\u77ED\u540E\u91CD\u8BD5",
+  VOICE_BAD_REQUEST: "\u5F55\u97F3\u6570\u636E\u4E0D\u5408\u6CD5\uFF0C\u8BF7\u91CD\u65B0\u5F55\u5236",
+  VOICE_UPSTREAM: "\u8BED\u97F3\u8BC6\u522B\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+  RATE_LIMITED: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  AUTH_FAILED: "\u767B\u5F55\u72B6\u6001\u5F02\u5E38\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55"
+};
+var VOICE_GENERIC_FAILURE_MESSAGE = "\u8BED\u97F3\u8BC6\u522B\u6682\u65F6\u65E0\u6CD5\u4F7F\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var VOICE_SESSION_EXPIRED_MESSAGE = "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55";
+var VOICE_FALLBACK_CONFIG = { enabled: false, maxDurationSeconds: 60 };
+function displayVoiceGatewayMessage(code, message) {
+  const text = typeof message === "string" ? message.trim() : "";
+  if (text === "") return VOICE_MESSAGE_FALLBACK[code] ?? VOICE_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 VOICE_MESSAGE_FALLBACK[code] ?? VOICE_GENERIC_FAILURE_MESSAGE;
+  return text;
+}
+function parseVoicePayload(endpoint, raw) {
+  if (raw === void 0 || raw === null) {
+    if (endpoint === "transcribe") throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u7F3A\u5C11 audioBase64\u3002");
+    return {};
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u53C2\u6570\u4E0D\u5408\u6CD5\u3002");
+  }
+  const record = raw;
+  const keys = Object.keys(record);
+  if (endpoint === "status") {
+    if (keys.length > 0) throw new VoiceRequestError("bad-request", `\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5305\u542B\u672A\u77E5\u5B57\u6BB5 '${keys[0]}'\u3002`);
+    return {};
+  }
+  for (const key of keys) {
+    if (key !== "audioBase64") throw new VoiceRequestError("bad-request", `\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5305\u542B\u672A\u77E5\u5B57\u6BB5 '${key}'\u3002`);
+  }
+  const rawAudio = record["audioBase64"];
+  if (typeof rawAudio !== "string" || rawAudio.trim() === "") {
+    throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u7684 audioBase64 \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002");
+  }
+  return { audioBase64: rawAudio };
+}
+function isVoiceRpcEndpoint(endpoint) {
+  return VOICE_RPC_ENDPOINTS.includes(endpoint);
+}
+function isAborted4(signal) {
+  return signal?.aborted === true;
+}
+async function handleVoiceEndpoint(endpoint, rawPayload, deps, signal) {
+  try {
+    if (isAborted4(signal)) return failure4("cancelled", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (!isVoiceRpcEndpoint(endpoint)) {
+      throw new VoiceRequestError("bad-request", `\u672A\u77E5\u7684\u8BED\u97F3\u8BC6\u522B\u7AEF\u70B9 '${endpoint}'`);
+    }
+    const payload = parseVoicePayload(endpoint, rawPayload);
+    const sessionCookie = await deps.resolveSession();
+    if (sessionCookie === void 0 || sessionCookie === "") {
+      return failure4("SESSION_EXPIRED", VOICE_SESSION_EXPIRED_MESSAGE);
+    }
+    const gateway = deps.gateway();
+    if (gateway === void 0) {
+      return failure4("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
+    }
+    if (isAborted4(signal)) return failure4("cancelled", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (endpoint === "status") return { ok: true, value: await readVoiceConfig(gateway, sessionCookie, deps.log) };
+    return { ok: true, value: await transcribe(gateway, sessionCookie, payload) };
+  } catch (error) {
+    if (error instanceof VoiceRequestError) return failure4(error.code, error.message);
+    if (error instanceof GatewayError) {
+      return failure4(error.code, displayVoiceGatewayMessage(error.code, error.message));
+    }
+    deps.log?.(`hiwork-core: \u8BED\u97F3\u8BC6\u522B RPC '${endpoint}' \u5931\u8D25\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
+    return failure4("internal", VOICE_GENERIC_FAILURE_MESSAGE);
+  }
+}
+async function readVoiceConfig(gateway, sessionCookie, log) {
+  try {
+    const config = await gateway.getMyVoiceConfig(sessionCookie);
+    return {
+      enabled: config.enabled === true,
+      maxDurationSeconds: config.maxDurationSeconds > 0 ? config.maxDurationSeconds : VOICE_FALLBACK_CONFIG.maxDurationSeconds
+    };
+  } catch (error) {
+    log?.(`hiwork-core: \u8BED\u97F3\u914D\u7F6E\u8BFB\u53D6\u5931\u8D25\uFF0C\u6309\u7981\u7528\u56DE\u843D\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
+    return { ...VOICE_FALLBACK_CONFIG };
+  }
+}
+async function transcribe(gateway, sessionCookie, payload) {
+  const audioBase64 = payload.audioBase64;
+  if (audioBase64 === void 0) throw new VoiceRequestError("bad-request", "\u8BED\u97F3\u8BC6\u522B\u8BF7\u6C42\u7F3A\u5C11 audioBase64\u3002");
+  const result = await gateway.transcribeVoice(sessionCookie, audioBase64);
+  return { text: result.text };
+}
+function failure4(code, message) {
+  return { ok: false, error: { code, message, details: {} } };
+}
+function registerVoiceRpc(ctx, deps) {
+  const handler = (endpoint, payload, signal) => handleVoiceEndpoint(endpoint, payload, deps, signal);
+  const remove = ctx.connection.rpc.handle(VOICE_RPC_CHANNEL, handler, { authority: "loopback" });
+  return async () => {
+    await remove();
+  };
+}
+
 // src/managed-mcp.ts
 var MANAGED_MCP_RPC_CHANNEL = "/hiwork-managed-mcp";
 var MANAGED_MCP_RPC_ENDPOINTS = ["snapshot", "refresh", "assertion"];
@@ -4816,12 +5033,12 @@ var ManagedMcpStore = class {
     }
   }
 };
-function isAborted4(signal) {
+function isAborted5(signal) {
   return signal?.aborted === true;
 }
 async function handleManagedMcpEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (isAborted4(signal)) return failure4("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted5(signal)) return failure5("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isManagedMcpRpcEndpoint(endpoint)) {
       throw new ManagedMcpRequestError("bad-request", `\u672A\u77E5\u7684 MCP \u6E05\u5355\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -4842,19 +5059,19 @@ async function handleManagedMcpEndpoint(endpoint, rawPayload, deps, store, signa
 async function handleAssertion(assignmentId, deps, signal) {
   const sessionCookie = await deps.resolveSession();
   if (sessionCookie === void 0 || sessionCookie === "") {
-    return failure4("SESSION_EXPIRED", MANAGED_MCP_SESSION_EXPIRED_MESSAGE);
+    return failure5("SESSION_EXPIRED", MANAGED_MCP_SESSION_EXPIRED_MESSAGE);
   }
   const gateway = deps.gateway();
   if (gateway === void 0) {
-    return failure4("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
+    return failure5("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
   }
-  if (isAborted4(signal)) return failure4("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+  if (isAborted5(signal)) return failure5("cancelled", "MCP \u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
   const ticket = await gateway.issueMyMcpAssertion(sessionCookie, assignmentId);
   const assertion = textOrUndefined(ticket?.assertion);
   const mintUrl = textOrUndefined(ticket?.mintUrl);
   if (assertion === void 0 || mintUrl === void 0) {
     deps.log?.("hiwork-core: \u53D6\u65AD\u8A00\u6536\u5230\u65E0\u6548\u54CD\u5E94\uFF08\u7F3A assertion / mintUrl\uFF09");
-    return failure4("internal", MANAGED_MCP_GENERIC_FAILURE_MESSAGE);
+    return failure5("internal", MANAGED_MCP_GENERIC_FAILURE_MESSAGE);
   }
   return {
     ok: true,
@@ -4867,7 +5084,7 @@ async function handleAssertion(assignmentId, deps, signal) {
     }
   };
 }
-function failure4(code, message) {
+function failure5(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerManagedMcpRpc(ctx, deps, store) {
@@ -5098,12 +5315,12 @@ var ManagedSkillsStore = class {
     }
   }
 };
-function isAborted5(signal) {
+function isAborted6(signal) {
   return signal?.aborted === true;
 }
 async function handleManagedSkillsEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (isAborted5(signal)) return failure5("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted6(signal)) return failure6("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isManagedSkillsRpcEndpoint(endpoint)) {
       throw new ManagedSkillsRequestError("bad-request", `\u672A\u77E5\u7684\u6280\u80FD\u6E05\u5355\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -5124,24 +5341,24 @@ async function handleManagedSkillsEndpoint(endpoint, rawPayload, deps, store, si
 async function handlePackage(assignmentId, deps, signal) {
   const sessionCookie = await deps.resolveSession();
   if (sessionCookie === void 0 || sessionCookie === "") {
-    return failure5("SESSION_EXPIRED", MANAGED_SKILLS_SESSION_EXPIRED_MESSAGE);
+    return failure6("SESSION_EXPIRED", MANAGED_SKILLS_SESSION_EXPIRED_MESSAGE);
   }
   const gateway = deps.gateway();
   if (gateway === void 0) {
-    return failure5("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
+    return failure6("GATEWAY_UNREACHABLE", "\u7F51\u5173\u5730\u5740\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u5728\u300C\u7F51\u5173\u6A21\u578B\u300D\u91CC\u5B8C\u6210\u767B\u5F55");
   }
-  if (isAborted5(signal)) return failure5("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+  if (isAborted6(signal)) return failure6("cancelled", "\u6280\u80FD\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
   const pkg = await gateway.getMySkillPackage(sessionCookie, assignmentId);
   const bytes = pkg?.bytes;
   const skillName = textOrUndefined2(pkg?.skillName);
   const contentSha256 = textOrUndefined2(pkg?.contentSha256);
   if (!(bytes instanceof Uint8Array) || bytes.byteLength === 0 || skillName === void 0 || contentSha256 === void 0) {
     deps.log?.("hiwork-core: \u53D6\u6280\u80FD\u5305\u6536\u5230\u65E0\u6548\u54CD\u5E94\uFF08\u7F3A skillName / contentSha256 \u6216\u7A7A\u5305\u4F53\uFF09");
-    return failure5("internal", MANAGED_SKILLS_GENERIC_FAILURE_MESSAGE);
+    return failure6("internal", MANAGED_SKILLS_GENERIC_FAILURE_MESSAGE);
   }
   if (bytes.byteLength > MAX_MANAGED_SKILL_ARCHIVE_BYTES) {
     deps.log?.("hiwork-core: \u6280\u80FD\u5305\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650\uFF0C\u5DF2\u62D2\u7EDD\u642C\u8FD0");
-    return failure5(MANAGED_SKILLS_PACKAGE_TOO_LARGE_CODE, MANAGED_SKILLS_PACKAGE_TOO_LARGE_MESSAGE);
+    return failure6(MANAGED_SKILLS_PACKAGE_TOO_LARGE_CODE, MANAGED_SKILLS_PACKAGE_TOO_LARGE_MESSAGE);
   }
   return {
     ok: true,
@@ -5155,7 +5372,7 @@ async function handlePackage(assignmentId, deps, signal) {
     }
   };
 }
-function failure5(code, message) {
+function failure6(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerManagedSkillsRpc(ctx, deps, store) {
@@ -5297,7 +5514,7 @@ function failureOf3(error) {
 function normalizeSession2(sessionCookie) {
   return sessionCookie === void 0 || sessionCookie === "" ? void 0 : sessionCookie;
 }
-function isAborted6(signal) {
+function isAborted7(signal) {
   return signal?.aborted === true;
 }
 var WorkbenchStore = class {
@@ -5422,7 +5639,7 @@ var WorkbenchStore = class {
 };
 async function handleWorkbenchEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (isAborted6(signal)) return failure6("cancelled", "\u5DE5\u4F5C\u53F0\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted7(signal)) return failure7("cancelled", "\u5DE5\u4F5C\u53F0\u6E05\u5355\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
     if (!isWorkbenchRpcEndpoint(endpoint)) {
       throw new WorkbenchRequestError("bad-request", `\u672A\u77E5\u7684\u5DE5\u4F5C\u53F0\u6E05\u5355\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -5435,7 +5652,7 @@ async function handleWorkbenchEndpoint(endpoint, rawPayload, deps, store, signal
     return { ok: false, error: failureOf3(error) };
   }
 }
-function failure6(code, message) {
+function failure7(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerWorkbenchRpc(ctx, deps, store) {
@@ -5448,8 +5665,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 +5716,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 +5905,22 @@ 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、令牌只在有身份时发），所以两条路共用这一处，
+   * 而不是各抄一份、将来各自漂移。
+   *
+   * **重定向自己跟**（`redirect: 'manual'` + {@link redirectTargetOf}）：`fetch` 的默认 `follow` 会把
+   * 重定向后的请求按 fetch 语义**把 POST 改成 GET**，于是请求落在一个只认 POST 的映射上、拿到一个
+   * 「200 + 业务错误信封」，看上去像上游坏了。判据与修法见 {@link PMS_MAX_REDIRECTS}。
+   *
+   * @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}`,
@@ -5675,13 +5931,34 @@ var PmsClient = class {
       const init = {
         method: opts.method,
         headers,
-        signal: AbortSignal.timeout(this.timeoutMs)
+        // 手动跟随：默认的 `follow` 会把重定向后的 POST 降级成 GET（见本方法的抬头）。
+        redirect: "manual"
       };
       if (opts.body !== void 0) init.body = JSON.stringify(opts.body);
-      response = await fetch(`${this.baseURL}${path}`, init);
+      const deadline = Date.now() + this.timeoutMs;
+      let target = isAbsoluteUrl(url) ? url : `${this.baseURL}${url}`;
+      let response = await fetchWithinDeadline(target, init, deadline);
+      for (let hop = 0; ; hop += 1) {
+        const next = redirectTargetOf(target, response, hop);
+        if (next === void 0) return response;
+        target = next;
+        response = await fetchWithinDeadline(target, init, deadline);
+      }
     } 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 +5990,41 @@ 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);
+}
+var PMS_MAX_REDIRECTS = 2;
+var METHOD_PRESERVING_REDIRECTS = /* @__PURE__ */ new Set([301, 302, 307, 308]);
+function redirectTargetOf(current, response, hop) {
+  if (!METHOD_PRESERVING_REDIRECTS.has(response.status)) return void 0;
+  if (hop >= PMS_MAX_REDIRECTS) return void 0;
+  const location = response.headers.get("location");
+  if (location === null || location.trim() === "") return void 0;
+  let from2;
+  let next;
+  try {
+    from2 = new URL(current);
+    next = new URL(location.trim(), current);
+  } catch {
+    return void 0;
+  }
+  if (next.protocol !== "https:" && next.protocol !== from2.protocol) return void 0;
+  if (next.hostname !== from2.hostname) return void 0;
+  return next.toString();
+}
+async function fetchWithinDeadline(target, init, deadline) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw new Error("pms request deadline exceeded");
+  return await fetch(target, { ...init, signal: AbortSignal.timeout(remaining) });
+}
+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 +6117,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 +6139,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 +6168,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 +6219,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 +6318,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 +6345,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）。
    *
-   * 「读一次就记住 `loaded`」是有意的：凭据的写入方只有本类（`login` / `logout` / refresh 回写），
-   * 因此在同一进程里，读盘只需要一次。跨进程变更（别的进程写了同一个 ref）本就不可观测，
-   * 硬要每次重新读只会让「不 remember 的登录」被磁盘上的旧记录当场覆盖。
+   * 匹配依据只有 slug（逐字等于 {@link PMS_ASSIGNMENT_SLUG}）：清单里还有 visio-mcp 之类的分配，
+   * 「取第一条断言分配」在分配多起来之后会随机串台。**不看 `auth.kind`**：那是服务端演进的开放
+   * 集合，我们只认自己写死的 slug（D9 的原文就是「唯一匹配依据」）。
+   *
+   * 没有这条分配 → `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 分两类：
    *
-   * 先 `resolve` 一次再 `unset`：没有记录时一次写都不做（测试与磁盘都清清爽爽），有记录时
-   * **必须**清掉——否则一条旧的 account+refresh token 会在下次启动时被当成「这个人配置过凭据」，
-   * 用户明明刚选了「不记住」却在重启后仍是登录态。
+   *  - **被拒（401 / 403）→ 不重试**：断言过期 / `aud` 不符 / 签名不过 / 工号在 PMS 不存在，
+   *    四种原因在 PMS 侧都是同一个 403（防账号探测），重发只会连打；动作是「重新登录 HiWork」。
+   *  - **网络 / 5xx → 换一张新断言重试一次**：断言可能是在途耗掉的（120 秒的门票），而同一张断言
+   *    是一次性的（`jti` 防重放），所以重试必须重新签一张。仍失败 → `UPSTREAM_UNAVAILABLE`。
+   *
+   * 日志只记 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 {
@@ -6251,7 +6551,7 @@ var PmsTodoStore = class {
 };
 async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, signal) {
   try {
-    if (signal?.aborted === true) return failure7("BAD_REQUEST", PMS_TODO_CANCELLED_MESSAGE);
+    if (signal?.aborted === true) return failure8("BAD_REQUEST", PMS_TODO_CANCELLED_MESSAGE);
     if (!isPmsTodoRpcEndpoint(endpoint)) {
       throw new PmsTodoRequestError(`\u672A\u77E5\u7684 PMS \u5F85\u529E\u7AEF\u70B9 '${endpoint}'`);
     }
@@ -6259,10 +6559,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":
@@ -6279,7 +6575,7 @@ async function handlePmsTodoEndpoint(endpoint, rawPayload, deps, store, signal)
     return { ok: false, error: pmsTodoErrorOf(error) };
   }
 }
-function failure7(code, message) {
+function failure8(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerPmsTodoRpc(ctx, deps, store) {
@@ -6310,7 +6606,7 @@ function isRecord4(value) {
 function textOrUndefined4(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
-function isAborted7(signal) {
+function isAborted8(signal) {
   return signal?.aborted === true;
 }
 function parsePluginUpdatesPayload(endpoint, raw) {
@@ -6353,7 +6649,7 @@ function toSnapshot(raw) {
 }
 async function handlePluginUpdatesEndpoint(endpoint, rawPayload, deps, signal) {
   try {
-    if (isAborted7(signal)) return failure8("cancelled", "\u63D2\u4EF6\u66F4\u65B0\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+    if (isAborted8(signal)) return failure9("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}'`);
     }
@@ -6369,12 +6665,12 @@ async function handlePluginUpdatesEndpoint(endpoint, rawPayload, deps, signal) {
     await plugins.applyNow();
     return { ok: true, value: { requested: true } };
   } catch (error) {
-    if (error instanceof PluginUpdatesRequestError) return failure8(error.code, error.message);
+    if (error instanceof PluginUpdatesRequestError) return failure9(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 failure8("internal", PLUGIN_UPDATES_GENERIC_FAILURE_MESSAGE);
+    return failure9("internal", PLUGIN_UPDATES_GENERIC_FAILURE_MESSAGE);
   }
 }
-function failure8(code, message) {
+function failure9(code, message) {
   return { ok: false, error: { code, message, details: {} } };
 }
 function registerPluginUpdatesRpc(ctx, deps) {
@@ -6445,16 +6741,15 @@ function provideIdentity(ctx, deps) {
   };
 }
 
-// src/memory-config.ts
-var HIWORK_MEMORY_SERVICE = "hiworkMemory";
-var ME_MEMORY_CONFIG_PATH = "/api/me/memory-config";
-var MEMORY_CONFIG_TTL_MS = 5 * 60 * 1e3;
-var MEMORY_CONFIG_TIMEOUT_MS = 1e4;
-var MESSAGE_NOT_CONFIGURED = "\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u56E2\u961F\u8BB0\u5FC6\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5F00\u901A";
+// src/knowledge-config.ts
+var HIWORK_KNOWLEDGE_SERVICE = "hiworkKnowledge";
+var ME_KNOWLEDGE_CONFIG_PATH = "/api/me/knowledge-config";
+var KNOWLEDGE_CONFIG_TTL_MS = 5 * 60 * 1e3;
+var KNOWLEDGE_CONFIG_TIMEOUT_MS = 1e4;
+var MESSAGE_NOT_CONFIGURED = "\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u77E5\u8BC6\u5E93\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5F00\u901A";
 var MESSAGE_UNAUTHENTICATED = "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55";
-var MESSAGE_UNREACHABLE = "\u8BB0\u5FC6\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
-var MESSAGE_NO_GATEWAY = "\u8FD8\u6CA1\u8FDE\u4E0A\u4F01\u4E1A\u7F51\u5173\uFF0C\u8BF7\u5148\u767B\u5F55\u540E\u518D\u8BD5";
-var MESSAGE_GENERIC = "\u8BB0\u5FC6\u914D\u7F6E\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var MESSAGE_UNREACHABLE = "\u77E5\u8BC6\u5E93\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var MESSAGE_GENERIC = "\u77E5\u8BC6\u5E93\u914D\u7F6E\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
 function messageFor(reason) {
   switch (reason) {
     case "not-configured":
@@ -6467,7 +6762,7 @@ function messageFor(reason) {
       return MESSAGE_GENERIC;
   }
 }
-function failure9(reason, message) {
+function failure10(reason, message) {
   return { ok: false, reason, message: message ?? messageFor(reason) };
 }
 function textOrUndefined6(value) {
@@ -6475,26 +6770,17 @@ function textOrUndefined6(value) {
   const text = value.trim();
   return text === "" ? void 0 : text;
 }
-function teamIdsOf(value) {
-  if (!Array.isArray(value)) return [];
-  const ids = [];
-  for (const item of value) {
-    const text = textOrUndefined6(item);
-    if (text !== void 0) ids.push(text);
-  }
-  return ids;
-}
-function projectMemoryConfig(body) {
-  const panelUrl = textOrUndefined6(body["panel_url"] ?? body["panelUrl"]);
-  const serviceId = textOrUndefined6(body["service_id"] ?? body["serviceId"]);
-  const apiKey = textOrUndefined6(body["api_key"] ?? body["apiKey"] ?? body["userKey"]);
-  if (panelUrl === void 0 || serviceId === void 0 || apiKey === void 0) return void 0;
+function projectKnowledgeConfig(body) {
+  const baseUrl = textOrUndefined6(body["base_url"] ?? body["baseUrl"]);
+  const apiKey = textOrUndefined6(body["api_key"] ?? body["apiKey"]);
+  if (baseUrl === void 0 || apiKey === void 0) return void 0;
   return {
     ok: true,
-    panelUrl,
-    serviceId,
-    teamIds: teamIdsOf(body["team_ids"] ?? body["teamIds"]),
-    apiKey
+    baseUrl,
+    apiKey,
+    agentId: textOrUndefined6(body["agent_id"] ?? body["agentId"]) ?? "",
+    chatModelId: textOrUndefined6(body["chat_model_id"] ?? body["chatModelId"]) ?? "",
+    tenantId: textOrUndefined6(body["tenant_id"] ?? body["tenantId"]) ?? ""
   };
 }
 function errorName2(error) {
@@ -6506,9 +6792,9 @@ function reasonOfErrorCode(error) {
   switch (code) {
     case "SESSION_EXPIRED":
       return "unauthenticated";
-    case "MEMORY_NOT_CONFIGURED":
+    case "KNOWLEDGE_NOT_CONFIGURED":
       return "not-configured";
-    case "MEMORY_UNREACHABLE":
+    case "KNOWLEDGE_UNREACHABLE":
     case "GATEWAY_UNREACHABLE":
       return "unreachable";
     default:
@@ -6521,6 +6807,168 @@ function reasonOfStatus(status) {
   if (status === 504) return "unreachable";
   return "error";
 }
+var KnowledgeConfigProvider = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  cached;
+  async config(opts) {
+    const force = opts?.force === true;
+    let sessionCookie;
+    try {
+      sessionCookie = await this.deps.resolveSession();
+    } catch (error) {
+      this.deps.log?.(`hiwork-core: \u77E5\u8BC6\u5E93\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
+      return failure10("error");
+    }
+    if (sessionCookie === void 0 || sessionCookie === "") return failure10("unauthenticated");
+    if (!force) {
+      const hit = this.cached;
+      if (hit !== void 0 && hit.sessionCookie === sessionCookie && this.now() - hit.at < KNOWLEDGE_CONFIG_TTL_MS) {
+        return hit.view;
+      }
+    }
+    const gateway = this.deps.gateway();
+    if (gateway === void 0) return failure10("unreachable");
+    let outcome;
+    try {
+      outcome = await gateway.getMyKnowledgeConfig(sessionCookie);
+    } catch (error) {
+      const mapped = reasonOfErrorCode(error);
+      if (mapped !== void 0) return failure10(mapped);
+      this.deps.log?.(`hiwork-core: \u77E5\u8BC6\u5E93\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
+      return failure10("error");
+    }
+    if (!outcome.ok) {
+      if (outcome.kind === "network") return failure10("unreachable");
+      if (outcome.kind === "http") return failure10(reasonOfStatus(outcome.status));
+      return failure10("error");
+    }
+    const view = projectKnowledgeConfig(outcome.body);
+    if (view === void 0) {
+      this.deps.log?.("hiwork-core: \u7F51\u5173\u8FD4\u56DE\u7684 knowledge-config \u4E0D\u5B8C\u6574\uFF08\u7F3A base_url / api_key \u4E4B\u4E00\uFF09");
+      return failure10("error");
+    }
+    this.cached = { sessionCookie, view, at: this.now() };
+    return view;
+  }
+  now() {
+    return (this.deps.now ?? Date.now)();
+  }
+};
+function provideKnowledgeConfig(ctx, deps) {
+  const service = new KnowledgeConfigProvider(deps);
+  const dispose = ctx.provide(HIWORK_KNOWLEDGE_SERVICE, service);
+  return typeof dispose === "function" ? dispose : () => {
+  };
+}
+function createKnowledgeConfigGateway(baseURL, opts = {}) {
+  const root = baseURL.replace(/\/+$/, "");
+  const timeoutMs = opts.timeoutMs ?? KNOWLEDGE_CONFIG_TIMEOUT_MS;
+  const doFetch = opts.fetchImpl ?? fetch;
+  return {
+    async getMyKnowledgeConfig(sessionCookie) {
+      try {
+        const res = await doFetch(`${root}${ME_KNOWLEDGE_CONFIG_PATH}`, {
+          method: "GET",
+          headers: {
+            "user-agent": `hiwork-core/${PKG_VERSION}`,
+            cookie: sessionCookie
+          },
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        if (!res.ok) return { ok: false, kind: "http", status: res.status };
+        let body;
+        try {
+          body = await res.json();
+        } catch {
+          return { ok: false, kind: "invalid" };
+        }
+        if (body === null || typeof body !== "object") return { ok: false, kind: "invalid" };
+        return { ok: true, body };
+      } catch {
+        return { ok: false, kind: "network" };
+      }
+    }
+  };
+}
+
+// src/memory-config.ts
+var HIWORK_MEMORY_SERVICE = "hiworkMemory";
+var ME_MEMORY_CONFIG_PATH = "/api/me/memory-config";
+var MEMORY_CONFIG_TTL_MS = 5 * 60 * 1e3;
+var MEMORY_CONFIG_TIMEOUT_MS = 1e4;
+var MESSAGE_NOT_CONFIGURED2 = "\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u56E2\u961F\u8BB0\u5FC6\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5F00\u901A";
+var MESSAGE_UNAUTHENTICATED2 = "\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55";
+var MESSAGE_UNREACHABLE2 = "\u8BB0\u5FC6\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var MESSAGE_NO_GATEWAY = "\u8FD8\u6CA1\u8FDE\u4E0A\u4F01\u4E1A\u7F51\u5173\uFF0C\u8BF7\u5148\u767B\u5F55\u540E\u518D\u8BD5";
+var MESSAGE_GENERIC2 = "\u8BB0\u5FC6\u914D\u7F6E\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+function messageFor2(reason) {
+  switch (reason) {
+    case "not-configured":
+      return MESSAGE_NOT_CONFIGURED2;
+    case "unauthenticated":
+      return MESSAGE_UNAUTHENTICATED2;
+    case "unreachable":
+      return MESSAGE_UNREACHABLE2;
+    case "error":
+      return MESSAGE_GENERIC2;
+  }
+}
+function failure11(reason, message) {
+  return { ok: false, reason, message: message ?? messageFor2(reason) };
+}
+function textOrUndefined7(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  return text === "" ? void 0 : text;
+}
+function teamIdsOf(value) {
+  if (!Array.isArray(value)) return [];
+  const ids = [];
+  for (const item of value) {
+    const text = textOrUndefined7(item);
+    if (text !== void 0) ids.push(text);
+  }
+  return ids;
+}
+function projectMemoryConfig(body) {
+  const panelUrl = textOrUndefined7(body["panel_url"] ?? body["panelUrl"]);
+  const serviceId = textOrUndefined7(body["service_id"] ?? body["serviceId"]);
+  const apiKey = textOrUndefined7(body["api_key"] ?? body["apiKey"] ?? body["userKey"]);
+  if (panelUrl === void 0 || serviceId === void 0 || apiKey === void 0) return void 0;
+  return {
+    ok: true,
+    panelUrl,
+    serviceId,
+    teamIds: teamIdsOf(body["team_ids"] ?? body["teamIds"]),
+    apiKey
+  };
+}
+function errorName3(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+function reasonOfErrorCode2(error) {
+  const code = error?.code;
+  if (typeof code !== "string") return void 0;
+  switch (code) {
+    case "SESSION_EXPIRED":
+      return "unauthenticated";
+    case "MEMORY_NOT_CONFIGURED":
+      return "not-configured";
+    case "MEMORY_UNREACHABLE":
+    case "GATEWAY_UNREACHABLE":
+      return "unreachable";
+    default:
+      return void 0;
+  }
+}
+function reasonOfStatus2(status) {
+  if (status === 401) return "unauthenticated";
+  if (status === 503) return "not-configured";
+  if (status === 504) return "unreachable";
+  return "error";
+}
 var MemoryConfigProvider = class {
   constructor(deps) {
     this.deps = deps;
@@ -6532,10 +6980,10 @@ var MemoryConfigProvider = class {
     try {
       sessionCookie = await this.deps.resolveSession();
     } catch (error) {
-      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
-      return failure9("error");
+      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName3(error)}\uFF09`);
+      return failure11("error");
     }
-    if (sessionCookie === void 0 || sessionCookie === "") return failure9("unauthenticated");
+    if (sessionCookie === void 0 || sessionCookie === "") return failure11("unauthenticated");
     if (!force) {
       const hit = this.cached;
       if (hit !== void 0 && hit.sessionCookie === sessionCookie && this.now() - hit.at < MEMORY_CONFIG_TTL_MS) {
@@ -6543,25 +6991,25 @@ var MemoryConfigProvider = class {
       }
     }
     const gateway = this.deps.gateway();
-    if (gateway === void 0) return failure9("unreachable", MESSAGE_NO_GATEWAY);
+    if (gateway === void 0) return failure11("unreachable", MESSAGE_NO_GATEWAY);
     let outcome;
     try {
       outcome = await gateway.getMyMemoryConfig(sessionCookie);
     } catch (error) {
-      const mapped = reasonOfErrorCode(error);
-      if (mapped !== void 0) return failure9(mapped);
-      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName2(error)}\uFF09`);
-      return failure9("error");
+      const mapped = reasonOfErrorCode2(error);
+      if (mapped !== void 0) return failure11(mapped);
+      this.deps.log?.(`hiwork-core: \u8BB0\u5FC6\u914D\u7F6E\u83B7\u53D6\u5931\u8D25\uFF08${errorName3(error)}\uFF09`);
+      return failure11("error");
     }
     if (!outcome.ok) {
-      if (outcome.kind === "network") return failure9("unreachable");
-      if (outcome.kind === "http") return failure9(reasonOfStatus(outcome.status));
-      return failure9("error");
+      if (outcome.kind === "network") return failure11("unreachable");
+      if (outcome.kind === "http") return failure11(reasonOfStatus2(outcome.status));
+      return failure11("error");
     }
     const view = projectMemoryConfig(outcome.body);
     if (view === void 0) {
       this.deps.log?.("hiwork-core: \u7F51\u5173\u8FD4\u56DE\u7684 memory-config \u4E0D\u5B8C\u6574\uFF08\u7F3A panel_url / service_id / api_key \u4E4B\u4E00\uFF09");
-      return failure9("error");
+      return failure11("error");
     }
     this.cached = { sessionCookie, view, at: this.now() };
     return view;
@@ -6754,9 +7202,1352 @@ function provideOfficeRelay(ctx, deps) {
   };
 }
 
+// node_modules/.pnpm/@deepseek-ai+dsh-llm@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-llm/lib/index.js
+import { createRequire } from "node:module";
+
+// node_modules/.pnpm/@deepseek-ai+dsh-typert-protocol@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-typert-protocol/lib/index.js
+var RemoteError = class extends Error {
+  code;
+  details;
+  /** Structural marker: cross-realm/bundle identification never uses instanceof. */
+  isDSHRemoteError = true;
+  /**
+  * @param code - stable failure code declared in {@link RemoteErrorDetailsMap}.
+  * @param message - human diagnostic carried across the wire.
+  * @param details - structured payload typed by the code.
+  * @param options - standard Error options (`cause` survives in-process only).
+  */
+  constructor(code, message, details, options) {
+    super(message, options);
+    this.code = code;
+    this.details = details;
+    this.name = "RemoteError";
+  }
+};
+var TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+function isTypertRemoteSegment(value) {
+  return value !== "." && value !== ".." && TYPERT_REMOTE_SEGMENT_PATTERN.test(value);
+}
+var REMOTE_METHOD_DESCRIPTOR = "@deepseek-ai/dsh-typert-protocol/remote-methods";
+function bindTypertRemote(service, serviceKey, options = {}) {
+  validateName("service key", serviceKey);
+  const namespace = options.namespace ?? serviceKey;
+  validateName("namespace", namespace);
+  return Object.freeze({
+    service,
+    serviceKey,
+    namespace
+  });
+}
+var TypertRemoteService = class extends Service {
+  /** Visible binding consumed by the Gateway's source-mode discovery. */
+  typertRemote;
+  /**
+  * Register the Service and bind the same key to Typert Gateway.
+  * @param ctx - owning Cordis Context.
+  * @param serviceKey - exact Cordis service key and default wire namespace.
+  * @param options - optional distinct wire namespace.
+  */
+  constructor(ctx, serviceKey, options = {}) {
+    super(ctx, serviceKey);
+    this.typertRemote = bindTypertRemote(this, this.name, options);
+  }
+};
+function Remote(methodExportOrOptions, context) {
+  if (typeof methodExportOrOptions === "string") {
+    validateName("Remote export name", methodExportOrOptions);
+    return remoteDecorator({ kind: "direct" }, void 0, methodExportOrOptions);
+  }
+  if (typeof methodExportOrOptions === "object") {
+    if (remoteOptionMode(methodExportOrOptions) !== "stream" || Reflect.ownKeys(methodExportOrOptions).length !== 1) throw new TypeError('typert-protocol: Remote options must contain exactly mode: "stream"');
+    return remoteDecorator({ kind: "direct" }, "stream");
+  }
+  if (context === void 0) throw new TypeError("typert-protocol: Remote decorator context is missing");
+  addMarkerInitializer(context, { kind: "direct" });
+}
+function remoteOptionMode(options) {
+  return Reflect.get(options, "mode");
+}
+function remoteDecorator(invocation, mode, exportName) {
+  return function(_method, context) {
+    addMarkerInitializer(context, invocation, mode, exportName);
+  };
+}
+function readRemoteMethodDescriptor(prototype) {
+  const property2 = Object.getOwnPropertyDescriptor(prototype, REMOTE_METHOD_DESCRIPTOR);
+  if (property2 === void 0) return void 0;
+  const descriptor = property2.value;
+  if (descriptor === null || typeof descriptor !== "object") throw new TypeError("typert-protocol: Remote method descriptor must be an object");
+  const version2 = Reflect.get(descriptor, "version");
+  if (version2 !== 1) throw new TypeError(`typert-protocol: unsupported Remote method descriptor version ${String(version2)}`);
+  const methods = Reflect.get(descriptor, "methods");
+  if (!Array.isArray(methods)) throw new TypeError("typert-protocol: Remote method descriptor methods must be an array");
+  return descriptor;
+}
+function addMarkerInitializer(context, invocation, mode, exportName) {
+  if (context.private || context.static || typeof context.name !== "string") throw new TypeError("typert-protocol: Remote decorators require a public instance method with a string name");
+  const method = context.name;
+  context.addInitializer(function() {
+    const prototype = Object.getPrototypeOf(this);
+    if (prototype === null) throw new TypeError(`typert-protocol: cannot mark Remote method "${method}" on an object without a prototype`);
+    mark(prototype, method, invocation, mode, exportName);
+  });
+}
+function mark(prototype, method, invocation, mode, exportName) {
+  const descriptor = readRemoteMethodDescriptor(prototype);
+  const marker = Object.freeze({
+    method,
+    ...exportName === void 0 || exportName === method ? {} : { exportName },
+    ...mode === void 0 ? {} : { mode },
+    invocation: Object.freeze(invocation)
+  });
+  const current = descriptor?.methods.find((candidate) => candidate.method === method);
+  if (current !== void 0) {
+    if (current.exportName === marker.exportName && current.mode === marker.mode && sameInvocation(current.invocation, invocation)) return;
+    throw new Error(`typert-protocol: Remote method "${method}" has conflicting invocation markers`);
+  }
+  Object.defineProperty(prototype, REMOTE_METHOD_DESCRIPTOR, {
+    configurable: true,
+    value: Object.freeze({
+      version: 1,
+      methods: Object.freeze([...descriptor?.methods ?? [], marker])
+    })
+  });
+}
+function sameInvocation(left, right) {
+  if (left.kind === "direct") return right.kind === "direct";
+  if (right.kind === "direct") return false;
+  return left.context === right.context;
+}
+function validateName(subject, value) {
+  if (!isTypertRemoteSegment(value)) throw new TypeError(`typert-protocol: ${subject} must contain only RPC endpoint segment characters`);
+}
+
+// node_modules/.pnpm/@deepseek-ai+dsh-timeout@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-timeout/lib/index.js
+var MAX_TIMER_DELAY_MS = 2147483647;
+
+// node_modules/.pnpm/@deepseek-ai+dsh-llm@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-llm/lib/index.js
+function freezeMessage(message) {
+  return deepFreeze(structuredClone(message));
+}
+var HarnessError = class extends Error {
+  /** Stable machine-routable failure class (e.g. `RATE_LIMIT`); route on this, never by parsing `message`. */
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.code = code;
+    this.name = new.target.name;
+  }
+};
+var EMPTY_RESPONSE_CODE = "EMPTY_RESPONSE";
+var STRUCTURED_CONTEXT_OVERFLOW = new RegExp(String.raw`(?:^|[^a-z0-9])context[\s_-](?:length|window)[\s_-]` + String.raw`(?:exceed(?:ed|s)?|overflow(?:ed)?|limit[\s_-]exceeded)(?:$|[^a-z0-9])`, "i");
+var TOO_LARGE_FOR_CONTEXT = new RegExp(String.raw`\b(?:request|prompt|input|messages?)\s+(?:is\s+|are\s+)?` + String.raw`too\s+(?:large|long)\s+for\s+(?:(?:this|the)\s+)?` + String.raw`(?:model(?:'s)?\s+)?context(?:\s+window)?\b`, "i");
+var EXCEEDS_MODEL_CONTEXT = new RegExp(String.raw`\b(?:input|prompt|request|messages?)\b.{0,40}` + String.raw`\b(?:exceed(?:s|ed)?|overflows?|is\s+larger\s+than)\b.{0,40}` + String.raw`\b(?:the\s+)?(?:model(?:'s)?\s+)?context(?:\s+(?:length|window))?\b`, "i");
+var DEFAULT_MAX_RETRIES = 5;
+var DEFAULT_INITIAL_DELAY_MS = 500;
+var DEFAULT_MAX_DELAY_MS = 1e4;
+var DEFAULT_JITTER_RATIO = 0.1;
+var DEFAULT_RETRYABLE_CODES = Object.freeze([
+  EMPTY_RESPONSE_CODE,
+  "RATE_LIMIT",
+  "SERVER",
+  "TIMEOUT",
+  "TRANSPORT"
+]);
+var backoffSchema = Schema.object({
+  initialDelayMs: Schema.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_INITIAL_DELAY_MS),
+  maxDelayMs: Schema.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_MAX_DELAY_MS),
+  jitterRatio: Schema.number().min(0).max(1).default(DEFAULT_JITTER_RATIO)
+});
+var normalPolicySchema = Schema.object({
+  mode: Schema.const("normal").required(),
+  maxRetries: Schema.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(DEFAULT_MAX_RETRIES),
+  retryableCodes: Schema.array(Schema.string()).default([...DEFAULT_RETRYABLE_CODES]),
+  backoff: backoffSchema
+});
+var alwaysPolicySchema = Schema.object({
+  mode: Schema.const("always").required(),
+  backoff: backoffSchema
+});
+var RetryPolicySchema = Schema.union([normalPolicySchema, alwaysPolicySchema]);
+var NORMAL_POLICY_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "maxRetries",
+  "retryableCodes",
+  "backoff"
+]);
+var ALWAYS_POLICY_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "maxRetries",
+  "retryableCodes",
+  "backoff"
+]);
+var BACKOFF_KEYS = /* @__PURE__ */ new Set([
+  "initialDelayMs",
+  "maxDelayMs",
+  "jitterRatio"
+]);
+function validateKeys(value, allowed, path) {
+  for (const key of Object.keys(value)) if (!allowed.has(key)) throw new Error(`${path}: unknown key "${key}"`);
+}
+function resolveBackoff(config, path) {
+  if (config !== void 0) validateKeys(config, BACKOFF_KEYS, path);
+  const initialDelayMs = config?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+  const maxDelayMs = config?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  const jitterRatio = config?.jitterRatio ?? DEFAULT_JITTER_RATIO;
+  if (!Number.isFinite(initialDelayMs) || initialDelayMs <= 0 || initialDelayMs > MAX_TIMER_DELAY_MS) throw new Error(`${path}.initialDelayMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+  if (!Number.isFinite(maxDelayMs) || maxDelayMs <= 0 || maxDelayMs > MAX_TIMER_DELAY_MS) throw new Error(`${path}.maxDelayMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+  if (initialDelayMs > maxDelayMs) throw new Error(`${path}.initialDelayMs must be less than or equal to maxDelayMs`);
+  if (!Number.isFinite(jitterRatio) || jitterRatio < 0 || jitterRatio > 1) throw new Error(`${path}.jitterRatio must be between 0 and 1`);
+  return Object.freeze({
+    initialDelayMs,
+    maxDelayMs,
+    jitterRatio
+  });
+}
+function resolveRetryPolicy(config, path) {
+  if (config === void 0) return Object.freeze({
+    mode: "normal",
+    maxRetries: DEFAULT_MAX_RETRIES,
+    retryableCodes: DEFAULT_RETRYABLE_CODES,
+    ...resolveBackoff(void 0, `${path}.backoff`)
+  });
+  switch (config.mode) {
+    case "normal": {
+      validateKeys(config, NORMAL_POLICY_KEYS, path);
+      const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+      const retryableCodes = config.retryableCodes ?? [...DEFAULT_RETRYABLE_CODES];
+      if (!Number.isSafeInteger(maxRetries) || maxRetries < 0) throw new Error(`${path}.maxRetries must be a non-negative safe integer`);
+      if (retryableCodes.length === 0) throw new Error(`${path}.retryableCodes must not be empty`);
+      if (retryableCodes.some((code) => typeof code !== "string" || code.length === 0)) throw new Error(`${path}.retryableCodes must contain only non-empty strings`);
+      if (new Set(retryableCodes).size !== retryableCodes.length) throw new Error(`${path}.retryableCodes must not contain duplicates`);
+      return Object.freeze({
+        mode: "normal",
+        maxRetries,
+        retryableCodes: Object.freeze([...retryableCodes]),
+        ...resolveBackoff(config.backoff, `${path}.backoff`)
+      });
+    }
+    case "always":
+      validateKeys(config, ALWAYS_POLICY_KEYS, path);
+      return Object.freeze({
+        mode: "always",
+        ...resolveBackoff(config.backoff, `${path}.backoff`)
+      });
+    default:
+      throw new Error(`${path}.mode must be "normal" or "always"`);
+  }
+}
+function callConfigEquals(a, b) {
+  if (a.provider !== b.provider || a.model !== b.model || a.reasoningEffort !== b.reasoningEffort || a.temperature !== b.temperature || a.maxTokens !== b.maxTokens) return false;
+  if (a.stop === void 0 || b.stop === void 0) return a.stop === b.stop;
+  return a.stop.length === b.stop.length && a.stop.every((s, i) => s === b.stop?.[i]);
+}
+function normalizeLlmFailure(value) {
+  const error = value instanceof Error ? value : new HarnessError(thrownMessage(value), "UNKNOWN", { cause: value });
+  const carried = ownFailureSnapshot(error);
+  if (carried !== void 0 && carried.code === ownErrorCode(error)) return carried;
+  return Object.freeze({
+    message: errorMessage(error),
+    code: harnessErrorCode(error)
+  });
+}
+function thrownMessage(value) {
+  try {
+    const message = String(value);
+    return message.length > 0 ? message : "LLM adapter failed";
+  } catch (_hostileThrownValue) {
+    return "LLM adapter failed";
+  }
+}
+function ownErrorCode(error) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+    return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+  } catch (_sdkPropertyTrap) {
+    return;
+  }
+}
+function ownFailureSnapshot(error) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(error, "failure");
+    return descriptor !== void 0 && "value" in descriptor ? failureSnapshot(descriptor.value) : void 0;
+  } catch (_sdkPropertyTrap) {
+    return;
+  }
+}
+function failureSnapshot(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  try {
+    const candidate = value;
+    const message = candidate.message;
+    const code = candidate.code;
+    const status = candidate.status;
+    const providerRetryAfterMs = candidate.providerRetryAfterMs;
+    const requestId = candidate.requestId;
+    if (typeof message !== "string" || message.length === 0 || typeof code !== "string" || code.length === 0 || status !== void 0 && (!Number.isInteger(status) || status < 100 || status > 599) || providerRetryAfterMs !== void 0 && (!Number.isFinite(providerRetryAfterMs) || providerRetryAfterMs <= 0) || requestId !== void 0 && (typeof requestId !== "string" || requestId.length === 0)) return void 0;
+    return Object.freeze({
+      message,
+      code,
+      ...status === void 0 ? {} : { status },
+      ...providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs },
+      ...requestId === void 0 ? {} : { requestId }
+    });
+  } catch (_sdkFailureGetter) {
+    return;
+  }
+}
+function errorMessage(error) {
+  try {
+    const message = error.message;
+    if (typeof message === "string" && message.length > 0) return message;
+  } catch (_sdkMessageGetter) {
+  }
+  return "LLM adapter failed";
+}
+function harnessErrorCode(error) {
+  return error instanceof HarnessError ? error.code : "UNKNOWN";
+}
+function quoted(value) {
+  return JSON.stringify(value);
+}
+function textOnlyImageText(ref) {
+  return `[image omitted because this model accepts text only; attachment sha256:${String(ref.attachmentId).slice(7, 15)}]`;
+}
+function contentHasImage(content) {
+  return content.some((block) => block.type === "image" || block.type === "tool-result" && contentHasImage(block.content));
+}
+function contentHasFile(content) {
+  for (const block of content) if (block.type === "file" || block.type === "tool-result" && contentHasFile(block.content)) return true;
+  return false;
+}
+function fileHandleText(ref, readonlyPath) {
+  const digest = String(ref.attachmentId).slice(7, 15);
+  const identity = `File ${quoted(ref.name)} (${ref.bytes} bytes, sha256:${digest})`;
+  if (readonlyPath === void 0) return `[${identity} was uploaded, but the current execution environment cannot access a readable path. Report that limitation if its contents are needed; do not claim to have read it.]`;
+  return `[${identity}: verbatim read-only copy saved at ${quoted(readonlyPath)}. Read that path with your file tools when its contents are needed; copy it to a writable location before modifying it. When delegating file work, include this saved path in the delegation prompt; only subagents sharing this execution environment can read it.]`;
+}
+function replaceFilesWithHandles(blocks, resolvePath) {
+  let next;
+  for (const [index, block] of blocks.entries()) {
+    if (block.type === "file") {
+      next ??= blocks.slice(0, index);
+      next.push({
+        type: "text",
+        text: fileHandleText(block.attachment, resolvePath(block.attachment))
+      });
+      continue;
+    }
+    if (block.type === "tool-result") {
+      const content = replaceFilesWithHandles(block.content, resolvePath);
+      if (content !== block.content) {
+        next ??= blocks.slice(0, index);
+        next.push({
+          ...block,
+          content
+        });
+        continue;
+      }
+    }
+    next?.push(block);
+  }
+  return next ?? blocks;
+}
+function projectFilesToText(messages, resolvePath) {
+  if (!messages.some((message) => contentHasFile(message.content))) return messages;
+  return messages.map((message) => {
+    const content = replaceFilesWithHandles(message.content, resolvePath);
+    return content === message.content ? message : {
+      ...message,
+      content
+    };
+  });
+}
+function replaceImagesForTextModel(blocks) {
+  let next;
+  for (const [index, block] of blocks.entries()) {
+    if (block.type === "image") {
+      next ??= blocks.slice(0, index);
+      next.push({
+        type: "text",
+        text: textOnlyImageText(block.attachment)
+      });
+      continue;
+    }
+    if (block.type === "tool-result") {
+      const content = replaceImagesForTextModel(block.content);
+      if (content !== block.content) {
+        next ??= blocks.slice(0, index);
+        next.push({
+          ...block,
+          content
+        });
+        continue;
+      }
+    }
+    next?.push(block);
+  }
+  return next ?? blocks;
+}
+function projectImagesForTextModel(messages) {
+  if (!messages.some((message) => contentHasImage(message.content))) return messages;
+  return messages.map((message) => {
+    const content = replaceImagesForTextModel(message.content);
+    return content === message.content ? message : {
+      ...message,
+      content
+    };
+  });
+}
+var { version } = createRequire(import.meta.url)("../package.json");
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? {
+      get: descriptor.get,
+      set: descriptor.set
+    } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+    else descriptor[key] = _;
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var LlmError = class extends HarnessError {
+  /** Serializable facts retained beside this live Error. */
+  failure;
+  /**
+  * @param message - non-empty human-readable failure summary.
+  * @param code - non-empty stable provider-neutral machine code.
+  * @param options - optional cause and validated serializable provider facts.
+  */
+  constructor(message, code, options) {
+    if (typeof message !== "string" || message.length === 0) throw new Error("LlmError message must be a non-empty string");
+    if (typeof code !== "string" || code.length === 0) throw new Error("LlmError code must be a non-empty string");
+    if (options?.status !== void 0 && (!Number.isInteger(options.status) || options.status < 100 || options.status > 599)) throw new Error("LlmError status must be an integer from 100 through 599");
+    if (options?.providerRetryAfterMs !== void 0 && (!Number.isFinite(options.providerRetryAfterMs) || options.providerRetryAfterMs <= 0)) throw new Error("LlmError providerRetryAfterMs must be a positive finite number");
+    if (options?.requestId !== void 0 && (typeof options.requestId !== "string" || options.requestId.length === 0)) throw new Error("LlmError requestId must be a non-empty string");
+    super(message, code, options);
+    this.name = "LlmError";
+    this.failure = Object.freeze({
+      message,
+      code,
+      ...options?.status === void 0 ? {} : { status: options.status },
+      ...options?.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: options.providerRetryAfterMs },
+      ...options?.requestId === void 0 ? {} : { requestId: options.requestId }
+    });
+  }
+};
+var LlmRuntime = (() => {
+  let _classSuper = TypertRemoteService;
+  let _instanceExtraInitializers = [];
+  let _listProviders_decorators;
+  let _listConfigurableProviders_decorators;
+  let _remoteDiscoverModels_decorators;
+  return class LlmRuntime extends _classSuper {
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _listProviders_decorators = [Remote];
+      _listConfigurableProviders_decorators = [Remote];
+      _remoteDiscoverModels_decorators = [Remote("discoverModels")];
+      __esDecorate(this, null, _listProviders_decorators, {
+        kind: "method",
+        name: "listProviders",
+        static: false,
+        private: false,
+        access: {
+          has: (obj) => "listProviders" in obj,
+          get: (obj) => obj.listProviders
+        },
+        metadata: _metadata
+      }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _listConfigurableProviders_decorators, {
+        kind: "method",
+        name: "listConfigurableProviders",
+        static: false,
+        private: false,
+        access: {
+          has: (obj) => "listConfigurableProviders" in obj,
+          get: (obj) => obj.listConfigurableProviders
+        },
+        metadata: _metadata
+      }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _remoteDiscoverModels_decorators, {
+        kind: "method",
+        name: "remoteDiscoverModels",
+        static: false,
+        private: false,
+        access: {
+          has: (obj) => "remoteDiscoverModels" in obj,
+          get: (obj) => obj.remoteDiscoverModels
+        },
+        metadata: _metadata
+      }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: _metadata
+      });
+    }
+    adapters = (__runInitializers(this, _instanceExtraInitializers), /* @__PURE__ */ new Map());
+    directory = /* @__PURE__ */ new Map();
+    discoveries = /* @__PURE__ */ new Map();
+    constructor(ctx) {
+      super(ctx, "llm");
+    }
+    /** Notify topology observers without letting one broken listener veto the commit. */
+    emitAdaptersUpdated() {
+      let invariantFailure;
+      for (const listener of this.ctx.events.dispatch("emit", ["llm/adapters-updated"])) try {
+        const returned = listener();
+        if (returned != null && typeof returned.then === "function") Promise.resolve(returned).then(void 0, (error) => {
+          this.warnAdaptersListenerFailure(error);
+        });
+      } catch (error) {
+        if (error?.code === "INVARIANT") {
+          invariantFailure ??= error;
+          continue;
+        }
+        this.warnAdaptersListenerFailure(error);
+      }
+      if (invariantFailure !== void 0) throw invariantFailure;
+    }
+    /** Contained-listener diagnostic shared by the sync and async failure paths. */
+    warnAdaptersListenerFailure(error) {
+      this.ctx.logger.warn("llm: an llm/adapters-updated listener failed");
+      this.ctx.logger.warn(error);
+    }
+    /**
+    * Register an adapter for the given provider routes. Throws `LlmError` with code
+    * `DUPLICATE_ADAPTER` if any provider already has an adapter (all-or-nothing).
+    * Disposed with the fiber.
+    * @param providers - every provider route this adapter should serve.
+    * @param adapter - the adapter that streams calls for those providers.
+    * @returns the disposer, carrying {@link AdapterRegistrationHandle.replace}.
+    */
+    registerAdapter(providers, adapter) {
+      const owned = /* @__PURE__ */ new Set();
+      let released = false;
+      const dispose = this.ctx.effect(function* () {
+        if (providers.length === 0) throw new LlmError("an adapter must register at least one provider", "INVALID_ADAPTER");
+        this.commitRoutes(owned, this.prepareRoutes(providers, adapter, owned));
+        yield () => {
+          released = true;
+          for (const provider of owned) this.adapters.delete(provider);
+          owned.clear();
+          this.emitAdaptersUpdated();
+        };
+      }.bind(this), "llm.registerAdapter()");
+      const handle = () => void dispose();
+      handle.replace = (next) => {
+        if (released) throw new LlmError("a disposed adapter registration cannot replace its routes", "REGISTRATION_DISPOSED");
+        this.commitRoutes(owned, this.prepareRoutes(next, adapter, owned));
+      };
+      return handle;
+    }
+    /**
+    * Validate one candidate route set for `adapter`, treating routes this
+    * registration already holds as available. Nothing is mutated: a rejected
+    * candidate leaves the registry exactly as it was.
+    */
+    prepareRoutes(providers, adapter, owned) {
+      const unique = /* @__PURE__ */ new Set();
+      const registrations = [];
+      for (const provider of providers) {
+        if (provider.length === 0) throw new LlmError("adapter provider names must be non-empty", "INVALID_ADAPTER");
+        if (unique.has(provider) || this.adapters.has(provider) && !owned.has(provider)) throw new LlmError(`an adapter for provider "${provider}" is already registered`, "DUPLICATE_ADAPTER");
+        const info = adapter.providerInfo(provider);
+        if (typeof info.id !== "string" || info.id !== provider || typeof info.name !== "string" || info.name.length === 0) throw new LlmError(`adapter metadata for provider "${provider}" must preserve its id and have a non-empty name`, "INVALID_ADAPTER");
+        unique.add(provider);
+        const retryPolicy = adapter.providerRetryPolicy(provider) ?? resolveRetryPolicy(void 0, `llm: provider "${provider}" retryPolicy`);
+        registrations.push({
+          adapter,
+          provider: {
+            id: info.id,
+            name: info.name
+          },
+          retryPolicy
+        });
+      }
+      return registrations;
+    }
+    /**
+    * Swap this registration's routes for the prepared ones in one synchronous
+    * section, so no observer can see the registry between the release and the
+    * re-registration. The route set's one mutation point is also where
+    * `llm/adapters-updated` is published, so a `replace` announces itself
+    * exactly like a first registration.
+    */
+    commitRoutes(owned, registrations) {
+      for (const provider of owned) this.adapters.delete(provider);
+      owned.clear();
+      for (const registration of registrations) {
+        this.adapters.set(registration.provider.id, registration);
+        owned.add(registration.provider.id);
+      }
+      this.emitAdaptersUpdated();
+    }
+    /**
+    * Describe provider routes with a registered adapter.
+    * @returns detached provider metadata in registration order.
+    */
+    listProviders() {
+      return [...this.adapters.values()].map(({ provider }) => ({ ...provider }));
+    }
+    /**
+    * Declare provider routes an adapter plugin can activate through
+    * configuration. Registration is all-or-nothing: an empty list, invalid
+    * entry, or a provider already declared by any registration throws
+    * `LlmError` without registering the rest. Disposed with the fiber.
+    * @param entries - every configurable provider this plugin owns.
+    * @returns a handle that withdraws all of them, and can atomically replace them.
+    */
+    registerConfigurableProviders(entries) {
+      let held = [];
+      let disposed = false;
+      const commit = (candidates) => {
+        const detached = [];
+        const own = new Set(held.map((entry) => entry.provider));
+        for (const entry of candidates) {
+          if (entry.provider.length === 0 || entry.displayName.length === 0 || entry.settingsNs.length === 0) throw new LlmError("configurable providers need a non-empty provider, displayName, and settingsNs", "INVALID_DIRECTORY");
+          if (entry.settingsPath.some((segment) => segment.length === 0)) throw new LlmError(`configurable provider "${entry.provider}" has an empty settingsPath segment`, "INVALID_DIRECTORY");
+          if (this.directory.has(entry.provider) && !own.has(entry.provider) || detached.some((seen) => seen.provider === entry.provider)) throw new LlmError(`configurable provider "${entry.provider}" is already declared`, "DUPLICATE_DIRECTORY");
+          detached.push({
+            ...entry,
+            settingsPath: [...entry.settingsPath]
+          });
+        }
+        for (const entry of held) this.directory.delete(entry.provider);
+        for (const entry of detached) this.directory.set(entry.provider, entry);
+        held = detached;
+        this.emitAdaptersUpdated();
+      };
+      const dispose = this.ctx.effect(function* () {
+        if (entries.length === 0) throw new LlmError("a configurable-provider registration must declare at least one provider", "INVALID_DIRECTORY");
+        commit(entries);
+        yield () => {
+          disposed = true;
+          for (const entry of held) this.directory.delete(entry.provider);
+          held = [];
+          this.emitAdaptersUpdated();
+        };
+      }.bind(this), "llm.registerConfigurableProviders()");
+      const handle = () => void dispose();
+      handle.replace = (next) => {
+        if (disposed) throw new LlmError("this configurable-provider registration was disposed", "REGISTRATION_DISPOSED");
+        commit(next);
+      };
+      return handle;
+    }
+    /**
+    * List every declared configurable provider, registered or dormant.
+    * @returns detached directory entries in declaration order.
+    */
+    listConfigurableProviders() {
+      return [...this.directory.values()].map((entry) => ({
+        ...entry,
+        settingsPath: [...entry.settingsPath]
+      }));
+    }
+    /**
+    * Offer to interrogate provider endpoints on behalf of the settings
+    * namespace this plugin owns. The namespace is the key because that is what
+    * a configuration surface already holds from the configurable-provider
+    * directory, and because a provider being *added* has no route to name yet.
+    * Disposed with the fiber.
+    * @param settingsNs - the namespace whose profiles this discovery serves.
+    * @param discover - interrogates one endpoint and must honor the supplied signal.
+    * @returns the disposer that withdraws the offer.
+    */
+    registerModelDiscovery(settingsNs, discover) {
+      const dispose = this.ctx.effect(function* () {
+        if (settingsNs.length === 0) throw new LlmError("model discovery needs a non-empty settings namespace", "INVALID_DISCOVERY");
+        if (this.discoveries.has(settingsNs)) throw new LlmError(`model discovery for "${settingsNs}" is already registered`, "DUPLICATE_DISCOVERY");
+        this.discoveries.set(settingsNs, discover);
+        yield () => {
+          this.discoveries.delete(settingsNs);
+        };
+      }.bind(this), "llm.registerModelDiscovery()");
+      return () => void dispose();
+    }
+    /**
+    * Interrogate one provider endpoint for the models it advertises. The
+    * request describes a draft, not a stored route, so nothing here reads or
+    * writes settings or credentials — the caller owns both, and the reply is
+    * candidate metadata a surface may offer for adoption.
+    * @param settingsNs - namespace whose registered discovery serves this draft.
+    * @param request - the endpoint, protocol, and one-shot credential to use.
+    * @param signal - caller cancellation.
+    * @returns the advertised models, deduplicated in endpoint order.
+    */
+    async discoverModels(settingsNs, request, signal) {
+      const discover = this.discoveries.get(settingsNs);
+      if (discover === void 0) throw new LlmError(`no model discovery is registered for "${settingsNs}"`, "NO_DISCOVERY");
+      if ((request.provider ?? "").length === 0 && (request.baseURL ?? "").length === 0) throw new LlmError("model discovery needs a provider route or a baseURL", "INVALID_DISCOVERY");
+      const discovered = signal === void 0 ? await discover(request) : await discover(request, signal);
+      const seen = /* @__PURE__ */ new Set();
+      const models = [];
+      for (const model of discovered) {
+        if (typeof model.id !== "string" || model.id.length === 0 || seen.has(model.id)) continue;
+        seen.add(model.id);
+        models.push({
+          id: model.id,
+          ...model.name === void 0 ? {} : { name: model.name },
+          ...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+          ...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens }
+        });
+      }
+      return models;
+    }
+    /**
+    * Remote adapter for one draft provider interrogation.
+    * @param settingsNs - namespace whose registered discovery serves this draft.
+    * @param request - endpoint, protocol, and one-shot credential to use.
+    * @param signal - caller cancellation supplied by the Remote carrier.
+    * @returns advertised models in endpoint order.
+    * @throws RemoteError with `llm/model-discovery-rejected` when discovery refuses or fails.
+    */
+    async remoteDiscoverModels(settingsNs, request, signal) {
+      try {
+        return await this.discoverModels(settingsNs, request, signal);
+      } catch (error) {
+        throw new RemoteError("llm/model-discovery-rejected", error instanceof Error ? error.message : String(error), {
+          settingsNs,
+          ...request.baseURL === void 0 ? {} : { baseURL: request.baseURL }
+        }, { cause: error });
+      }
+    }
+    /**
+    * Resolve the retry policy captured when one provider route was registered.
+    * @param provider - registered provider route to inspect.
+    * @returns the provider-owned policy, with normal defaults already resolved.
+    */
+    providerRetryPolicy(provider) {
+      return this.registration(provider).retryPolicy;
+    }
+    /**
+    * Resolve provider-side request-image pricing for one exact route, or
+    * `undefined` when the provider is unregistered or declares none. Unknown
+    * providers degrade to `undefined` rather than throwing because callers
+    * price durable history whose route may no longer be mounted.
+    * @param provider - provider route named by a request header.
+    * @param model - exact model id named by the same header.
+    * @returns the owning adapter's image pricing for the route, when declared.
+    */
+    imageRequestPricing(provider, model) {
+      return this.adapters.get(provider)?.adapter.imageRequestPricing(provider, model);
+    }
+    /**
+    * Resolve the exact text one durable file occurrence contributes to every
+    * provider request in the current execution environment.
+    * @param ref - durable verbatim file reference from model history.
+    * @returns the same deterministic handle text used at adapter dispatch.
+    */
+    fileRequestText(ref) {
+      return fileHandleText(ref, this.fileReadPath(ref));
+    }
+    /** Detach typed adapter-owned modality metadata. */
+    detachedModalities(modalities) {
+      return modalities === void 0 ? void 0 : [...modalities];
+    }
+    /**
+    * Discover models advertised by one registered provider. Catalog membership
+    * is advisory and never changes routing or request validation.
+    * @param provider - registered provider route to inspect.
+    * @returns detached model metadata in adapter-preferred order.
+    */
+    async listModels(provider) {
+      const models = await this.registration(provider).adapter.listModels(provider);
+      const seen = /* @__PURE__ */ new Set();
+      return models.map((model) => {
+        if (typeof model.provider !== "string" || model.provider !== provider || typeof model.id !== "string" || model.id.length === 0 || typeof model.name !== "string" || model.name.length === 0 || model.description !== void 0 && typeof model.description !== "string" || seen.has(model.id)) throw new LlmError(`adapter returned invalid or duplicate model metadata for provider "${provider}"`, "INVALID_CATALOG");
+        seen.add(model.id);
+        const inputModalities = this.detachedModalities(model.inputModalities);
+        return {
+          provider: model.provider,
+          id: model.id,
+          name: model.name,
+          ...model.description === void 0 ? {} : { description: model.description },
+          ...inputModalities === void 0 ? {} : { inputModalities }
+        };
+      });
+    }
+    /**
+    * Resolve and validate all metadata from the adapter that owns one exact
+    * route. The result is detached from adapter-owned objects; catalog
+    * membership remains advisory and does not control request routing.
+    * @param provider - registered provider route to inspect.
+    * @param model - exact model id passed to the adapter.
+    * @param signal - optional cancellation for adapter-owned asynchronous lookup.
+    * @returns exact model identity plus available context and reasoning metadata.
+    */
+    async resolveModelInfo(provider, model, signal) {
+      return this.resolveModelInfoFor(this.registration(provider), model, signal);
+    }
+    async resolveModelInfoFor(registration, model, signal) {
+      const resolved = await registration.adapter.resolveModel(registration.provider.id, model, signal);
+      return this.normalizeModelInfo(registration, model, resolved);
+    }
+    /** Validate and detach one adapter-returned exact model result. */
+    normalizeModelInfo(registration, model, resolved) {
+      const provider = registration.provider.id;
+      if (typeof resolved.provider !== "string" || resolved.provider !== provider || typeof resolved.id !== "string" || resolved.id !== model || typeof resolved.name !== "string" || resolved.name.length === 0 || resolved.description !== void 0 && typeof resolved.description !== "string") throw new LlmError(`adapter returned invalid exact model metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_INFO");
+      const context = resolved.context;
+      if (context !== void 0 && (!Number.isInteger(context.contextWindow) || context.contextWindow <= 0)) throw new LlmError(`adapter returned invalid context metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_CONTEXT");
+      const inputModalities = this.detachedModalities(resolved.inputModalities);
+      const systemPromptUpdate = resolved.systemPromptUpdate;
+      if (systemPromptUpdate !== void 0 && systemPromptUpdate !== "in-history") throw new LlmError(`adapter returned invalid system prompt update mode for provider "${provider}" model "${model}"`, "INVALID_MODEL_INFO");
+      const defaultMaxTokens = resolved.defaultMaxTokens;
+      if (defaultMaxTokens !== void 0 && (!Number.isSafeInteger(defaultMaxTokens) || defaultMaxTokens <= 0)) throw new LlmError(`adapter returned invalid default maxTokens for provider "${provider}" model "${model}"`, "INVALID_MODEL_MAX_TOKENS");
+      const info = {
+        provider,
+        id: model,
+        name: resolved.name,
+        ...resolved.description === void 0 ? {} : { description: resolved.description },
+        ...inputModalities === void 0 ? {} : { inputModalities },
+        ...context === void 0 ? {} : { context: { contextWindow: context.contextWindow } },
+        ...defaultMaxTokens === void 0 ? {} : { defaultMaxTokens },
+        ...resolved.systemPromptUpdate === void 0 ? {} : { systemPromptUpdate: resolved.systemPromptUpdate }
+      };
+      const reasoning = resolved.reasoning;
+      if (reasoning === void 0) return info;
+      if (reasoning.efforts.length === 0) throw new LlmError(`adapter returned invalid reasoning metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+      const seen = /* @__PURE__ */ new Set();
+      const efforts = reasoning.efforts.map((effort) => {
+        if (typeof effort.id !== "string" || effort.id.length === 0 || typeof effort.name !== "string" || effort.name.length === 0 || effort.description !== void 0 && typeof effort.description !== "string" || seen.has(effort.id)) throw new LlmError(`adapter returned invalid or duplicate reasoning effort metadata for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+        seen.add(effort.id);
+        return {
+          id: effort.id,
+          name: effort.name,
+          ...effort.description === void 0 ? {} : { description: effort.description }
+        };
+      });
+      if (reasoning.defaultEffort !== void 0 && !seen.has(reasoning.defaultEffort)) throw new LlmError(`adapter returned an unknown default reasoning effort for provider "${provider}" model "${model}"`, "INVALID_MODEL_REASONING");
+      return {
+        ...info,
+        reasoning: {
+          efforts,
+          ...reasoning.defaultEffort === void 0 ? {} : { defaultEffort: reasoning.defaultEffort }
+        }
+      };
+    }
+    /**
+    * Validate a conversation call config against its exact model capability and
+    * materialize adapter-configured defaults. Unsupported explicit efforts
+    * reject before provider I/O; no clamping or aliasing is performed. This
+    * standalone query does not bind a later dispatch; use {@link prepareCall}
+    * when logging and streaming must share one adapter registration.
+    * @param config - provider/model route and optional request controls.
+    * @param signal - optional cancellation for adapter-owned capability lookup.
+    * @returns a detached config only when a default must be materialized.
+    */
+    async resolveCallConfig(config, signal) {
+      return (await this.resolveCallFor(this.registration(config.provider), config, signal)).config;
+    }
+    async resolveCallFor(registration, config, signal) {
+      const info = await this.resolveModelInfoFor(registration, config.model, signal);
+      return this.resolveCallWithInfo(config, info);
+    }
+    /** Validate request controls against one already-bound exact model result. */
+    resolveCallWithInfo(config, info) {
+      const defaulted = config.maxTokens === void 0 && info.defaultMaxTokens !== void 0 ? {
+        ...config,
+        maxTokens: info.defaultMaxTokens
+      } : config;
+      const reasoning = info.reasoning;
+      const requested = defaulted.reasoningEffort;
+      let resolvedConfig = defaulted;
+      if (reasoning === void 0) {
+        if (requested !== void 0) throw new LlmError(`provider "${config.provider}" model "${config.model}" does not support reasoning effort "${requested}"`, "UNSUPPORTED_REASONING_EFFORT");
+      } else {
+        const effective = requested ?? reasoning.defaultEffort;
+        if (effective !== void 0) {
+          if (!reasoning.efforts.some((effort) => effort.id === effective)) throw new LlmError(`provider "${config.provider}" model "${config.model}" does not support reasoning effort "${effective}"`, "UNSUPPORTED_REASONING_EFFORT");
+          if (requested !== effective) resolvedConfig = {
+            ...defaulted,
+            reasoningEffort: effective
+          };
+        }
+      }
+      return {
+        config: resolvedConfig,
+        ...info.context === void 0 ? {} : { context: info.context },
+        modelInfo: info
+      };
+    }
+    /**
+    * Resolve one call under its current adapter registration. The returned
+    * one-shot handle keeps that registration across header logging and dispatch,
+    * so HMR cannot combine one adapter's capability result with another adapter.
+    * @param config - provider/model route and optional request controls.
+    * @param signal - optional cancellation for adapter-owned capability lookup.
+    * @returns a prepared config and its registration-bound stream entry point.
+    */
+    async prepareCall(config, signal) {
+      const registration = this.registration(config.provider);
+      const adapterCall = await registration.adapter.prepareCall(config.provider, config.model, signal);
+      const modelInfo = this.normalizeModelInfo(registration, config.model, adapterCall.model);
+      const resolved = this.resolveCallWithInfo(config, modelInfo);
+      const resolvedConfig = deepFreeze(structuredClone(resolved.config));
+      const context = resolved.context === void 0 ? void 0 : deepFreeze(structuredClone(resolved.context));
+      const adapterDefaults = deepFreeze({
+        ...config.reasoningEffort === void 0 && resolvedConfig.reasoningEffort !== void 0 ? { reasoningEffort: true } : {},
+        ...config.maxTokens === void 0 && resolvedConfig.maxTokens !== void 0 ? { maxTokens: true } : {}
+      });
+      let dispatched = false;
+      return Object.freeze({
+        config: resolvedConfig,
+        retryPolicy: registration.retryPolicy,
+        adapterDefaults,
+        ...context === void 0 ? {} : { context },
+        ...modelInfo.inputModalities === void 0 ? {} : { inputModalities: Object.freeze([...modelInfo.inputModalities]) },
+        ...modelInfo.systemPromptUpdate === void 0 ? {} : { systemPromptUpdate: modelInfo.systemPromptUpdate },
+        stream: (options) => {
+          if (dispatched) throw new LlmError("a prepared LLM call can only be dispatched once", "INVALID_PREPARED_CALL");
+          if (!callConfigEquals(options, resolvedConfig)) throw new LlmError("prepared LLM call config changed before adapter dispatch", "INVALID_PREPARED_CALL");
+          dispatched = true;
+          return this.streamWithRegistration(options, {
+            registration,
+            config: resolvedConfig,
+            modelInfo,
+            dispatch: (options2) => adapterCall.stream(options2)
+          });
+        }
+      });
+    }
+    registration(provider) {
+      const registration = this.adapters.get(provider);
+      if (!registration) throw new LlmError(`no adapter registered for provider "${provider}"`, "NO_ADAPTER");
+      return registration;
+    }
+    /** Remove replay state whose historical route is owned by another adapter. */
+    forAdapter(options, adapter) {
+      const messages = options.messages.map((message) => {
+        const source = message.source;
+        if (message.role !== "assistant" || source.kind !== "model" || source.replayState === void 0) return message;
+        if (this.adapters.get(source.provider)?.adapter === adapter) return message;
+        return freezeMessage({
+          ...message,
+          source: {
+            kind: "model",
+            provider: source.provider,
+            model: source.model
+          }
+        });
+      });
+      if (messages.every((message, index) => message === options.messages[index])) return options;
+      const filtered = {
+        ...options,
+        messages
+      };
+      return Object.isFrozen(options) ? deepFreeze(filtered) : filtered;
+    }
+    /**
+    * Resolve the current execution-world read path of one durable file
+    * reference through the mounted attachment and filesystem providers.
+    */
+    fileReadPath(ref) {
+      let hostPath;
+      try {
+        hostPath = this.ctx.get("attachments")?.fileHostPath(ref);
+      } catch {
+        return;
+      }
+      if (hostPath === void 0) return void 0;
+      return this.ctx.get("fs")?.processPathFromHostPath(hostPath);
+    }
+    /**
+    * Final adapter boundary. Adapter selection, dispatch, iterator construction,
+    * and iteration failures become one terminal failure chunk. Middleware and
+    * downstream consumer failures remain thrown plugin or consumer errors.
+    */
+    async *adapterStream(options, prepared) {
+      let iterator;
+      try {
+        const registration = prepared?.registration ?? this.registration(options.provider);
+        const adapter = registration.adapter;
+        let modelInfo;
+        let resolvedConfig;
+        let dispatch;
+        if (prepared === void 0) {
+          const adapterCall = await adapter.prepareCall(options.provider, options.model, options.signal);
+          modelInfo = this.normalizeModelInfo(registration, options.model, adapterCall.model);
+          resolvedConfig = this.resolveCallWithInfo(options, modelInfo).config;
+          dispatch = (options2) => adapterCall.stream(options2);
+        } else {
+          modelInfo = prepared.modelInfo;
+          resolvedConfig = prepared.config;
+          dispatch = prepared.dispatch;
+        }
+        if (prepared !== void 0 && !callConfigEquals(options, resolvedConfig)) throw new LlmError("prepared LLM call config changed before adapter dispatch", "INVALID_PREPARED_CALL");
+        const resolvedOptions = callConfigEquals(options, resolvedConfig) ? options : Object.isFrozen(options) ? deepFreeze({
+          ...options,
+          ...resolvedConfig
+        }) : {
+          ...options,
+          ...resolvedConfig
+        };
+        let projectedMessages = resolvedOptions.messages;
+        if (projectedMessages.some((message) => contentHasFile(message.content))) projectedMessages = projectFilesToText(projectedMessages, (ref) => this.fileReadPath(ref));
+        if (modelInfo.inputModalities !== void 0 && !modelInfo.inputModalities.includes("image") && projectedMessages.some((message) => contentHasImage(message.content))) projectedMessages = projectImagesForTextModel(projectedMessages);
+        const projectedOptions = projectedMessages === resolvedOptions.messages ? resolvedOptions : Object.isFrozen(resolvedOptions) ? deepFreeze({
+          ...resolvedOptions,
+          messages: projectedMessages
+        }) : {
+          ...resolvedOptions,
+          messages: projectedMessages
+        };
+        iterator = dispatch(this.forAdapter(projectedOptions, adapter))[Symbol.asyncIterator]();
+      } catch (error) {
+        yield adapterFailureChunk(error, options.signal);
+        return;
+      }
+      let completed = false;
+      try {
+        while (true) {
+          let item;
+          try {
+            const next = await iterator.next();
+            item = next.done ? { done: true } : {
+              done: false,
+              value: next.value
+            };
+          } catch (error) {
+            completed = true;
+            yield adapterFailureChunk(error, options.signal);
+            return;
+          }
+          if (item.done) {
+            completed = true;
+            return;
+          }
+          yield item.value;
+        }
+      } finally {
+        if (!completed) {
+          const close = iterator.return?.bind(iterator);
+          if (close) await close();
+        }
+      }
+    }
+    /**
+    * Stream one model call as raw chunks (token-level deltas). Replay state is
+    * retained only when the same adapter instance owns its historical provider
+    * and the target provider. Final adapter selection remains fixed through
+    * asynchronous exact-model resolution and dispatch. Adapter selection,
+    * dispatch, and iteration failures become terminal `error` or `aborted`
+    * finish chunks; middleware, nested-call, cleanup, and consumer failures
+    * remain thrown.
+    * @param options - the full request; `options.provider` selects the adapter.
+    * @returns the chunk stream, possibly wrapped by `llm/stream` listeners.
+    */
+    stream(options) {
+      return this.streamWithRegistration(options);
+    }
+    streamWithRegistration(options, prepared) {
+      return this.ctx.waterfall(this, "llm/stream", options, () => this.adapterStream(options, prepared));
+    }
+  };
+})();
+function adapterFailureChunk(error, signal) {
+  const failure12 = normalizeLlmFailure(error);
+  return {
+    type: "finish",
+    reason: signal?.aborted || failure12.code === "ABORTED" ? {
+      kind: "aborted",
+      failure: failure12
+    } : {
+      kind: "error",
+      failure: failure12
+    }
+  };
+}
+
+// node_modules/.pnpm/@deepseek-ai+dsh-web@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2_@deepseek-ai+dsh-llm@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2_/node_modules/@deepseek-ai/dsh-web/lib/index.js
+var WebError = class extends HarnessError {
+};
+var WebRuntime = class extends Service {
+  /**
+  * Provider selection config. Operational env overrides feed the SAME fields:
+  * `$DSH_WEB_SEARCH_PROVIDER` / `$DSH_WEB_FETCH_PROVIDER` are equivalent to
+  * `searchProvider` / `fetchProvider` and are NOT a hidden priority chain.
+  */
+  static Config = Schema.object({
+    searchProvider: Schema.string(),
+    fetchProvider: Schema.string()
+  });
+  searchProviders = /* @__PURE__ */ new Map();
+  fetchProviders = /* @__PURE__ */ new Map();
+  searchProviderId;
+  fetchProviderId;
+  constructor(ctx, config = {}) {
+    super(ctx, "web");
+    this.searchProviderId = config.searchProvider ?? process.env.DSH_WEB_SEARCH_PROVIDER;
+    this.fetchProviderId = config.fetchProvider ?? process.env.DSH_WEB_FETCH_PROVIDER;
+  }
+  /**
+  * Register a search provider. Throws {@link WebError} `WEB_DUPLICATE_PROVIDER`
+  * if its id is already registered for search. Returns a disposer; disposed
+  * with the calling fiber.
+  * @param provider - the provider; its `id` is the registry key.
+  * @returns the disposer that unregisters the provider.
+  */
+  registerSearchProvider(provider) {
+    return this.registerProvider(this.searchProviders, provider);
+  }
+  /**
+  * Register a fetch provider. Throws {@link WebError} `WEB_DUPLICATE_PROVIDER`
+  * if its id is already registered for fetch. Returns a disposer; disposed
+  * with the calling fiber.
+  * @param provider - the provider; its `id` is the registry key.
+  * @returns the disposer that unregisters the provider.
+  */
+  registerFetchProvider(provider) {
+    return this.registerProvider(this.fetchProviders, provider);
+  }
+  registerProvider(store, provider) {
+    if (store.has(provider.id)) throw new WebError(`a web provider with id "${provider.id}" is already registered`, "WEB_DUPLICATE_PROVIDER");
+    const dispose = this.ctx.effect(function* () {
+      store.set(provider.id, provider);
+      yield () => store.delete(provider.id);
+    }, "web.registerProvider()");
+    return () => void dispose();
+  }
+  /**
+  * Run one search through the selected provider. Resolves the provider at call
+  * time with the selection rules above; throws {@link WebError} when the
+  * capability cannot run. The seam enforces `request.maxResults` on the result:
+  * if the provider over-returns, `sources[]` is truncated and `truncated` set.
+  * @param request - the query and optional result limit.
+  * @param signal - optional cancellation signal forwarded to the provider.
+  * @returns the provider's results, capped to `request.maxResults`.
+  */
+  async search(request, signal) {
+    return capSources(await resolveProvider({
+      providers: this.searchProviders,
+      ...this.searchProviderId !== void 0 ? { configuredId: this.searchProviderId } : {}
+    }).search(request, signal), request.maxResults);
+  }
+  /**
+  * Retrieve one URL through the selected provider. Resolves the provider at
+  * call time with the selection rules above; throws {@link WebError} when the
+  * capability cannot run. A non-2xx response is a result, not a throw.
+  * @param request - the URL plus retrieval options.
+  * @param signal - optional cancellation signal forwarded to the provider.
+  * @returns the retrieval outcome; non-2xx responses resolve descriptively.
+  */
+  async fetch(request, signal) {
+    return resolveProvider({
+      providers: this.fetchProviders,
+      ...this.fetchProviderId !== void 0 ? { configuredId: this.fetchProviderId } : {}
+    }).fetch(request, signal);
+  }
+};
+function resolveProvider(selection) {
+  const { configuredId, providers } = selection;
+  if (configuredId !== void 0) {
+    const provider = providers.get(configuredId);
+    if (!provider) throw new WebError(`configured web provider "${configuredId}" is not registered`, "WEB_PROVIDER_CONFIGURED_MISSING");
+    if (!provider.available()) throw new WebError(`configured web provider "${configuredId}" is registered but unavailable`, "WEB_PROVIDER_CONFIGURED_UNAVAILABLE");
+    return provider;
+  }
+  const usable = [...providers.values()].filter((provider) => provider.available());
+  const [single] = usable;
+  if (single === void 0) throw new WebError("no usable web provider is registered", "WEB_PROVIDER_UNAVAILABLE");
+  if (usable.length > 1) throw new WebError(`multiple usable web providers are registered (${usable.map((provider) => provider.id).join(", ")}); configure one explicitly`, "WEB_PROVIDER_AMBIGUOUS");
+  return single;
+}
+function capSources(result, maxResults) {
+  if (maxResults === void 0 || result.sources.length <= maxResults) return result;
+  return {
+    ...result,
+    sources: result.sources.slice(0, maxResults),
+    truncated: true
+  };
+}
+
+// src/web-search.ts
+var HIWORK_SEARCH_PROVIDER_ID = "hiwork-managed-search";
+var ME_WEB_SEARCH_PATH = "/api/me/web-search";
+var WEB_SEARCH_TIMEOUT_MS = 12e3;
+var HiworkSearchProvider = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  id = HIWORK_SEARCH_PROVIDER_ID;
+  available() {
+    return true;
+  }
+  async search(request, signal) {
+    if (signal?.aborted) throw aborted();
+    let sessionCookie;
+    try {
+      sessionCookie = await this.deps.resolveSession();
+    } catch (error) {
+      this.deps.log?.(`hiwork-core: \u8054\u7F51\u641C\u7D22\u4F1A\u8BDD\u89E3\u6790\u5931\u8D25\uFF08${errorName4(error)}\uFF09`);
+      throw new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UNREACHABLE, { cause: error });
+    }
+    if (sessionCookie === void 0 || sessionCookie === "") {
+      throw new WebError("\u767B\u5F55\u540E\u624D\u80FD\u4F7F\u7528\u8054\u7F51\u641C\u7D22", HIWORK_SEARCH_UNAUTHENTICATED);
+    }
+    const gateway = this.deps.gateway();
+    if (gateway === void 0) {
+      throw new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UNREACHABLE);
+    }
+    const outcome = await gateway.searchWeb(
+      sessionCookie,
+      // maxResults 是 tool-web 传进来的上限，透传给网关少拉数据（费用按次不按条，
+      // 但少拉条数能压响应体）。seam 仍会在结果侧强制截断，这里只是配合。
+      { query: request.query, ...request.maxResults !== void 0 ? { max_results: request.maxResults } : {} },
+      signal
+    );
+    if (!outcome.ok) {
+      throw outcomeToError(outcome);
+    }
+    const view = projectWebSearch(outcome.body);
+    if (view === void 0) {
+      this.deps.log?.("hiwork-core: \u7F51\u5173\u8FD4\u56DE\u7684 web-search \u54CD\u5E94\u4E0D\u7B26\u5408\u5951\u7EA6\uFF08results \u7F3A\u5931\u6216\u5F62\u72B6\u4E0D\u5BF9\uFF09");
+      throw new WebError("\u8054\u7F51\u641C\u7D22\u8FD4\u56DE\u4E86\u65E0\u6CD5\u89E3\u6790\u7684\u7ED3\u679C", "WEB_PROVIDER_ERROR");
+    }
+    return view;
+  }
+};
+var HIWORK_SEARCH_UNAUTHENTICATED = "HIWORK_SEARCH_UNAUTHENTICATED";
+var HIWORK_SEARCH_DISABLED = "HIWORK_SEARCH_DISABLED";
+var HIWORK_SEARCH_NOT_CONFIGURED = "HIWORK_SEARCH_NOT_CONFIGURED";
+var HIWORK_SEARCH_LIMIT = "HIWORK_SEARCH_LIMIT";
+var HIWORK_SEARCH_UNREACHABLE = "HIWORK_SEARCH_UNREACHABLE";
+var HIWORK_SEARCH_UPSTREAM = "HIWORK_SEARCH_UPSTREAM";
+function aborted() {
+  return new WebError("\u8054\u7F51\u641C\u7D22\u5DF2\u53D6\u6D88", "WEB_ABORTED");
+}
+function outcomeToError(outcome) {
+  switch (outcome.kind) {
+    case "aborted":
+      return aborted();
+    case "network":
+      return new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UNREACHABLE);
+    case "invalid":
+      return new WebError("\u8054\u7F51\u641C\u7D22\u8FD4\u56DE\u4E86\u65E0\u6CD5\u89E3\u6790\u7684\u7ED3\u679C", "WEB_PROVIDER_ERROR");
+    case "http":
+      return httpOutcomeToError(outcome.status, outcome.code);
+  }
+}
+function httpOutcomeToError(status, code) {
+  if (status === 401) return new WebError("\u767B\u5F55\u72B6\u6001\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", HIWORK_SEARCH_UNAUTHENTICATED);
+  if (code === "SEARCH_DISABLED") return new WebError("\u7BA1\u7406\u5458\u8FD8\u6CA1\u5F00\u542F\u8054\u7F51\u641C\u7D22", HIWORK_SEARCH_DISABLED);
+  if (code === "SEARCH_NOT_CONFIGURED") return new WebError("\u8054\u7F51\u641C\u7D22\u8FD8\u6CA1\u6709\u914D\u7F6E\u597D\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458", HIWORK_SEARCH_NOT_CONFIGURED);
+  if (status === 429 || code === "SEARCH_LIMIT_EXCEEDED") return new WebError("\u4ECA\u5929\u7684\u8054\u7F51\u641C\u7D22\u6B21\u6570\u5DF2\u7528\u5B8C\uFF0C\u660E\u5929\u518D\u6765", HIWORK_SEARCH_LIMIT);
+  if (status === 502 || code === "SEARCH_UPSTREAM_ERROR") return new WebError("\u641C\u7D22\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", HIWORK_SEARCH_UPSTREAM);
+  return new WebError("\u8054\u7F51\u641C\u7D22\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", "WEB_PROVIDER_ERROR");
+}
+function textOrUndefined8(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  return text === "" ? void 0 : text;
+}
+function projectWebSearch(body) {
+  const raw = body["results"];
+  if (!Array.isArray(raw)) return void 0;
+  const sources = [];
+  for (const item of raw) {
+    if (item === null || typeof item !== "object") continue;
+    const record = item;
+    const url = textOrUndefined8(record["url"]);
+    if (url === void 0) continue;
+    const title = textOrUndefined8(record["title"]);
+    const snippet = textOrUndefined8(record["snippet"]) ?? textOrUndefined8(record["content"]);
+    const publishedAt = textOrUndefined8(record["published_at"]);
+    sources.push({
+      url,
+      ...title !== void 0 ? { title } : {},
+      ...snippet !== void 0 ? { snippet } : {},
+      ...publishedAt !== void 0 ? { publishedAt } : {}
+    });
+  }
+  return { sources, truncated: false };
+}
+function errorName4(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+function createWebSearchGateway(baseURL, opts = {}) {
+  const root = baseURL.replace(/\/+$/, "");
+  const timeoutMs = opts.timeoutMs ?? WEB_SEARCH_TIMEOUT_MS;
+  const doFetch = opts.fetchImpl ?? fetch;
+  return {
+    async searchWeb(sessionCookie, body, signal) {
+      const signals = [AbortSignal.timeout(timeoutMs)];
+      if (signal !== void 0) signals.push(signal);
+      const merged = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+      let res;
+      try {
+        res = await doFetch(`${root}${ME_WEB_SEARCH_PATH}`, {
+          method: "POST",
+          headers: {
+            "user-agent": `hiwork-core/${PKG_VERSION}`,
+            cookie: sessionCookie,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(body),
+          signal: merged
+        });
+      } catch (error) {
+        if (signal?.aborted) return { ok: false, kind: "aborted" };
+        return { ok: false, kind: "network" };
+      }
+      if (!res.ok) {
+        let code;
+        try {
+          const parsed2 = await res.json();
+          if (typeof parsed2?.code === "string" && parsed2.code !== "") code = parsed2.code;
+        } catch {
+        }
+        return { ok: false, kind: "http", status: res.status, ...code !== void 0 ? { code } : {} };
+      }
+      let parsed;
+      try {
+        parsed = await res.json();
+      } catch {
+        return { ok: false, kind: "invalid" };
+      }
+      if (parsed === null || typeof parsed !== "object") return { ok: false, kind: "invalid" };
+      return { ok: true, body: parsed };
+    }
+  };
+}
+function registerManagedSearchProvider(web, deps) {
+  return web.registerSearchProvider(new HiworkSearchProvider(deps));
+}
+
 // src/index.ts
 var name = "hiwork-core";
-var inject = ["settings", "credentials", "workspaceRegistry", "connection"];
+var inject = ["settings", "credentials", "workspaceRegistry", "connection", "web"];
 var NS = "ai-router";
 var PI_AI_NS = "llm-pi-ai";
 var lastErrorSchema = Schema.object({ code: Schema.string().required(), message: Schema.string().required() }).default(void 0);
@@ -6879,14 +8670,14 @@ function parseDeviceInfo(message) {
   const id = deviceId.value?.trim();
   if (id === void 0 || id === "") return void 0;
   const name2 = deviceName.value?.trim();
-  const version = appVersion.value?.trim();
+  const version2 = appVersion.value?.trim();
   return {
     deviceId: id,
     ...name2 === void 0 || name2 === "" ? {} : { deviceName: name2 },
-    ...version === void 0 || version === "" ? {} : { appVersion: version }
+    ...version2 === void 0 || version2 === "" ? {} : { appVersion: version2 }
   };
 }
-function errorName3(error) {
+function errorName5(error) {
   return error instanceof Error ? error.name : typeof error;
 }
 function registerIpcMessageHandler(ports) {
@@ -6913,12 +8704,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${errorName3(error)}\uFF09`);
+          log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5904\u7406\u5F02\u5E38\uFF08${errorName5(error)}\uFF09`);
         }).finally(() => {
           authInFlight = false;
         });
       } catch (error) {
-        log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5206\u53D1\u5931\u8D25\uFF08${errorName3(error)}\uFF09`);
+        log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5206\u53D1\u5931\u8D25\uFF08${errorName5(error)}\uFF09`);
         authInFlight = false;
       }
       return;
@@ -6966,12 +8757,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${errorName3(error)}\uFF09`);
+    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u62C9\u53D6\u5931\u8D25\uFF0C\u767B\u5F55\u65B9\u5F0F\u56DE\u9000 both\uFF08${errorName5(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${errorName3(error)}\uFF09`);
+    opts.log?.(`hiwork-core: \u5BA2\u6237\u7AEF\u7B56\u7565\u5199\u5165\u5931\u8D25\uFF08${errorName5(error)}\uFF09`);
   }
   return loginMode;
 }
@@ -7109,6 +8900,16 @@ function apply(ctx, config) {
       ctx.logger.warn(message);
     }
   }), "hiwork-core: daily rpc");
+  ctx.effect(() => registerVoiceRpc({ connection, logger: ctx.logger }, {
+    resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
+    gateway: () => {
+      const baseURL = current().baseURL;
+      return baseURL === void 0 || baseURL === "" ? void 0 : gatewayFor(baseURL);
+    },
+    log: (message) => {
+      ctx.logger.warn(message);
+    }
+  }), "hiwork-core: voice rpc");
   const managedMcpDeps = {
     resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
     gateway: () => {
@@ -7194,7 +8995,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 +9013,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: () => {
@@ -7233,6 +9042,16 @@ function apply(ctx, config) {
       ctx.logger.warn(message);
     }
   }), "hiwork-core: memory config service");
+  ctx.effect(() => provideKnowledgeConfig(ctx, {
+    resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
+    gateway: () => {
+      const baseURL = current().baseURL;
+      return baseURL === void 0 || baseURL === "" ? void 0 : createKnowledgeConfigGateway(baseURL);
+    },
+    log: (message) => {
+      ctx.logger.warn(message);
+    }
+  }), "hiwork-core: knowledge config service");
   ctx.effect(() => provideOfficeRelay(ctx, {
     resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
     gateway: () => {
@@ -7243,6 +9062,19 @@ function apply(ctx, config) {
       ctx.logger.warn(message);
     }
   }), "hiwork-core: office relay");
+  const web = ctx.get("web");
+  if (web !== void 0) {
+    registerManagedSearchProvider(web, {
+      resolveSession: async () => (await ports.credentials.resolve(SESSION_REF))?.value,
+      gateway: () => {
+        const baseURL = current().baseURL;
+        return baseURL === void 0 || baseURL === "" ? void 0 : createWebSearchGateway(baseURL);
+      },
+      log: (message) => {
+        ctx.logger.warn(message);
+      }
+    });
+  }
   ctx.effect(() => registerAppVersionRpc({ connection, logger: ctx.logger }, {
     appVersion: () => pushedAppVersion(),
     log: (message) => {