@sema-agent/server 7.134.0 → 7.136.0

package/dist/fleet/fleet-reconciler.d.ts

@@ -33,9 +33,9 @@
  * 「**静默满一个对账周期**」(本腿订阅总线自记每行的最后帧时刻):还在出帧 = 活着的证据。
  * durable 行**在场**的那三格没有这个歧义(`getRun` 命中 = 它就是一条 run 行),故照矩阵即时处置。
  *
- * ## 子代行(§1;🔴 S-751 起改为「活性由属主说了算」)
+ * ## 子代行(§1;🔴 [ref] 起改为「活性由属主说了算」)
  * 子代行**不读 durable run 店**(它不是 run 行)。它的活性属主有两只,都在本仓可读 —— 读它们**不是**越界重判,
- * 是问属主(S-751 之前此处写「bg 子代的 durable 真源在 core 侧 registry,server 不越界重判」,于是判据里只剩
+ * 是问属主([ref] 之前此处写「bg 子代的 durable 真源在 core 侧 registry,server 不越界重判」,于是判据里只剩
  * 「静默」这一条,而 registry 的读半场 `RunnerDeps.backgroundAgentStore` 一直就在本仓):
  *  ① core bg registry(`BackgroundAgentStore` 行 `status` 非终态 = `running` / `parked`);
  *  ② 本副本审批面的待决卡(子代发起、没人答的 ask —— 子代卡在那儿,当然不出帧)。
@@ -49,7 +49,7 @@
  * 只做同款「durable 终局投影」([ref] 的 snapshot pull 腿 + reapers 的 workflow recover 腿已在场),
  * **不加新判据**:活行恒不动,没有陈述级退场这一形。
  *
- * ## 🔴 S-450:候补窗的升级**由事实驱动**,周期臂降为兜底
+ * ## 🔴 [ref]:候补窗的升级**由事实驱动**,周期臂降为兜底
  * 陈述级退场(`orphanExit`)恒不造终态、行进候补窗;把它升级成真终局此前**只**发生在下一个对账周期的
  * ① 臂 ⇒ 成对终帧最晚 {@link FLEET_RECONCILE_INTERVAL_MS} + 预算抖动才到面板,而消费方
  * (`@sema-agent/client-core` 的面板投影)对「行缺席」按 30s 结算 —— 两侧各自正确,合成的是「面板先结算
@@ -118,7 +118,7 @@ export interface FleetReconcileRunPort {
 export interface FleetReconcileWorkflowPort {
     get(id: string): Promise<WorkflowRun | null | undefined>;
 }
-/** S-751:core bg registry 账(`BackgroundAgentStore`)的只读窄口 —— 与 {@link FleetReconcileRunPort} 同一条
+/** [ref]:core bg registry 账(`BackgroundAgentStore`)的只读窄口 —— 与 {@link FleetReconcileRunPort} 同一条
  *  单写者纪律(接口上没有写方法)。生产 = `RunnerDeps.backgroundAgentStore` **同实例**(结构上就是它的 `get`
  *  一面);`null` = 账上没有这一行。 */
 export interface FleetReconcileAgentPort {
@@ -133,7 +133,7 @@ export interface FleetReconcilerDeps {
      */
     isLiveOnThisReplica: (taskId: string) => boolean;
     /**
-     * S-450 测试缝:「run 行 CAS 赢了翻终局」的订阅口。**生产恒缺席** —— 缺席时本腿自己去
+     * [ref] 测试缝:「run 行 CAS 赢了翻终局」的订阅口。**生产恒缺席** —— 缺席时本腿自己去
      * `observability/run-terminal.ts` 的**唯一铸点**登记(那口是进程级的自由函数,与 `recordFailOpen`
      * 同姿势:真正的铸点在没有任何句柄的深处)。给它一个注入形只是为了让用例能在一台假铸点上跑。
      *
@@ -143,10 +143,10 @@ export interface FleetReconcilerDeps {
     subscribeRunTerminal?: (fn: (rec: RunTerminalRecord) => void) => () => void;
     runs?: FleetReconcileRunPort;
     workflows?: FleetReconcileWorkflowPort | WorkflowRunStore;
-    /** S-751:子代活性的属主①(bg registry 账)。缺席 = 没有 bg 店的部署(纯内存 dev),这一问问不了。 */
+    /** [ref]:子代活性的属主①(bg registry 账)。缺席 = 没有 bg 店的部署(纯内存 dev),这一问问不了。 */
     agents?: FleetReconcileAgentPort;
     /**
-     * S-751:子代活性的属主②:这只子代此刻有没有**待决**审批卡。只问是非(与 {@link isLiveOnThisReplica} 同姿势,
+     * [ref]:子代活性的属主②:这只子代此刻有没有**待决**审批卡。只问是非(与 {@link isLiveOnThisReplica} 同姿势,
      * 不搬 Map)。入参是 ask 发起者域(子代自己的 core session id,= 卡上的 `originTaskId`),**不是**行 id ——
      * 行 id → 该域的换算只在 `FleetEventBus.childOwnerKeys`。生产 = `ToolApprovalCoordinator.hasLivePendingFrom`。
      */
@@ -171,9 +171,9 @@ export interface FleetReconcileTally {
     retired: number;
     /** 陈述级退场的行数(顶层 + 孤儿子行)。 */
     orphaned: number;
-    /** 父本周期刚离场、自己又判成孤儿而陈述级退场的子行数(S-751 前 = 随父无条件同扫的数)。 */
+    /** 父本周期刚离场、自己又判成孤儿而陈述级退场的子行数([ref] 前 = 随父无条件同扫的数)。 */
     childrenSwept: number;
-    /** S-751:静默满一周期、无父可循(或 run 账不认识),但属主作保而**留行**的子行数。 */
+    /** [ref]:静默满一周期、无父可循(或 run 账不认识),但属主作保而**留行**的子行数。 */
     childrenKeptAlive: number;
     /** durable 终局 ⇒ 投影退休的 workflow 行数。 */
     workflowsRetired: number;

package/dist/fleet/subagent-tail-bus.d.ts

@@ -8,7 +8,7 @@ export type SubagentTailFrame = Record<string, unknown> & {
 };
 /** core forward 事件 → wire 投影(sync 主流五分支同源;不认识的帧类型=null 不发——tail 面只承诺
  *  content 六类,新 core 帧类型先经这里显式收编再出 wire)。
- *  ⚠️ **本函数是无状态逐帧投影**:`reasoning_end`(S-310 的推理权威段)不在这里 —— 它要按句柄攒段,
+ *  ⚠️ **本函数是无状态逐帧投影**:`reasoning_end`([ref] 的推理权威段)不在这里 —— 它要按句柄攒段,
  *  住在 {@link SubagentTailBus.onForwardFrame}(publish 侧是唯一知道句柄的地方)。 */
 export declare function projectTailFrame(e: Record<string, unknown> & {
     type?: string;
@@ -53,7 +53,7 @@ export declare class SubagentTailBus {
      */
     private readonly modeByHandle;
     /**
-     * 句柄 → 该句柄这条 tail 流上**在攒的推理段**(S-310)。
+     * 句柄 → 该句柄这条 tail 流上**在攒的推理段**([ref])。
      *
      * 键必须是句柄,理由与 {@link modeByHandle} 同源再加一条硬的:两个并发子代的 `reasoning_delta` 在
      * **同一个** forward sink 上交错到达,一只累积器会把两份思考拼成一段、再盖上其中一个的身份键。
@@ -67,10 +67,10 @@ export declare class SubagentTailBus {
      *  否则晚开的 tail 永远读不到供给形)。同值重复写是 no-op(热路径只付一次 Map.get)。 */
     noteHandleContentMode(bgAgentId: string, mode: TailContentMode): void;
     /**
-     * 🔴 **三条 run 腿的 forward 回调唯一入口**(S-310 收口)——登记供给形 → 段界收段 → 逐帧投影 → publish。
+     * 🔴 **三条 run 腿的 forward 回调唯一入口**([ref] 收口)——登记供给形 → 段界收段 → 逐帧投影 → publish。
      *
      * 此前这四步以**同一段六行代码**抄在三条腿上(sync 流腿、verify-resume 腿、resume-stream 腿),
-     * 差别为零;S-310 要给 tail 面补 `reasoning_end` 时,那就是第四、第五、第六份拷贝。收成一扇门之后
+     * 差别为零;[ref] 要给 tail 面补 `reasoning_end` 时,那就是第四、第五、第六份拷贝。收成一扇门之后
      * 腿上只剩「句柄在不在」这一句判断,三腿不可能再分家(`test/subagent-tail-stream.test.ts` G18-G20)。
      *
      * 顺序即语义:权威段**先于**触发它的结构帧上 wire(消费端「整段替换已攒 delta」的替换点不与卡片交错),

package/dist/fleet-client.d.ts

@@ -1,21 +1,21 @@
 /**
  * Fleet worker-side wiring(announce/heartbeat + usage 批报;契约 = registry-core 0.1.48+
  * `/fleet`,center 端点 = web-admin `/api/fleet/*`)。设计要点:
- *  - **可选分层(D3),两条环各自有门(S-866 ④)**:客户端在中心车道配齐时启动(`centerLaneConfigured` —— baseUrl + 声明了
+ *  - **可选分层(D3),两条环各自有门([ref] ④)**:客户端在中心车道配齐时启动(`centerLaneConfigured` —— baseUrl + 声明了
  *    凭证 + worker,与租约管理器、用量累加器**同一只**谓词);**用量环**只要这三件;**公告环**(announce / 心跳 / 注销)另要
  *    配置席 `fleetAdvertiseAddress`(env `FLEET_ADVERTISE_ADDRESS`,`loadConfig` 解析一次;可达性是运维的话,不自猜:k8s pod IP /
  *    docker alias / 127.0.0.1:port 只有部署环境自己知道)。不配中心的部署零行为变化;配了中心而不公告的引擎只报用量、不注册(7.105.0 及以前它连用量都不报)。
  *  - **announce=注册=心跳同形状幂等 upsert**:boot 后(listen 之后)POST 一次 + 每 heartbeatMs 续。
- *    `ready` / `draining` 两字段由引擎信号铸点的同一次读铸(S-740:`ready` = `http/readiness.ts` `readinessOf` 的判,
+ *    `ready` / `draining` 两字段由引擎信号铸点的同一次读铸([ref]:`ready` = `http/readiness.ts` `readinessOf` 的判,
  *    与 `/health.ready`、`GET /readyz`、计费提交门同源;= roster 已落 ∧ ¬draining),`draining` = 排空事实在场(与嵌套
  *    `engineSignal.draining` 同一个字段,`fleet/engine-signal.ts` 规则 5)。修前 `ready = !isDraining()`,不含 roster ⇒ roster 未落时
  *    心跳说「就绪」而计费提交在 503。
  *  - **`engineSignal`(7.123.0)**:引擎态整只(契约 `EngineSignal`),与扁平键同一次读数;契约包 10.x 的心跳形没有它的座位(10.x 中心
  *    默认 strip 解析丢掉它、照收心跳);扁平布尔 `draining` settings-schema 12.0.0 删、本引擎 7.124.0+ 删发。
- *  - **`restart?`(S-741)**:在场 ⇔ 本副本必须重启才能应用配置 —— 取自 `/health.restart` **同一只**取值口(装配层接
+ *  - **`restart?`([ref])**:在场 ⇔ 本副本必须重启才能应用配置 —— 取自 `/health.restart` **同一只**取值口(装配层接
  *    `deployment.restartState`,web-admin 的 `restartState()`),同一个对象,形 = settings-schema `RestartSignal`;
  *    缺席即键缺席(中心按行整体替换,不合并 —— 一条不带它的心跳就是「不再需要」)。
- *  - **`modelRefusals?`(S-768)**:在场 ⇔ 本副本对最近一次被判的中心候选目录有可报的拒(逐条名 → 码 / 模型面组拒码)—— 取自
+ *  - **`modelRefusals?`([ref])**:在场 ⇔ 本副本对最近一次被判的中心候选目录有可报的拒(逐条名 → 码 / 模型面组拒码)—— 取自
  *    `/health.modelRefusals` **同一只**取值口(装配层接 `deployment.modelRefusalsState`),同一个对象,形 = settings-schema
  *    `ModelRefusalsSignal`;缺席即键缺席(同 `restart`)。
  *  - **自报状态翻转即刻再 announce**(第一时间自摘流 / 自挂流 / 报重启 / 报拒因,比任何观测都快):draining 翻转由收尾链直调
@@ -25,11 +25,15 @@
  *    累计,每窗口(默认 60s,半开 [windowStartMs, windowEndMs))POST /api/fleet/usage。幂等键
  *    (worker,instanceId,windowStartMs) 重发安全;**发送失败 → merge 回累计器**,并入下一窗(失败窗从未入账,
  *    向前合并不会双计 —— 只延迟,不丢量)。
+ *  - **用量按中心凭证身份分箱([ref])**:累计器一个身份一只({@link createFleetUsageBins},分箱规则 = `createIdentityBins` 一只),
+ *    tracer 记进记账身份那一箱(执行开始时钉下的身份;执行外 = 此刻身份);用量环只报此刻身份那一箱、经钉在它身份上的凭证发 —— 文件形凭证进程内换人后,上一个人窗里的用量
+ *    不在下一个人的凭证下上报(不记到别人头上);它留在原箱,那个身份回来时照常报出去,收尾时还压着就响亮一行。
  *  - 全部 fire-and-forget + swallow-guarded:fleet 面是运维旁路,绝不影响任务面;网络错误只 warn 一次/连败类。
  */
 import { UsageReport, type CapabilityReading, type WebAdminCapabilities, type ModelRefusalsSignal } from "@sema-agent/settings-schema/fleet";
 import { type EngineSignalFacts } from "./fleet/engine-signal.js";
 import { type CenterEndpoint } from "./web-admin-client/center-request.js";
+import { type CenterCredentialSource } from "./center-credential.js";
 /** Bound on distinct principal×model keys per window — a runaway/multi-tenant burst collapses into
  *  `__other__` instead of growing unbounded (same posture as budget.ts cardinalityGuard). */
 export declare const FLEET_USAGE_KEY_CAP = 1024;
@@ -71,28 +75,55 @@ export declare class FleetUsageAccumulator {
     mergeBack(entries: UsageReport["entries"]): void;
     get size(): number;
 }
+/** [ref] —— 一个中心凭证身份的用量箱:这个身份窗里的累计格,与钉在这个身份上的凭证(用量环只经它报这一箱)。 */
+export interface FleetUsageBin {
+    readonly usage: FleetUsageAccumulator;
+    readonly credential: CenterCredentialSource;
+}
+/**
+ * [ref] —— **按中心凭证身份分箱的用量账**(活对象 ⇒ `create*`)。tracer / side-query 记账写 {@link record}(此刻身份那一箱);
+ * 用量环读 {@link current}(此刻身份那一箱 + 钉住的凭证)。分箱规则只有 `createIdentityBins` 一只(与租约管理器、per-principal caps 同规则)。
+ */
+export interface FleetUsageBins {
+    /** 记进**记账身份**那一箱(执行里 = 执行开始时钉下的身份;执行外 = 此刻身份)。 */
+    record(principal: string | undefined, model: string, taskId: string, d: {
+        inputTokens: number;
+        outputTokens: number;
+        costMicroUsd?: number;
+        weightedTokens?: number;
+        quotaWeightAtUse?: number;
+    }): void;
+    /** 把这次执行的记账身份钉在此刻(tracer 在 `task.start` 调;规则属 `center-credential.ts` `pinAccountingIdentity`)。 */
+    pinExecution(): void;
+    /** 此刻身份那一箱(用量环上报读它)。 */
+    current(): FleetUsageBin;
+    /** **全部**箱里还压着的条目数(收尾那一行 warn 用:最后一窗之后还压着的,进程退出即丢 —— 别的身份的、身份未知的、或最后一窗没报成的,同一待遇)。 */
+    held(): number;
+}
+export declare function createFleetUsageBins(credential: CenterCredentialSource): FleetUsageBins;
 export interface FleetClientOpts {
-    /** S-651:凭证是**来源**(每条公告 / 用量 / 注销请求各取一次值),不是启动期烧进 header 的字符串。 */
+    /** [ref]:凭证是**来源**(每条公告 / 用量 / 注销请求各取一次值),不是启动期烧进 header 的字符串。 */
     center: CenterEndpoint & {
         worker: string;
     };
     instanceId: string;
     /** Reachable base URL of THIS instance — the operator's explicit declaration (`FLEET_ADVERTISE_ADDRESS`).
-     *  S-866 ④:**缺席 = 公告环不装**(不注册、不心跳、不注销;`announceNow` 是空操作),用量环照装。 */
+     *  [ref] ④:**缺席 = 公告环不装**(不注册、不心跳、不注销;`announceNow` 是空操作),用量环照装。 */
     advertiseAddress?: string | undefined;
     version: string;
     /** 编排器片 2 件 1:引擎信号的**一只铸点**(装配层接 `mintEngineSignal(deployment)` —— `/health` 与 `/readyz` 读的同一只、同一个 deps 组)。
      *  每条公告现铸**一次**,嵌套 `engineSignal` 与扁平 `ready` / `draining` / `restart` / 代际与租约三键都取自这一次(不会撕裂成 `ready:true` +
-     *  `draining:true`,也不会出现心跳与 `/health` 各算一份重启或租约)。修前是 `readiness` + `restart` 两只取值口(S-740 / S-741),合进这一只。 */
+     *  `draining:true`,也不会出现心跳与 `/health` 各算一份重启或租约)。修前是 `readiness` + `restart` 两只取值口([ref] / [ref]),合进这一只。 */
     signal: () => EngineSignalFacts;
-    /** S-768:模型拒因信号(装配层接 `/health` 同一只取值口 `deployment.modelRefusalsState`)。每条公告现读一次;`undefined` ⇒ 公告不带
+    /** [ref]:模型拒因信号(装配层接 `/health` 同一只取值口 `deployment.modelRefusalsState`)。每条公告现读一次;`undefined` ⇒ 公告不带
      *  `modelRefusals` 键。必填:与 `restart` 同 —— 心跳面没有「不知道有没有拒」这一形(老引擎不发这个键,中心按 `version` 判「不可知」)。 */
     modelRefusals: () => ModelRefusalsSignal | undefined;
     /** 编排器片 2:每一次**能力读数**交出去一次(装配层接服务租约客户端的 `noteCenterCapabilities`)。规则见 {@link capabilityReadingOf}:
      *  只有 `declared`(交出宣告的位)与 `undeclared`(交 `undefined` = 老中心没宣告)是读数;`unreadable`(体读不出 / 不是对象 /
      *  `capabilities` 键在场而形坏)不是读数 ⇒ 不调,上一次读数与它的钟原样。失败的公告同样不调(没听到 ≠ 没有)。 */
     onCenterCapabilities?: (caps: WebAdminCapabilities | undefined) => void;
-    usage?: FleetUsageAccumulator;
+    /** [ref]:按凭证身份分箱的用量账(缺席 = 用量环不装)。 */
+    usage?: FleetUsageBins;
     heartbeatMs?: number;
     usageWindowMs?: number;
     logger?: {
@@ -104,7 +135,7 @@ export interface FleetClientOpts {
 }
 export interface FleetClient {
     /** Immediate out-of-cycle announce — call when a self-reported input flips (draining: self-remove from routing FIRST;
-     *  roster landed: become routable without waiting a heartbeat; restart signal changed: S-741). */
+     *  roster landed: become routable without waiting a heartbeat; restart signal changed: [ref]). */
     announceNow: () => Promise<void>;
     /**
      * **路由面**停:停心跳、等在飞公告排空、best-effort DELETE 注销(各请求有界;从不抛)。之后的 `announceNow` 是空操作。
@@ -113,7 +144,7 @@ export interface FleetClient {
     stopRouting: () => Promise<void>;
     /**
      * **记账面**停:停用量窗定时器、上报最后一个(可能不满的)用量窗(有界;从不抛;空窗不发)。与路由面无关(不公告的引擎也报用量)。
-     * 收尾链排在**排空等待之后**调(S-929 F12:宽限窗里跑完的腿记下的用量必须进这一窗)。
+     * 收尾链排在**排空等待之后**调([ref] F12:宽限窗里跑完的腿记下的用量必须进这一窗)。
      */
     flushFinalUsage: () => Promise<void>;
 }
@@ -134,13 +165,13 @@ export type AnnounceReplyReading = Exclude<CapabilityReading, {
 };
 /**
  * Start the worker-side fleet loops. Caller has already gated on the center lane (startFleetClientFromConfig below).
- * The announce loop runs iff `advertiseAddress` is present; the usage loop iff `usage` is present (S-866 ④: the two
+ * The announce loop runs iff `advertiseAddress` is present; the usage loop iff `usage` is present ([ref] ④: the two
  * loops no longer share one gate).
  */
 export declare function startFleetClient(opts: FleetClientOpts): FleetClient;
 /**
- * Config gate (D3 可选分层;S-866 ④ 两条环各自有门): start when the center lane is configured —
- * {@link centerLaneConfigured}(baseUrl + a DECLARED credential + worker — S-651: declared, not "currently readable": a token
+ * Config gate (D3 可选分层;[ref] ④ 两条环各自有门): start when the center lane is configured —
+ * {@link centerLaneConfigured}(baseUrl + a DECLARED credential + worker — [ref]: declared, not "currently readable": a token
  * file that is unreadable right now still starts the client, every request re-reads it), the SAME predicate the lease
  * manager and the usage accumulator use. The usage loop needs nothing more; the announce loop additionally needs the
  * operator's explicit reachable address — the config seat `fleetAdvertiseAddress` (env `FLEET_ADVERTISE_ADDRESS`, parsed once by

package/dist/fleet-client.js

@@ -2,6 +2,7 @@ import { InstanceAnnouncement, UsageReport, DEFAULT_HEARTBEAT_MS, readCapability
 import { ENGINE_SIGNAL_KEY, buildEngineSignal, fleetMembershipKeys, heartbeatReadinessKeys } from "./fleet/engine-signal.js";
 import { centerFetch, centerLaneConfigured } from "./web-admin-client/center-request.js";
 import { recordFailOpen } from "./observability/fail-open.js";
+import { createIdentityBins, pinAccountingIdentity } from "./center-credential.js";
 import { WEB_ADMIN_ENV } from "@sema-agent/settings-schema";
 export const FLEET_USAGE_KEY_CAP = 1024;
 export const FLEET_CLIENT_FETCH_TIMEOUT_MS = 5000;
@@ -67,6 +68,20 @@ export class FleetUsageAccumulator {
         return this.cells.size;
     }
 }
+export function createFleetUsageBins(credential) {
+    const made = [];
+    const bins = createIdentityBins(credential, (pinned) => {
+        const bin = { usage: new FleetUsageAccumulator(), credential: pinned };
+        made.push(bin);
+        return bin;
+    });
+    return {
+        record: (principal, model, taskId, d) => bins.accounting().usage.record(principal, model, taskId, d),
+        pinExecution: () => pinAccountingIdentity(credential),
+        current: bins.now,
+        held: () => made.reduce((n, b) => n + b.usage.size, 0),
+    };
+}
 async function rejectionSnippet(res) {
     try {
         const text = (await res.text()).slice(0, 200).trim();
@@ -90,7 +105,7 @@ export function startFleetClient(opts) {
     const f = opts.fetchImpl ?? fetch;
     const heartbeatMs = opts.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
     const usageWindowMs = opts.usageWindowMs ?? 60_000;
-    const send = (route, method, json) => centerFetch(opts.center, { kind: route }, { method, json, timeoutMs: FLEET_CLIENT_FETCH_TIMEOUT_MS, fetchImpl: f });
+    const send = (route, method, json, center = opts.center) => centerFetch(center, { kind: route }, { method, json, timeoutMs: FLEET_CLIENT_FETCH_TIMEOUT_MS, fetchImpl: f });
     let stopped = false;
     let failStreak = 0;
     let unreadableStreak = 0;
@@ -177,20 +192,21 @@ export function startFleetClient(opts) {
     const flushUsage = async () => {
         if (!opts.usage)
             return;
+        const bin = opts.usage.current();
         const windowEndMs = Date.now();
-        const entries = opts.usage.drain();
+        const entries = bin.usage.drain();
         const start = windowStartMs;
         windowStartMs = windowEndMs;
         if (entries.length === 0)
             return;
         const report = { worker: opts.center.worker, instanceId: opts.instanceId, windowStartMs: start, windowEndMs, entries };
         try {
-            const { res } = await send("fleet-usage", "POST", { reports: [report] });
+            const { res } = await send("fleet-usage", "POST", { reports: [report] }, { ...opts.center, credential: bin.credential });
             if (!res.ok)
                 throw new Error(`usage ${res.status}${await rejectionSnippet(res)}`);
         }
         catch (err) {
-            opts.usage.mergeBack(entries);
+            bin.usage.mergeBack(entries);
             opts.logger?.warn("fleet_usage_report_failed", { error: err instanceof Error ? err.message : String(err), entries: entries.length });
         }
     };
@@ -227,6 +243,10 @@ export function startFleetClient(opts) {
         if (uw)
             clearInterval(uw);
         await flushUsage();
+        const held = opts.usage?.held() ?? 0;
+        if (held > 0) {
+            opts.logger?.warn("fleet_usage_unreported_identity", { entries: held, note: "usage still held at exit is dropped: it accrued under another center credential identity (never reported under the current one — it would be billed to the wrong account), under an unknown identity (credential unreadable), or its final report failed" });
+        }
     };
     return { announceNow, stopRouting, flushFinalUsage };
 }

package/dist/fleet-lease.d.ts

@@ -3,20 +3,20 @@ import { type CenterEndpoint } from "./web-admin-client/center-request.js";
 export declare const NOT_LEASE_TTL_MS: number;
 /** center 判 budget exhausted 后,多久内的重复提交直接拒绝而不再打 center(防 per-request 打爆)。 */
 export declare const EXHAUSTED_RETRY_MS: number;
-/** principal 状态表上界(镜像 FLEET_USAGE_KEY_CAP 的姿势):超界丢最旧 —— 被丢的 principal 下次 admit
+/** principal 状态表上界(**每个身份箱各一份**;镜像 FLEET_USAGE_KEY_CAP 的姿势):超界丢最旧 —— 被丢的 principal 下次 admit
  *  重新协商,一次多余 RTT,无正确性影响。 */
 export declare const LEASE_PRINCIPAL_CAP = 4096;
 /** 复审 O1:lease 协商 RTT 的硬上限——leaseDenied 在提交热路径同步 await 它,一个 accept-but-hang 的
  *  center 必须迅速塌成连接级失败臂而不是拖垮提交。取 2.5s(远小于任何续租余量,略紧于 registry 的 8s)。 */
 export declare const LEASE_FETCH_TIMEOUT_MS = 2500;
-/** S-866 ③:`closed` 姿态下连接级失败给调用方的重试窗(秒)。**固定短窗** —— 不猜中心何时恢复;503 可重试,下一次提交就是
+/** [ref] ③:`closed` 姿态下连接级失败给调用方的重试窗(秒)。**固定短窗** —— 不猜中心何时恢复;503 可重试,下一次提交就是
  *  下一次谈判(失败臂不缓存,中心一恢复即恢复)。 */
 export declare const LEASE_UNAVAILABLE_RETRY_SEC = 5;
-/** S-866 ③:租约连接级失败的两种姿态(= caps `centerWiring.failMode` 的词表;生效值由 `createFleetLeaseFromEnv` 从
+/** [ref] ③:租约连接级失败的两种姿态(= caps `centerWiring.failMode` 的词表;生效值由 `createFleetLeaseFromEnv` 从
  *  `FLEET_LEASE_FAIL_CLOSED` 定)。加一种 = 下面按姿态穷举的 `Record` 当场编译红。 */
 export declare const LEASE_FAIL_MODES: readonly ["open", "closed"];
 export type LeaseFailMode = (typeof LEASE_FAIL_MODES)[number];
-/** S-866 ③:`lease_unavailable` 的两个成因(503 体 `reason` 的词表,与 caps `leaseHealth` 的两个失败词同名)。 */
+/** [ref] ③:`lease_unavailable` 的两个成因(503 体 `reason` 的词表,与 caps `leaseHealth` 的两个失败词同名)。 */
 export declare const LEASE_UNAVAILABLE_CAUSES: readonly ["auth-rejected", "unreachable"];
 export type LeaseUnavailableCause = (typeof LEASE_UNAVAILABLE_CAUSES)[number];
 /** E4 定稿的 409 结构化字段(center verbatim → 我方 429 body verbatim 透传;人话归壳/web)。 */
@@ -45,7 +45,7 @@ export type LeaseRefusalAdmission = Extract<LeaseAdmission, {
     ok: false;
 }>;
 /**
- * S-866 ② —— **最近一次谈判怎么收尾的**(`issueOrRenew` 收尾写;新状态,本管理器只此一枚)。闭集:
+ * [ref] ② —— **最近一次谈判怎么收尾的**(`issueOrRenew` 收尾写;新状态,本管理器只此一枚)。闭集:
  *  · `none` —— 本进程还没谈判过;
  *  · `ok` —— 中心给了合法答复(200 租约 / 409 not-lease / 409 耗尽 —— 耗尽也是「中心在判」);
  *  · `auth-error` —— 中心 401 / 403 / 400,或这一次读凭证失败(请求根本没发);
@@ -54,10 +54,10 @@ export type LeaseRefusalAdmission = Extract<LeaseAdmission, {
  */
 export declare const LEASE_ADMIT_OUTCOMES: readonly ["none", "ok", "auth-error", "unavailable"];
 export type LeaseAdmitOutcome = (typeof LEASE_ADMIT_OUTCOMES)[number];
-/** S-866 ② caps `centerWiring.leaseHealth` 的词表。 */
+/** [ref] ② caps `centerWiring.leaseHealth` 的词表。 */
 export declare const LEASE_HEALTH_WORDS: readonly ["ok", "auth-rejected", "unreachable", "unobserved"];
 export type LeaseHealth = (typeof LEASE_HEALTH_WORDS)[number];
-/** S-866 ② caps `centerWiring.caller.lease` 的词表(F-1 裁定:过期 / 耗尽而未续成 ⇒ `unobserved`)。 */
+/** [ref] ② caps `centerWiring.caller.lease` 的词表(F-1 裁定:过期 / 耗尽而未续成 ⇒ `unobserved`)。 */
 export declare const CALLER_LEASE_WORDS: readonly ["enforced", "not-enforced", "exhausted", "unobserved"];
 export type CallerLease = (typeof CALLER_LEASE_WORDS)[number];
 /** `snapshot()` 的产物(纯数据):调用方这一刻的租约读数 + 管理器最近一次谈判的健康位。`retryAfterSec` 只随 `exhausted`。 */
@@ -69,11 +69,11 @@ export interface LeaseSnapshot {
     };
 }
 export interface FleetLeaseOpts {
-    /** S-651:凭证是**来源**(每次协商取一次值),不是构造期烧进 header 的字符串。 */
+    /** [ref]:凭证是**来源**(每次协商取一次值),不是构造期烧进 header 的字符串。 */
     center: CenterEndpoint & {
         worker: string;
     };
-    /** S-866 ③:连接级失败臂的姿态。**必填** —— 安全轴上没有「不知道该放还是该拒」这一形(缺省在配置层按部署姿态派生,不在这里猜)。 */
+    /** [ref] ③:连接级失败臂的姿态。**必填** —— 安全轴上没有「不知道该放还是该拒」这一形(缺省在配置层按部署姿态派生,不在这里猜)。 */
     failMode: LeaseFailMode;
     fetchImpl?: typeof fetch;
     logger?: {
@@ -87,16 +87,18 @@ export interface FleetLeaseOpts {
 }
 export declare class FleetLeaseManager {
     private readonly opts;
-    private readonly state;
-    private readonly inflight;
+    /** 记账身份的那一箱(惰建;分箱规则只有 `createIdentityBins` 一只,取箱口 `accounting`)。 */
+    private readonly binNow;
     private readonly f;
     private readonly now;
     private failStreak;
-    /** S-866 ②:最近一次谈判的收尾({@link LeaseAdmitOutcome})。只在 `issueOrRenewInner` 的各收尾点写。 */
+    /** [ref] ②:最近一次谈判的收尾({@link LeaseAdmitOutcome})。只在 `issueOrRenewInner` 的各收尾点写。 */
     private lastAdmit;
-    /** S-866 ③ 生效姿态(caps `centerWiring.failMode` 读的就是它 —— 与执行的那一只同源)。 */
+    /** [ref] ③ 生效姿态(caps `centerWiring.failMode` 读的就是它 —— 与执行的那一只同源)。 */
     readonly failMode: LeaseFailMode;
     constructor(opts: FleetLeaseOpts);
+    /** [ref]:把这次执行的记账身份钉在此刻(tracer 在执行的第一帧 `task.start` 调;规则属 `center-credential.ts` `pinAccountingIdentity`)。 */
+    pinExecution(): void;
     /**
      * Admission check for one billed submission. Fast path is synchronous-shaped (live lease / fresh negative
      * cache → no await beyond the microtask); only first-touch / expiry / exhaustion pays a center RTT.
@@ -117,8 +119,9 @@ export declare class FleetLeaseManager {
         costMicroUsd?: number;
     }): void;
     /**
-     * S-866 ② —— 调用方这一刻的租约读数(caps `centerWiring.caller` / `leaseHealth` 的唯一来源;7.105.0 的 `peek()` 退役:它只回 kind、
+     * [ref] ② —— 调用方这一刻的租约读数(caps `centerWiring.caller` / `leaseHealth` 的唯一来源;7.105.0 的 `peek()` 退役:它只回 kind、
      * 不看 `until`,过期条目照回原 kind)。**纯读**:不打中心、不写状态、不动 LRU 序(`Map.get` 不改插入序)—— caps 路由自己不 admit。
+     * 读的是**此刻凭证身份**那一箱([ref];取箱要读一次凭证,首次见到的身份惰建一只空箱 —— 空箱不是状态)。
      * 规则表(设计稿 v1.1 §2②,逐行钉在 `test/fleet-lease.test.ts`):
      *  · principal 缺席 / 无条目(含被 LRU 逐出)⇒ `unobserved`;
      *  · `not-lease` 且 `now < until` ⇒ `not-enforced`;到期 ⇒ `unobserved`;
@@ -128,20 +131,21 @@ export declare class FleetLeaseManager {
      * `leaseHealth` 按 `lastAdmit`({@link LEASE_HEALTH_BY_OUTCOME})。
      */
     snapshot(principal: string | undefined, now: number): LeaseSnapshot;
-    /** 🔴 复审 O2(Opus)的鉴权失败臂,S-651 起两个入口共用(中心 401/403/400;凭证文件不可读):运维配置事故,
+    /** 🔴 复审 O2(Opus)的鉴权失败臂,[ref] 起两个入口共用(中心 401/403/400;凭证文件不可读):运维配置事故,
      *  不是可用性事件。**每次**都 warn + 专用计数,且**不缓存**(配置一修好下一次谈判即恢复)。放不放行归姿态
-     *  ({@link connectionFailure},S-866 ③):open = 照旧放行(凭证抖一下不许把单用户锁在门外);closed = 拒。 */
+     *  ({@link connectionFailure},[ref] ③):open = 照旧放行(凭证抖一下不许把单用户锁在门外);closed = 拒。 */
     private authFailure;
-    /** S-866 ③:两条连接级失败臂的**唯一**收尾 —— 按姿态穷举(加一种姿态 = 编译红)。 */
+    /** [ref] ③:两条连接级失败臂的**唯一**收尾 —— 按姿态穷举(加一种姿态 = 编译红)。 */
     private connectionFailure;
     private set;
+    /** 单飞在箱内:同一身份同一 principal 的并发谈判共用一条;换了人的谈判各发各的([ref])。 */
     private issueOrRenew;
     private issueOrRenewInner;
 }
 /**
- * Env/config gate:中心车道配齐({@link centerLaneConfigured} —— 与 fleet 用量环 / 用量累加器**同一只**谓词,S-866 ④)即启;
+ * Env/config gate:中心车道配齐({@link centerLaneConfigured} —— 与 fleet 用量环 / 用量累加器**同一只**谓词,[ref] ④)即启;
  * 不需要 FLEET_ADVERTISE_ADDRESS(它是出站消费面,不是入站可达性声明)。缺任一件 → undefined,非 fleet 部署零行为变化。
- * S-651:按**声明**装、不按内容装 —— `SEMA_WEB_ADMIN_TOKEN_FILE`(`WEB_ADMIN_ENV.tokenFile`)在场而
+ * [ref]:按**声明**装、不按内容装 —— `SEMA_WEB_ADMIN_TOKEN_FILE`(`WEB_ADMIN_ENV.tokenFile`)在场而
  * 文件此刻不可读,管理器照样装上(每次协商取值,失败走响亮的鉴权失败臂;文件恢复即恢复)。
  */
 export declare function createFleetLeaseFromEnv(cfg: {

package/dist/fleet-lease.js

@@ -1,5 +1,5 @@
 import { QuotaLease, leaseExhausted, shouldRenewLease } from "@sema-agent/settings-schema/fleet";
-import { CenterCredentialUnavailableError } from "./center-credential.js";
+import { CenterCredentialUnavailableError, createIdentityBins, pinAccountingIdentity } from "./center-credential.js";
 import { centerFetch, centerLaneConfigured } from "./web-admin-client/center-request.js";
 export const NOT_LEASE_TTL_MS = 10 * 60 * 1000;
 export const EXHAUSTED_RETRY_MS = 30 * 1000;
@@ -23,8 +23,7 @@ const LEASE_HEALTH_BY_OUTCOME = {
 };
 export class FleetLeaseManager {
     opts;
-    state = new Map();
-    inflight = new Map();
+    binNow;
     f;
     now;
     failStreak = 0;
@@ -35,10 +34,19 @@ export class FleetLeaseManager {
         this.f = opts.fetchImpl ?? fetch;
         this.now = opts.now ?? Date.now;
         this.failMode = opts.failMode;
+        this.binNow = createIdentityBins(opts.center.credential, (pinned) => ({
+            state: new Map(),
+            inflight: new Map(),
+            center: { ...opts.center, credential: pinned },
+        })).accounting;
+    }
+    pinExecution() {
+        pinAccountingIdentity(this.opts.center.credential);
     }
     async admit(principal) {
+        const bin = this.binNow();
         const now = this.now();
-        const st = this.state.get(principal);
+        const st = bin.state.get(principal);
         if (st?.kind === "not-lease" && now < st.until)
             return { ok: true };
         if (st?.kind === "exhausted" && now < st.until) {
@@ -46,15 +54,15 @@ export class FleetLeaseManager {
         }
         if (st?.kind === "lease" && !leaseExhausted(st.lease, now)) {
             if (shouldRenewLease(st.lease, now))
-                void this.issueOrRenew(principal).catch(() => undefined);
+                void this.issueOrRenew(bin, principal).catch(() => undefined);
             return { ok: true };
         }
-        return this.issueOrRenew(principal);
+        return this.issueOrRenew(bin, principal);
     }
     recordSpend(principal, d) {
         if (!principal)
             return;
-        const st = this.state.get(principal);
+        const st = this.binNow().state.get(principal);
         if (st?.kind !== "lease")
             return;
         st.lease.consumed.weightedTokens += d.weightedTokens ?? 0;
@@ -62,7 +70,7 @@ export class FleetLeaseManager {
     }
     snapshot(principal, now) {
         const leaseHealth = LEASE_HEALTH_BY_OUTCOME[this.lastAdmit];
-        const st = principal === undefined ? undefined : this.state.get(principal);
+        const st = principal === undefined ? undefined : this.binNow().state.get(principal);
         if (st === undefined)
             return { leaseHealth, caller: { lease: "unobserved" } };
         switch (st.kind) {
@@ -97,25 +105,25 @@ export class FleetLeaseManager {
             }
         }
     }
-    set(principal, st) {
-        if (!this.state.has(principal) && this.state.size >= LEASE_PRINCIPAL_CAP) {
-            const oldest = this.state.keys().next().value;
-            this.state.delete(oldest);
+    set(bin, principal, st) {
+        if (!bin.state.has(principal) && bin.state.size >= LEASE_PRINCIPAL_CAP) {
+            const oldest = bin.state.keys().next().value;
+            bin.state.delete(oldest);
         }
-        this.state.delete(principal);
-        this.state.set(principal, st);
+        bin.state.delete(principal);
+        bin.state.set(principal, st);
     }
-    issueOrRenew(principal) {
-        const existing = this.inflight.get(principal);
+    issueOrRenew(bin, principal) {
+        const existing = bin.inflight.get(principal);
         if (existing)
             return existing;
-        const p = this.issueOrRenewInner(principal).finally(() => this.inflight.delete(principal));
-        this.inflight.set(principal, p);
+        const p = this.issueOrRenewInner(bin, principal).finally(() => bin.inflight.delete(principal));
+        bin.inflight.set(principal, p);
         return p;
     }
-    async issueOrRenewInner(principal) {
+    async issueOrRenewInner(bin, principal) {
         try {
-            const { res } = await centerFetch(this.opts.center, { kind: "fleet-leases" }, {
+            const { res } = await centerFetch(bin.center, { kind: "fleet-leases" }, {
                 method: "POST",
                 json: { principal, worker: this.opts.center.worker },
                 timeoutMs: LEASE_FETCH_TIMEOUT_MS,
@@ -124,7 +132,7 @@ export class FleetLeaseManager {
             if (res.status === 200) {
                 const body = (await res.json());
                 const lease = QuotaLease.parse(body.lease);
-                this.set(principal, { kind: "lease", lease });
+                this.set(bin, principal, { kind: "lease", lease });
                 if (this.failStreak > 0)
                     this.opts.logger?.info?.("fleet_lease_recovered", { after: this.failStreak });
                 this.failStreak = 0;
@@ -145,11 +153,11 @@ export class FleetLeaseManager {
                         ...(body.pool !== undefined ? { pool: body.pool } : {}),
                     };
                     const hasDetail = Object.keys(detail).length > 0;
-                    this.set(principal, { kind: "exhausted", until, ...(hasDetail ? { detail } : {}) });
+                    this.set(bin, principal, { kind: "exhausted", until, ...(hasDetail ? { detail } : {}) });
                     this.opts.metrics?.inc("fleet_lease_exhausted_total");
                     return { ok: false, reason: "budget_exhausted", retryAfterSec: Math.ceil(EXHAUSTED_RETRY_MS / 1000), ...(hasDetail ? { detail } : {}) };
                 }
-                this.set(principal, { kind: "not-lease", until: this.now() + NOT_LEASE_TTL_MS });
+                this.set(bin, principal, { kind: "not-lease", until: this.now() + NOT_LEASE_TTL_MS });
                 return { ok: true };
             }
             if (res.status === 401 || res.status === 403 || res.status === 400) {

package/dist/governance-http-status.d.ts

@@ -1,5 +1,5 @@
 /**
- * S-189 —— core `GOVERNANCE_CODES` **闭集**在本分诊面上的逐码处置表。
+ * [ref] —— core `GOVERNANCE_CODES` **闭集**在本分诊面上的逐码处置表。
  *
  * 为什么单独一张表而不是继续往下面的 if 链里加行:`failureCodeOf` 是**开集**(顶注写死「消费点一律带
  * default 臂,禁按穷举写」),而开集里嵌着 core 这一个**闭集注册表**。闭集的成员共享两个性质——同一条
@@ -11,7 +11,7 @@
  * 值 `null` = **有意**不在本腿分诊(理由逐条写在行上),与「忘了写」在类型上不同形 —— 这是本表存在的
  * 全部意义:让「没表态」不可能静默发生。开集那一半(下面的 if 链 + `resume_at.` 前缀臂 + default)不动。
  *
- * 逐码预期的**行为面**镜像在 `test/resume-anchor.test.ts` 的 S-189 段(同型同义、刻意不共用这张表:
+ * 逐码预期的**行为面**镜像在 `test/resume-anchor.test.ts` 的 [ref] 段(同型同义、刻意不共用这张表:
  * 测试喂码进函数看状态码,不读本表,否则表写错了两边一起错还全绿)。
  */
 export declare const GOVERNANCE_HTTP_STATUS: {

package/dist/hooks/hook-llm.d.ts

@@ -5,23 +5,23 @@ import type { HookLlmCall, HookLlmFailureCode } from "./hook-runner.js";
  * hookLlm(prompt 条目/session titler 的模型载体)= 直连一次非流式 completion,从 main.ts 抽出成可注入
  * 单元(fetchImpl/keyResolver 可假),因为这条 wire 在每个默认部署上都活(titler),必须可单测。
  *
- * api 形分派(2026-07-15,黑板 [ref]③b 真缺陷修;**选线依据 S-1630 起改为引擎主路由同一只判词**,见下):被选模型按所落的 brain 腿分家 ——
+ * api 形分派(2026-07-15,黑板 [ref]③b 真缺陷修;**选线依据 [ref] 起改为引擎主路由同一只判词**,见下):被选模型按所落的 brain 腿分家 ——
  *  - `openai-completions` ⇒ POST {base}/chat/completions(现状,字节不变);
  *  - `anthropic-messages` ⇒ POST {base}/v1/messages(x-api-key / Authorization: Bearer + anthropic-version
  *    头,messages 数组,回包取 content[].text)。此前 hookLlm 只会说 openai 形且缺省 baseUrl 恒落
- *    `config.gatewayBaseUrl`(当年它有一个本机 8000 端口的出厂缺省,S-623 已删)——anthropic 单路由部署(主模型
+ *    `config.gatewayBaseUrl`(当年它有一个本机 8000 端口的出厂缺省,[ref] 已删)——anthropic 单路由部署(主模型
  *    provider=anthropic 走 ANTHROPIC_BASE_URL,没配 MODEL_GATEWAY_BASEURL)下 titler 每会话打死
  *    localhost:8000 ⇒ `session_title_failed: TypeError: fetch failed`;即使端点活着,anthropic-messages
  *    模型也不能用 /chat/completions 形调。
  *
- * 🔴 **选线 = 引擎主路由同一只判词**(S-1630):「这只模型走 openai-completions 还是 anthropic-messages」不是本面的事,
+ * 🔴 **选线 = 引擎主路由同一只判词**([ref]):「这只模型走 openai-completions 还是 anthropic-messages」不是本面的事,
  * 是引擎主路由的事 —— `brain.ts` 按 `model.provider` 在「anthropic 路由(仅当 ANTHROPIC 凭据把它装上)/ 网关栈」之间选,
  * 路由没装时整台机器只有网关这一只 brain,**连 `provider:"anthropic"` 的模型也落网关**(判词 `brainLaneFor` = 引擎 `brainLaneOf` 对装上的路由表的答案,
  * 端点判官 / 降级腿 / 启动摘要读的是同一只)。本面此前自己按 `provider === "anthropic"` / `api === "anthropic-messages"`
  * 字面判线 ⇒ 在 `MODEL_PROVIDER=anthropic` 而只配了网关的部署上,主请求去网关、标题与 hooks 的 llm 面却要找一条没装的
  * anthropic 路由,整条拒发(零请求,只落 fail-open 标签)。现在本面只问那一只判词,不留第二个读法 —— 含 `api` 词:
  * 引擎不按 `api` 选线(core 的 `createRoutingBrain` 缺省按 `provider` 键),settings-schema 的 `ModelEntry` 又强制两个词同真同假。
- * (S-1630 的 (a) 路已兑现:core 7.53.0 #1842 根导出了那只判官 `brainLaneOf(model, routes)` —— `createRoutingBrain` 对每个请求问的就是它;
+ * ([ref] 的 (a) 路已兑现:core 7.53.0 [ref] 根导出了那只判官 `brainLaneOf(model, routes)` —— `createRoutingBrain` 对每个请求问的就是它;
  * 本仓自写的合取 `dispatchBrainLane` 随之退役,本调用点与另三处一并改问它。)
  */
 export type HookModelPick = {
@@ -31,14 +31,14 @@ export type HookModelPick = {
     baseUrl: string;
     api: "openai-completions" | "anthropic-messages";
 }
-/** 选不出来的那一臂自带失败码(S-1635):两个载体(prompt 直连 / agent 子代理)共用这一只选模闸,同一只判词同一个码。 */
+/** 选不出来的那一臂自带失败码([ref]):两个载体(prompt 直连 / agent 子代理)共用这一只选模闸,同一只判词同一个码。 */
  | {
     ok: false;
     error: string;
     code: Extract<HookLlmFailureCode, "model_unresolved">;
 };
 /**
- * 🔴 **hook 失败展示文本的唯一铸点**(S-494;`build*` = 返回纯数据的一只纯函数)。
+ * 🔴 **hook 失败展示文本的唯一铸点**([ref];`build*` = 返回纯数据的一只纯函数)。
  *
  * 病(codex 对 7.88.1/7.88.2 的补审抓出,存量泄漏,本车红先复现):这一族失败文本是**拼**出来的 ——
  * 料有四种:core 的路由拒绝文案(`routeRefusalText` 的 `fixHint` 逐字带 `config.baseUrl` 的值)、
@@ -59,7 +59,7 @@ export type HookModelPick = {
  * 🚧 **已知射程边界(登记,另车修在源头)**:自由文本律对**非规范拼法**的 URL
  * (`https:alice:pw@h/v1` 省了 `//`、authority 里夹 tab)认不出结构 ⇒ 那两形若出现在料里(目录下发的
  * `models[].baseUrl` 今天原样存,`apply-effective.ts` 只校验 `protocol`)仍会原样。修在源头 =
- * 目录 baseUrl 落库前归一成 `new URL(raw).href`(S-483 收车档未闭环项),不是在这里再加一把尺。
+ * 目录 baseUrl 落库前归一成 `new URL(raw).href`([ref] 收车档未闭环项),不是在这里再加一把尺。
  */
 export declare function buildHookFailureText(raw: string): string;
 /** The live object `createHookLlm` produces — model-pick resolution + the direct completion call, both capturing the hot-refreshed keyResolver/fetchImpl in closure. */