@sema-agent/client-core 0.37.0 → 0.38.1

package/dist/engineCapsCache.d.ts

@@ -34,7 +34,39 @@ export declare function kickEngineCapsProbe(baseUrl: string, probe: () => Promis
  * 绝不 reject(探测失败=位维持未判,调用方按缺席降级)。
  */
 export declare function engineCapsSettled(baseUrl: string | undefined): Promise<void>;
-/** 同步读口:该 base 的 caps 里 key 是否字面 true(未判/缺键 = false)。 */
+/**
+ * 能力位的**可分辨读数**(#318 件③,cli [4752] 自领缺口2)——{@link engineCapTrue} 的三态化底座。
+ *
+ * 病:`engineCapTrue` 只回 `true`/`false`,于是 `false` 同时承载**四件互不相同**的事 ——
+ * 「引擎明说没有」「还没探」「探测在飞」「探测失败」。对**放行判据**而言这个塌缩是正确且刻意的
+ * (缺席一律 fail-closed 不渲 affordance,见 engineCapTrue 的头注),但对**自检/诊断面**(doctor)
+ * 它是致命的:doctor 要报的正是「这台引擎到底说了什么」,把「不知道」印成「没有」就是谎报。
+ * 这也是 doctor 此前无法复用本共享缓存、只能自己再探一遍的直接原因。
+ *
+ * 🔴 **闭集,且每个成员各自可行动**(A1 禁哨兵值双义):
+ *  · `true` / `false` —— caps **已落地**且该键字面为该布尔值 = **引擎明说**;
+ *  · `unprobed` —— 该 base 此刻没有已落地的 caps(没 kick / 在飞 / 探测失败 / 刚被
+ *    {@link invalidateEngineCaps} 作废)。🔴 四种成因**故意合并**:它们对调用方是同一个动作 ——
+ *    `await` 一次 {@link engineCapsSettled} 再读,或按「不知道」呈现。分开需要引擎没给的信息;
+ *  · `absent` —— caps 已落地,但**没有这个键**:引擎比本包旧(还没这条车道)或比本包新(改名了);
+ *  · `non_boolean` —— caps 已落地、键也在,但值不是布尔。这一档**不并进 `absent`**:那会是假话
+ *    (键在),而它指向的是真问题(引擎申报了一个本口读不动的形 —— 比如把 caps 位写成了字符串),
+ *    诊断面该看见它。
+ *
+ * 🔴 **本读口不改变任何放行语义**:{@link engineCapTrue} 逐字等价于 `engineCapState(...) === 'true'`
+ * (下面就是这么实现的,单源)。放行面**继续**用 `engineCapTrue` —— 拿三态去开放行分支,等于把
+ * fail-closed 改成「按成因区别对待」,那是另一件事,不在本口的授权内。
+ */
+export type EngineCapState = 'true' | 'false' | 'unprobed' | 'absent' | 'non_boolean';
+/**
+ * 同步读口(三态化):该 base 的 caps 里 key 的**可分辨**读数。语义逐条见 {@link EngineCapState}。
+ *
+ * `baseUrl` 缺席 ⇒ `unprobed`(没有 base 就没有任何一次探测,这不是「引擎说没有」)。
+ */
+export declare function engineCapState(baseUrl: string | undefined, key: string): EngineCapState;
+/** 同步读口:该 base 的 caps 里 key 是否字面 true(未判/缺键 = false)。
+ *  🔴 **语义一字不变**(#318 件③ 三态化后改为经 {@link engineCapState} 单源实现):放行面读的就是
+ *  这一口,四种「不知道」继续一律折成 `false` = fail-closed。要分辨成因请读 {@link engineCapState}。 */
 export declare function engineCapTrue(baseUrl: string | undefined, key: string): boolean;
 /**
  * 同步读口(字符串键):该 base 的 caps 里 key 的字符串值,未判/缺键/非字符串 ⇒ undefined。

package/dist/engineCapsCache.js

@@ -143,11 +143,33 @@ export async function engineCapsSettled(baseUrl) {
             return;
     }
 }
-/** 同步读口:该 base 的 caps 里 key 是否字面 true(未判/缺键 = false)。 */
-export function engineCapTrue(baseUrl, key) {
+/**
+ * 同步读口(三态化):该 base 的 caps 里 key 的**可分辨**读数。语义逐条见 {@link EngineCapState}。
+ *
+ * `baseUrl` 缺席 ⇒ `unprobed`(没有 base 就没有任何一次探测,这不是「引擎说没有」)。
+ */
+export function engineCapState(baseUrl, key) {
     if (!baseUrl)
-        return false;
-    return capsByBase.get(baseUrl)?.[key] === true;
+        return 'unprobed';
+    const caps = capsByBase.get(baseUrl);
+    if (caps === undefined)
+        return 'unprobed';
+    // 🔴 `in` 而不是 `!== undefined`:引擎显式发 `{"foo": undefined}` 在 JSON 上不可能,但本表也接
+    //    宿主注入的对象;`in` 问的是「键在不在」,正是 `absent` 这一档要答的问题。
+    if (!(key in caps))
+        return 'absent';
+    const v = caps[key];
+    if (v === true)
+        return 'true';
+    if (v === false)
+        return 'false';
+    return 'non_boolean';
+}
+/** 同步读口:该 base 的 caps 里 key 是否字面 true(未判/缺键 = false)。
+ *  🔴 **语义一字不变**(#318 件③ 三态化后改为经 {@link engineCapState} 单源实现):放行面读的就是
+ *  这一口,四种「不知道」继续一律折成 `false` = fail-closed。要分辨成因请读 {@link engineCapState}。 */
+export function engineCapTrue(baseUrl, key) {
+    return engineCapState(baseUrl, key) === 'true';
 }
 /**
  * 同步读口(字符串键):该 base 的 caps 里 key 的字符串值,未判/缺键/非字符串 ⇒ undefined。

package/dist/engineErrorCodes.d.ts

@@ -59,11 +59,31 @@ export declare const CONFIG_STRATEGY_FIND_LIMIT_INVALID = "config.strategy_find_
 export declare const CONFIG_STRATEGY_MAX_SIZE_INVALID = "config.strategy_max_size_invalid";
 /** 未知的 limits 键(5.8.0 起:同时发新旧两代键会在这里当场失败,所以写面只发单一新形)。 */
 export declare const CONFIG_LIMIT_UNKNOWN_KEY = "config.limit_unknown_key";
+/**
+ * `RunnerDeps.delegationEntryCaps`(core 5.48.0 / design/323,[4743] @cli 点名件)的坏值拒。
+ *
+ * 两种拒绝形:成员不是正整数(NaN / 0 / 负数 / 分数 / 非数),或**解出的一对**满足
+ * `maxConcurrent > maxCumulativePerSession`(一棵树不可能同时跑得比它这辈子能创建的还多 ——
+ * 这是矛盾不是偏好)。缺席成员取 CC 对齐缺省(20 / 200)。
+ * 🔴 与本族其余成员同律:**坏旋钮响亮拒,绝不静默折回缺省**。
+ */
+export declare const CONFIG_DELEGATION_ENTRY_CAPS = "config.delegation_entry_caps";
 /**
  * 已知的配置拒绝码(**识别表,非白名单**)。判「这是不是一条配置拒绝」请用
  * {@link isConfigRefusalCode} —— 它按 `config.` 前缀判,未来新成员自动落进来。
  */
 export declare const CONFIG_REFUSAL_CODES: ReadonlySet<string>;
+/** 并发帽:这棵树此刻活着的委派席位已达 `delegationEntryCaps.maxConcurrent`(CC 对齐缺省 20)。
+ *  🔴 处置 = **可等**(兄弟结束即有位),别渲成「配置要改」。 */
+export declare const DELEGATION_CONCURRENCY_CAP = "delegation.concurrency_cap";
+/** 会话累计帽:这棵树累计创建的委派席位已达 `maxCumulativePerSession`(CC 对齐缺省 200)。
+ *  🔴 处置 = **等也没用**(配额是这条会话这辈子的),别渲成「稍后重试」。 */
+export declare const DELEGATION_SESSION_CAP = "delegation.session_cap";
+/** 委派席位到限码识别表(**开集**:core 可能再加第三根轴)。两员处置不对称,消费点禁合并分支。 */
+export declare const DELEGATION_CAP_CODES: ReadonlySet<string>;
+/** `delegation.` 前缀谓词 —— **开集**判别(与 {@link isConfigRefusalCode} 同款)。缺席/空串 ⇒ false。
+ *  🔴 它只回答「这是不是一条委派席位拒绝」;**该等还是该换会话**必须按成员分,见两码各自的注释。 */
+export declare function isDelegationCapCode(code: string | undefined): boolean;
 /** `config.` 前缀谓词 —— **开集**判别:5.10.0 之后每一波「不许静默折叠」都会往这一族加词,
  *  按前缀判的消费点不必跟车,按成员判的必须跟车。缺席/空串 ⇒ false。 */
 export declare function isConfigRefusalCode(code: string | undefined): boolean;

package/dist/engineErrorCodes.js

@@ -67,6 +67,15 @@ export const CONFIG_STRATEGY_FIND_LIMIT_INVALID = 'config.strategy_find_limit_in
 export const CONFIG_STRATEGY_MAX_SIZE_INVALID = 'config.strategy_max_size_invalid';
 /** 未知的 limits 键(5.8.0 起:同时发新旧两代键会在这里当场失败,所以写面只发单一新形)。 */
 export const CONFIG_LIMIT_UNKNOWN_KEY = 'config.limit_unknown_key';
+/**
+ * `RunnerDeps.delegationEntryCaps`(core 5.48.0 / design/323,[4743] @cli 点名件)的坏值拒。
+ *
+ * 两种拒绝形:成员不是正整数(NaN / 0 / 负数 / 分数 / 非数),或**解出的一对**满足
+ * `maxConcurrent > maxCumulativePerSession`(一棵树不可能同时跑得比它这辈子能创建的还多 ——
+ * 这是矛盾不是偏好)。缺席成员取 CC 对齐缺省(20 / 200)。
+ * 🔴 与本族其余成员同律:**坏旋钮响亮拒,绝不静默折回缺省**。
+ */
+export const CONFIG_DELEGATION_ENTRY_CAPS = 'config.delegation_entry_caps';
 /**
  * 已知的配置拒绝码(**识别表,非白名单**)。判「这是不是一条配置拒绝」请用
  * {@link isConfigRefusalCode} —— 它按 `config.` 前缀判,未来新成员自动落进来。
@@ -76,7 +85,42 @@ export const CONFIG_REFUSAL_CODES = new Set([
     CONFIG_STRATEGY_FIND_LIMIT_INVALID,
     CONFIG_STRATEGY_MAX_SIZE_INVALID,
     CONFIG_LIMIT_UNKNOWN_KEY,
+    CONFIG_DELEGATION_ENTRY_CAPS,
 ]);
+// ── 委派席位到限族(core 5.48.0 design/323,[4743] @cli 点名的「两新 coded 拒绝」)──────────────
+//
+// 语义:一次 Task/SendMessage 委派因为**席位帽**被拒 —— 不是配置坏了(那是上面的
+// `config.delegation_entry_caps`),也不是失败了,而是「现在不行」。两码**处置不同,禁合并**:
+//   · 并发帽 ⇒ **等**:活着的兄弟结束就有位,同一条命令过一会儿照样成;
+//   · 会话累计帽 ⇒ **等也没用**:这棵树这辈子的配额用完了,要么换会话要么抬 deps 旋钮。
+// 把两者渲成同一句「委派失败」会让第一种情形的用户去改配置,第二种情形的用户去干等。
+//
+// 🔴 **载体如实登记(2026-08-21 亲验,别按 `tool_end.errorCode` 写消费码)**:core 把这两码铸进
+//    Task 工具结果体的 `details.error`(`subagent.ts` 的 `capRefusal`),而 core 的 `errorCode`
+//    抬升腿(`runner/runtask.ts`)只读 `details.code` → `details.errorKind` **两个拼法**,
+//    `structuredFrom` 又要求 `details.type` 落在 `CC_DETAIL_TYPES` 里(这条 detail 连 `type` 都没有)
+//    ⇒ **今天这两码在 wire 上既不在 `tool_end.errorCode`、也不在 `structured`**,只剩模型面文案
+//    ("Sub-agent not started in background: …")。
+//    ⇒ 本词表**先立词、不落消费分支**:按文案反解正是本文件存在的理由要根除的东西
+//    ([cross-repo-fix-at-source-constitution]:载体缺口在 core,下游不许侧路补救)。
+//    上游诉求已登记(见 CHANGELOG 0.38.0 段):core 补 `details.code` 孪生拼法(或抬升腿兼读
+//    `details.error`)之后,消费分支在本包同批接上,**判定归本包、文案归端**。
+/** 并发帽:这棵树此刻活着的委派席位已达 `delegationEntryCaps.maxConcurrent`(CC 对齐缺省 20)。
+ *  🔴 处置 = **可等**(兄弟结束即有位),别渲成「配置要改」。 */
+export const DELEGATION_CONCURRENCY_CAP = 'delegation.concurrency_cap';
+/** 会话累计帽:这棵树累计创建的委派席位已达 `maxCumulativePerSession`(CC 对齐缺省 200)。
+ *  🔴 处置 = **等也没用**(配额是这条会话这辈子的),别渲成「稍后重试」。 */
+export const DELEGATION_SESSION_CAP = 'delegation.session_cap';
+/** 委派席位到限码识别表(**开集**:core 可能再加第三根轴)。两员处置不对称,消费点禁合并分支。 */
+export const DELEGATION_CAP_CODES = new Set([
+    DELEGATION_CONCURRENCY_CAP,
+    DELEGATION_SESSION_CAP,
+]);
+/** `delegation.` 前缀谓词 —— **开集**判别(与 {@link isConfigRefusalCode} 同款)。缺席/空串 ⇒ false。
+ *  🔴 它只回答「这是不是一条委派席位拒绝」;**该等还是该换会话**必须按成员分,见两码各自的注释。 */
+export function isDelegationCapCode(code) {
+    return typeof code === 'string' && code.startsWith('delegation.');
+}
 /** `config.` 前缀谓词 —— **开集**判别:5.10.0 之后每一波「不许静默折叠」都会往这一族加词,
  *  按前缀判的消费点不必跟车,按成员判的必须跟车。缺席/空串 ⇒ false。 */
 export function isConfigRefusalCode(code) {

package/dist/fleet/fleetLedger.d.ts

@@ -121,7 +121,7 @@ export type HookNoticeFrame = Extract<FleetFrame, {
  * 端因此无法对不同强度的证据分级处置(强证据可直接落库/翻卡,弱证据宜先渲染、别拿它当归属结论)。
  * 判据锚在**实际命中的那条臂**上,不是锚在「有没有 parentTaskId」这类前置条件上。
  *
- * 🔴 **每个词命名的是「放行臂」,不是「归属结论」**(codex 复审两轮收紧:首版把 `own_parent` 写成
+ * 🔴 **每个词命名的是「放行臂」,不是「归属结论」**(对抗复审两轮收紧:首版把 `own_parent` 写成
  *    「硬证据」、二版只给 `own_root` 挂了会话锚警告,都是过度声称)。强度分档如下 —— 前两格的
  *    会话级读法**带前提**,第三格永远只是进程级,第四格根本不是证据。
  *

package/dist/fleet/fleetLedger.js

@@ -214,7 +214,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                 for (const row of frame.tasks) {
                     taskMap.set(row.id, row);
                     rowMeta.set(row.id, { receivedAtMs });
-                    // #242 批 3(codex P-F1,红先绿后=B3-G4b):snapshot(重连 REPLACE)腿与增量 task 帧腿
+                    // #242 批 3(复审 P-F1,红先绿后=B3-G4b):snapshot(重连 REPLACE)腿与增量 task 帧腿
                     // 的复活语义**同权** —— snapshot 带回的非终态行,其全部别名(同尾段)的 belt 退休条目
                     // 一并清,否则重连别名切换(裸 id 退休 → 复合 id running 回归)会产出「复合 running +
                     // 裸 completed(带标)」双影。终态行不清(与增量腿同判);snapshot 里**没有**的任务,
@@ -350,7 +350,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             debug('[fleet-frame] MALFORMED bg_notification dropped(taskId 或 status 缺席/非串)');
             return;
         }
-        // 🔴 #284 尾件(codex 复审第四轮 high,红先绿后=B3-DIRTY):`parentTaskId` 是**隔离判据的锚**,
+        // 🔴 #284 尾件(对抗复审第四轮 high,红先绿后=B3-DIRTY):`parentTaskId` 是**隔离判据的锚**,
         //    它的脏形必须先于判据处置。下面那道 own/foreign 门写成
         //    `typeof === 'string' && length > 0 && !isOwnEngineRun(…)` —— 对 number/object/boolean
         //    这类脏值**整条不成立** ⇒ 门不响、通知照收,而新的 evidence 还会把它标成 `absent_parent`
@@ -400,7 +400,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
         //    `parentTaskId` 在不在分开(走到这里且带非空 parentTaskId ⇒ 它必然 ∈ own-run 台账,
         //    否则上面已丢弃)。多臂同时成立报第一条 —— 报的是「这一帧**实际**靠哪条过的门」,
         //    不是「最强的那条理论上也成立」。
-        // 🔴 非默认 sessionKey 封顶(0.32.0 发包前扫码采 codex 折中,P-31 的诚实半步):前两格的
+        // 🔴 非默认 sessionKey 封顶(0.32.0 发包前扫码采 复审 折中,P-31 的诚实半步):前两格的
         //    会话级读法前提=「这条流是按本 ledger 的会话开的」,而开流参数只认默认槽 ⇒ keyed ledger
         //    上该前提**无法成立也无法校验**。封顶词=`session_anchor_untrusted`(不降到 own_parent:
         //    经 serverFailClosed/ownByRoot 放行的帧,其 parentTaskId 可能是 foreign——标进程成员是

package/dist/fleet/fleetProjection.d.ts

@@ -93,6 +93,18 @@ export interface FleetTaskView {
         path: string;
         edits: number;
     }>;
+    /**
+     * #261 §2① 代际号(0.38.0 提货补投;取值规则见 {@link wireCycleSeq})。
+     * 同 id 帧 `cycleSeq` 更大 ⇒ **复活**(新代际,行内累计量重置);更小 ⇒ 前代迟到帧,忽略;
+     * **缺席 ⇒ 这条行没有代际概念**(不是第一代)。
+     */
+    cycleSeq?: number;
+    /**
+     * #261 §2② 非亲报终态的投影者(0.38.0 提货补投;取值规则见 {@link wireRetiredBy})。
+     * **在场 = 这条终态是对账腿从 durable run 行读出来的**(发布方死了),缺席 = 发布方亲报。
+     * 读侧开集,未知词通渲。
+     */
+    retiredBy?: string;
 }
 /** 终态行帧 / bg 通知帧共用的 usage 形(SDK `FleetTaskRow.usage` ≡ `FleetBgNotification.usage`)。 */
 export interface FleetRowUsage {
@@ -230,6 +242,28 @@ export declare function wireEditedFiles(r: Pick<FleetTaskRow, 'editedFiles'>): A
 }> | undefined;
 /** 终态四键之 `stoppedBy`(开放枚举 verbatim:"user"/"parent"/"system"/…)。 */
 export declare function wireStoppedBy(r: Pick<FleetTaskRow, 'stoppedBy'>): string | undefined;
+/**
+ * #261 §2① `cycleSeq`(server ≥7.25.0 / core 5.36.0 #258;SDK **7.2.0** 才把它声明进
+ * `FleetTaskRow` ⇒ 本包 0.38.0 提货补投)—— 这一行的**代际号**,与 `FleetBgNotification.seq` /
+ * `task_progress.seq` **同域同轴**(fresh spawn 就是 cycle 1,每次 SendMessage 复活翻 +1)。
+ *
+ * 🔴 **缺席 = 「无此概念」,不是「第一代」**(SDK 头注逐字):没有 `a*` registry 行的 run ——
+ * 同步委派子代 / workflow `wa*` agent / **顶层 run 行** —— 根本没有代际。把缺席读成 1 的消费端
+ * 会把「首帧迟到」误判成「复活」。所以这里对**非正整数**一律整键缺席(0 / 负数 / 非有限数 /
+ * 非整数都不是合法代际号),绝不 `?? 0`、绝不 `?? 1`。
+ */
+export declare function wireCycleSeq(r: Pick<FleetTaskRow, 'cycleSeq'>): number | undefined;
+/**
+ * #261 §2② `retiredBy`(server ≥7.25.0;SDK 7.2.0 声明)—— 这一帧的终态**不是发布方亲报**,
+ * 而是对账腿从 durable run 行**投影**出来的(发布方死了,行本会永久僵在活跃集里当幽灵)。
+ *
+ * 🔴 **发布方亲报的终态帧恒不带此键** ⇒ 两种终态在 wire 上可判:要区分「引擎说它完了」与
+ * 「我们从库里读出来它完了」时,这是**唯一**的判据([ghost-rows-need-upstream-liveness] 的
+ * wire 侧对位物 —— 此前本层把这一位整个丢掉,两种终态在视图上同形)。
+ * service 侧今天是单词闭集(`"reconcile"`),**读侧开集**:未知词原样透传(将来的第二个投影者
+ * 会是一个新词而不是改义),消费端 branch 已知值 + 通渲兜底,**绝不**按成员判死。
+ */
+export declare function wireRetiredBy(r: Pick<FleetTaskRow, 'retiredBy'>): string | undefined;
 /** 终态四键之 `resumable`(仅 bg 子代有源;非 boolean ⇒ 缺席,**不当 false**)。 */
 export declare function wireResumable(r: Pick<FleetTaskRow, 'resumable'>): boolean | undefined;
 export interface ProjectTasksOptions {

package/dist/fleet/fleetProjection.js

@@ -218,6 +218,34 @@ export function wireStoppedBy(r) {
     const v = r.stoppedBy;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+/**
+ * #261 §2① `cycleSeq`(server ≥7.25.0 / core 5.36.0 #258;SDK **7.2.0** 才把它声明进
+ * `FleetTaskRow` ⇒ 本包 0.38.0 提货补投)—— 这一行的**代际号**,与 `FleetBgNotification.seq` /
+ * `task_progress.seq` **同域同轴**(fresh spawn 就是 cycle 1,每次 SendMessage 复活翻 +1)。
+ *
+ * 🔴 **缺席 = 「无此概念」,不是「第一代」**(SDK 头注逐字):没有 `a*` registry 行的 run ——
+ * 同步委派子代 / workflow `wa*` agent / **顶层 run 行** —— 根本没有代际。把缺席读成 1 的消费端
+ * 会把「首帧迟到」误判成「复活」。所以这里对**非正整数**一律整键缺席(0 / 负数 / 非有限数 /
+ * 非整数都不是合法代际号),绝不 `?? 0`、绝不 `?? 1`。
+ */
+export function wireCycleSeq(r) {
+    const v = r.cycleSeq;
+    return typeof v === 'number' && Number.isInteger(v) && v > 0 ? v : undefined;
+}
+/**
+ * #261 §2② `retiredBy`(server ≥7.25.0;SDK 7.2.0 声明)—— 这一帧的终态**不是发布方亲报**,
+ * 而是对账腿从 durable run 行**投影**出来的(发布方死了,行本会永久僵在活跃集里当幽灵)。
+ *
+ * 🔴 **发布方亲报的终态帧恒不带此键** ⇒ 两种终态在 wire 上可判:要区分「引擎说它完了」与
+ * 「我们从库里读出来它完了」时,这是**唯一**的判据([ghost-rows-need-upstream-liveness] 的
+ * wire 侧对位物 —— 此前本层把这一位整个丢掉,两种终态在视图上同形)。
+ * service 侧今天是单词闭集(`"reconcile"`),**读侧开集**:未知词原样透传(将来的第二个投影者
+ * 会是一个新词而不是改义),消费端 branch 已知值 + 通渲兜底,**绝不**按成员判死。
+ */
+export function wireRetiredBy(r) {
+    const v = r.retiredBy;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
 /** 终态四键之 `resumable`(仅 bg 子代有源;非 boolean ⇒ 缺席,**不当 false**)。 */
 export function wireResumable(r) {
     return typeof r.resumable === 'boolean' ? r.resumable : undefined;
@@ -257,6 +285,8 @@ export function projectTasks(allRows, opts) {
         const usage = wireRowUsage(r);
         const resumable = wireResumable(r);
         const editedFiles = wireEditedFiles(r);
+        const cycleSeq = wireCycleSeq(r);
+        const retiredBy = wireRetiredBy(r);
         const task = {
             id: r.id,
             name: deriveAgentLabel(r.agentType, r.agentName, r.name, r.id),
@@ -286,6 +316,11 @@ export function projectTasks(allRows, opts) {
             ...(usage !== undefined ? { usage } : {}),
             ...(resumable !== undefined ? { resumable } : {}),
             ...(editedFiles !== undefined ? { editedFiles } : {}),
+            // #261 §2 两位:代际号与「非亲报终态」判别位。两者都是**在场才落键** —— cycleSeq 缺席是
+            // 「这条行没有代际概念」、retiredBy 缺席是「发布方亲报」,任何一个补默认值都会把一个诚实
+            // 缺席翻译成一句假话。
+            ...(cycleSeq !== undefined ? { cycleSeq } : {}),
+            ...(retiredBy !== undefined ? { retiredBy } : {}),
         };
         return task;
     });
@@ -341,6 +376,8 @@ const FLEET_TASK_VIEW_KEY_TUPLE = [
     'usage',
     'resumable',
     'editedFiles',
+    'cycleSeq',
+    'retiredBy',
 ];
 /** `FleetTaskView` 的键名清单(运行期物;编译期与 `keyof FleetTaskView` 双向等值)。 */
 export const FLEET_TASK_VIEW_KEYS = FLEET_TASK_VIEW_KEY_TUPLE;
@@ -382,6 +419,9 @@ const FLEET_TASK_ROW_WIRE_KEY_TUPLE = [
     'usage',
     'resumable',
     'editedFiles',
+    // SDK 7.2.0 新声明的两位(#261 §2,server ≥7.25.0 早已在 wire 上 —— 这是**类型跟车**不是新能力)。
+    'cycleSeq',
+    'retiredBy',
 ];
 /** SDK `FleetTaskRow` 的**入口**键名清单(编译期与 `keyof FleetTaskRow` 双向等值 ⇒ SDK 加一个
  *  wire 键,本元组不跟就编译红;跟了之后覆盖账那条腿再逼你表态「投不投」)。 */

package/dist/hitl/armedGateRegistry.d.ts

@@ -43,7 +43,7 @@ export declare function waitForGateArmedFor(sessionKey: string, keys: readonly s
 /** 宿主呈现面登记口:收到可渲染 question 帧即记(键归一见 gateIdentity;坏形静默忽略 ——
  *  id 是 wire/合成位,入参按边界收 unknown,本函数就是窄化动作本身)。
  *
- *  尝试级回执(#250 codex 轮二 [medium]):原始帧 id 自带 `#reopen-*` 尝试序号,是现成的
+ *  尝试级回执(#250 复审 轮二 [medium]):原始帧 id 自带 `#reopen-*` 尝试序号,是现成的
  *  attempt token —— 归一键之外**事件级**再发一枪原始 id(不入 Set,台账词汇保持归一键)。
  *  重开臂锚它,同 gate 两次在飞重开时一次真入队只唤对应那次尝试,不再同键互唤。 */
 export declare function registerArmedGateFromQuestionId(questionId: unknown): void;

package/dist/hitl/armedGateRegistry.js

@@ -231,7 +231,7 @@ function armedKeyForQuestionIdFor(sessionKey, questionId) {
 /** 宿主呈现面登记口:收到可渲染 question 帧即记(键归一见 gateIdentity;坏形静默忽略 ——
  *  id 是 wire/合成位,入参按边界收 unknown,本函数就是窄化动作本身)。
  *
- *  尝试级回执(#250 codex 轮二 [medium]):原始帧 id 自带 `#reopen-*` 尝试序号,是现成的
+ *  尝试级回执(#250 复审 轮二 [medium]):原始帧 id 自带 `#reopen-*` 尝试序号,是现成的
  *  attempt token —— 归一键之外**事件级**再发一枪原始 id(不入 Set,台账词汇保持归一键)。
  *  重开臂锚它,同 gate 两次在飞重开时一次真入队只唤对应那次尝试,不再同键互唤。 */
 export function registerArmedGateFromQuestionId(questionId) {
@@ -241,7 +241,7 @@ export function registerArmedGateFromQuestionId(questionId) {
 export function registerArmedGateFromQuestionIdFor(sessionKey, questionId) {
     if (typeof questionId !== 'string' || questionId.length === 0)
         return;
-    // 🔴 canonical 复用的去重记号过期(codex #244 F1 轮一 [medium]):arm 臂对同 run 每只 plan gate
+    // 🔴 canonical 复用的去重记号过期(复审 #244 F1 轮一 [medium]):arm 臂对同 run 每只 plan gate
     // 都复用 `plan-review:<taskId>` 这个 canonical id —— 决断记账按完整 questionId 去重,若记号不随
     // 卡换代过期,第二只 canonical 卡的决断会撞上第一只留下的记号 ⇒ 不推代 ⇒ 第三只门的重开又谎报
     // 「被关过」。**新 canonical 卡的呈现**就是「上一张同 id 卡已消解、这是新实例」的宿主侧可见时刻,

package/dist/hitl/hitlBridge.js

@@ -61,12 +61,15 @@ export class HitlSafetyError extends Error {
 // timeoutMs 是 client 构造级旋钮,本包对已构造的注入 client 不可配)。于是一次网络瞬断/超时 =
 // decide 单发即死 → 上层拼 `failed` → parkResolver 合成 `hitl_unanswered` 终帧 → ask 死局。
 //
-// 🔴 [4664] server 定谳的真因与过渡期口径(2026-08-19):60s 超时**结构性必炸** —— legacy 任务级
-// decide 腿(`/v1/approvals/:sessionId/decide`)在响应前**同步跑整条 resume**(模型往返,无上限);
-// server 立件 #316 改快速 ack,过渡期口径 = **壳把这条腿当长调用处理(预期上限无界)**。SDK 的
-// per-attempt 60s 帽对注入 client 不可配(调用面只有 signal,合流只能收短)⇒ 本层的消化形:
-//   · **超时类**(TimeoutError = 60s 帽掐断,server 多半仍在跑 resume)⇒ 带退避**继续重试**,
-//     总窗 {@link DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS}(10 分钟级 —— 长调用口径);
+// 🔴 **口径换代(#318 件②,2026-08-21):超时从「常态」变「真异常」** —— [4664] 的长调用口径作废。
+// server #316([4687] 点名 BREAKING,随 7.37.0 发车)把任务级 decide 的 200 体从**终局形**改成
+// **受理回执** `{taskId, sessionId, status:"resuming", bindingEnforced:true}`:受理点设在 core
+// `resumeStream` 解析之后,一切会变成拒绝的判定(lease 429 / markResuming CAS 409 / core pre-CAS
+// 守卫 / 绑定不符 409 / 卡不在 404)**仍同步发生**,受理后只剩模型段异步跑。实测受理即回 ≈23ms。
+// ⇒ 对 ≥7.37 的部署,一次 60s 超时**不再是**「server 还在跑 resume」的常态,而是**真异常**
+// (网络路径断在半途 / server 病态卡死 / 见下两条残余形)。口径随之收窄:
+//   · **超时类**(TimeoutError = SDK per-attempt 帽掐断)⇒ 仍带退避重试(重试环结构不动),但总窗
+//     从 10 分钟收到 {@link DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS}(十秒级,见该常量的取值推导);
 //   · **网络断类**(ECONNREFUSED / fetch failed 等:连语义答复都没拿到,引擎多半真死)⇒ 重试
 //     **恰一次**,让真死尽快显形;
 //   · 语义答复类(带 HTTP status 的 4xx/5xx —— 引擎收到并回答了)⇒ 零重试,原样上抛;
@@ -81,17 +84,69 @@ export class HitlSafetyError extends Error {
 // (typed 判别位)—— 消费方(toolApprovalWire / parkResolver)据此走**重呈臂**而不是把 turn 判死。
 // 引擎真死时失败也会尽快显形:重呈臂的下一步(approvals.list / runs.events)对死引擎当场失败,
 // 走既有诚实红。
-// 🔴 请托半场(候黑板):SDK decide 若开 per-call timeoutMs(或对 HITL 面单列长缺省),本层的
-// 超时类重试环可整段收敛成一发长等待;#316 落地(快速 ack)后总窗也可回收。
+// 🔴 **两条残余的同步形如实登记**(收窄不是「长调用消失了」,[4687] 逐字):终局形仍存在于
+//   ① **pre-7.37 的 server**(所有 decide 都是终局形 = 真长调用);② **≥7.37 但没有 durable run 行
+//   可跟的部署**(那里提前受理 = 把结果扔掉,所以腿如实保持同步)。本包是三端共用件,面向的是
+//   任意部署 —— 所以重试环**保留**、总窗**不设 0**。这两形上窗尽的代价是可接受的:耗尽走的是
+//   {@link DecideTransportRetryExhaustedError} → **重呈臂**(re-attach ⇒ durable 流重放 park ⇒
+//   同一张卡重交用户),而不是把 turn 判死;若第一发其实已送达,重呈的下一步会撞
+//   `isAlreadyResolvedGateReason` 的已解决判据被救回。
+// 🔴 请托半场(候协作板):SDK decide 若开 per-call timeoutMs(或对 HITL 面单列长缺省),本层的
+// 超时类重试环可整段收敛成一发长等待。
 /** 瞬断重试的起始退避(×2 递增,封顶 {@link DECIDE_RETRY_BACKOFF_MAX_MS};别把 decide 打成连发)。 */
 const DECIDE_TRANSPORT_RETRY_BACKOFF_MS = 750;
 const DECIDE_RETRY_BACKOFF_MAX_MS = 5_000;
-/** 超时类重试的总窗([4664] 长调用口径:legacy decide 腿同步跑整条 resume,60s 帽结构性必炸;
- *  每发本身就要跑满 SDK 的 60s 帽,10 分钟 ≈ 9 发 —— 覆盖长 resume 而不至于无限吊死)。
- *  🔴 窗的语义是**不再起新发**,刻意不掐在飞那一发(codex 复审议题,驳回后成文):给一发可能已被
- *  server 受理的 decide 塞截止 signal 换不来任何安全 —— server 侧照跑,客户端只多制造一个「送达
- *  未知」;上冲上界 = 一发(SDK 60s 帽)+ 一拍退避,可预算。 */
-const DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS = 10 * 60_000;
+/**
+ * SDK 的 **per-attempt 超时帽**(`AbortSignal.timeout(timeoutMs)`)的**缺省值**。
+ *
+ * 🔴 **它是「观察到的缺省」,不是本包能保证的量**(对抗复审 [medium] 采纳,2026-08-21)。
+ * per-call opts 只有 `signal`(与之合流取先,只能收短不能放长),但 `timeoutMs` 是 **client
+ * 构造级**旋钮,而本桥吃的是**宿主注入的** client(`HitlClientLike` 根本不暴露它)⇒ 一个 web/桌面
+ * 宿主完全可以用 30s 或 120s 的 client 构造本桥。所以任何「总窗 ÷ 帽 = 发数」的推导都只在缺省值
+ * 上成立,**不能当成本共用件的性质**。
+ * ⇒ 本常量只用来推导下面那个**墙钟上界**;「至少重试一次」这条**性质**改由
+ * {@link DECIDE_TIMEOUT_MIN_ATTEMPTS} 用**发数**保证,与宿主的 timeoutMs 无关。
+ */
+const DECIDE_ATTEMPT_TIMEOUT_CAP_MS = 60_000;
+/**
+ * 超时类**最少发数**(首发 + 至少一次重试)—— 与墙钟窗**两个独立的界**,不是第二层节奏。
+ *
+ * 🔴 为什么必须有它([4687] 登记的两条残余同步形是承重理由):终局形仍存在于 pre-7.37 的 server
+ * 与「≥7.37 但没有 durable run 行可跟」的部署 —— 那两形上一次超时**极可能是真的还在跑**,
+ * 至少给一次重试是这条腿唯一的补救。若只用墙钟窗判,宿主拿 120s 的 client 构造本桥时首发超时
+ * 那一刻 elapsed 已经 ≥ 窗 ⇒ **一次重试都没有**,而这件事在代码里毫无痕迹(注释还写着「恰一次重试」)。
+ * 🔴 这**不是** [4675] 说的「第二层节奏叠乘」:没有新增任何定时器/退避层,退避仍是同一条
+ * `backoff` 链;这只是同一个循环上的第二个**终止条件**(发数尽 ∧ 窗尽,两者都满足才停)。
+ */
+const DECIDE_TIMEOUT_MIN_ATTEMPTS = 2;
+/**
+ * 超时类重试的总窗(#318 件② 收窄:`10 * 60_000` → 本值)。
+ *
+ * ── 取值推导(锚在 {@link DECIDE_ATTEMPT_TIMEOUT_CAP_MS} 上,不是拍脑袋的整数)────────────────
+ * 窗的语义是**不再起新发**(见下),而每一发超时类失败**本身**就要吃满一个 per-attempt 帽 ⇒
+ * 实际发数由「总窗 ÷ 帽」决定,且量化得很粗:
+ *   · 窗 ≤ 1 帽  ⇒ 窗判本身当场耗尽;
+ *   · 1 帽 < 窗 ≤ 2 帽 ⇒ 窗判允许恰一次重试(共 2 发);
+ *   · > 2 帽 ⇒ 3 发起步,一路回到分钟级。
+ * 受理形下超时是**真异常**(不是「还在跑」),所以取**恰一次重试**那一档:一次重试足够吃掉单次
+ * 网络抖动,再多就是对着一个病态 server 空等。取 90s = 1.5 帽,**刻意落在区间中部**而不是边界
+ * (120s 恰等于 2 帽 + 退避,会让发数悬在退避时序的一根头发上)。
+ * ⇒ 在缺省帽上可预算的最坏墙钟 ≈ 60s(首发)+ 0.75s(退避)+ 60s(重发)≈ 121s,而不是旧口径的 10 分钟。
+ *
+ * 🔴 **本窗只是墙钟上界,不承诺发数**(复审 [medium] 采纳):宿主可以用非缺省 `timeoutMs` 构造
+ * client(见 {@link DECIDE_ATTEMPT_TIMEOUT_CAP_MS}),那时「窗 ÷ 帽」得出的发数与这里写的不同。
+ * 与宿主无关的那条性质(**至少重试一次**)由 {@link DECIDE_TIMEOUT_MIN_ATTEMPTS} 单独保证 ——
+ * 两个界合取:**发数达标 ∧ 窗尽** 才停。所以在 120s client 上是「2 发、~240s」,在 30s client 上
+ * 是「3 发、~92s」,在缺省 60s 上是「2 发、~121s」—— 三者都有界,且都拿得到那一次重试。
+ *
+ * 🔴 窗的语义是**不再起新发**,刻意不掐在飞那一发(对抗复审议题,驳回后成文):给一发可能已被
+ * server 受理的 decide 塞截止 signal 换不来任何安全 —— server 侧照跑,客户端只多制造一个「送达
+ * 未知」。
+ * 🔴 **写成「帽 × 系数」而不是裸 90_000**:上面那段推导只有在两者绑在一起时才会随 SDK 改帽自动
+ * 跟手;写裸整数的话,SDK 哪天把帽改成 30s,注释里的「恰一次重试」当天变成假话而代码全绿。
+ */
+const DECIDE_TIMEOUT_RETRY_BUDGET_ATTEMPT_MULTIPLE = 1.5;
+const DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS = DECIDE_ATTEMPT_TIMEOUT_CAP_MS * DECIDE_TIMEOUT_RETRY_BUDGET_ATTEMPT_MULTIPLE;
 let decideTimeoutRetryBudgetOverrideMs;
 /** 测试钩:把超时类重试总窗调小(传 undefined 还原缺省)。 */
 export function __setDecideTimeoutRetryBudgetForTests(ms) {
@@ -457,10 +512,14 @@ export class HitlBridge {
                 if (!isTransientDecideTransportFailure(e) || callerAborted())
                     throw e;
                 if (isDecideAttemptTimeout(e)) {
-                    // [4664] 长调用口径:60s 帽掐断 ≠ 引擎死了 —— legacy decide 腿在响应前同步跑整条 resume。
-                    // 重复 decide 由 server CAS 保证不双跑:server 已受理时,下一发要么等到快速答复(conflict/
-                    // not-found ⇒ 上抛,已解决判据接手),要么继续被长调用吃满 60s —— 总窗兜底。
-                    if (Date.now() - startedAt >= decideTimeoutRetryBudgetMs()) {
+                    // #318 件② 后口径:受理形(server ≥7.37)下 decide 受理即回,一次 per-attempt 帽掐断
+                    // **是真异常**,不再是「server 还在跑 resume」的常态 —— 所以总窗只留恰一次重试的量
+                    // (推导见 DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS)。重发仍然安全:重复 decide 由 server CAS
+                    // 保证不双跑,首发其实送达时下一发只会撞 4xx(conflict/not-found ⇒ 上抛,已解决判据接手)。
+                    // 🔴 **两个界合取**(复审 [medium] 采纳):发数没达标就一定再发一次(与宿主的
+                    //    per-attempt timeoutMs 无关),达标之后才由墙钟窗决定还发不发。少了前半句,
+                    //    120s client 的宿主一次重试都拿不到;少了后半句,30s client 会一路重试到分钟级。
+                    if (attempts >= DECIDE_TIMEOUT_MIN_ATTEMPTS && Date.now() - startedAt >= decideTimeoutRetryBudgetMs()) {
                         throw new DecideTransportRetryExhaustedError(attempts, String(e));
                     }
                 }

package/dist/hitl/persistedRulesWire.d.ts

@@ -123,7 +123,7 @@ export type ListAllPersistedRulesOutcome = {
  * 🔴 **游标绑 `(rev, principal, scope)`**:两页之间有人加/删了规则 ⇒ 第二页 400
  * `request.query_invalid`。处置 = **丢游标从头列一次**(静默重置成「接着上一页」会得到一份既漏行
  * 又重行的清单);从头再撞一次 ⇒ 如实报 cursor-stale,由调用方(人按 r 刷新)决定。
- * 🔴 **调用方 cursor 不收**(codex F2 对抗复审 [medium]):类型上剔掉 `cursor` 还不够 —— JS
+ * 🔴 **调用方 cursor 不收**(复审 F2 对抗复审 [medium]):类型上剔掉 `cursor` 还不够 —— JS
  * 调用方仍能塞进来,而首页的 `...params` 会把它原样送出 ⇒ 「列全」从**中途**开始却报 `ok:true`
  * 完整清单(治理面据此藏掉仍然生效的规则)。运行期显式剥除 + 留痕:drain 恒从第一页起,
  * 「接着别人的 keyset」证明不了完整性,与本函数的契约(rules 恒完整)结构性冲突。

package/dist/hitl/persistedRulesWire.js

@@ -58,7 +58,7 @@ export function classifyRulesFailure(e) {
         return { kind: 'forbidden', message };
     return { kind: 'error', message };
 }
-/** 一页要多少条。**必须显式给**(codex 对抗复审 [medium] 实撞):server 缺省是 **50**,而页帽
+/** 一页要多少条。**必须显式给**(对抗复审 [medium] 实撞):server 缺省是 **50**,而页帽
  *  按「200/页」算 ⇒ 真实上界只有 1250 条,一位规则多于 1250 的 principal 会恒拿到「翻不完」的
  *  失败、整个治理面打不开,而注释还写着 5000。夹取语义在 server(非数/越界夹进 1..200),所以给
  *  上限最省往返、也让页帽的算术与现实一致。 */
@@ -73,7 +73,7 @@ const MAX_PAGES = 25;
  * 🔴 **游标绑 `(rev, principal, scope)`**:两页之间有人加/删了规则 ⇒ 第二页 400
  * `request.query_invalid`。处置 = **丢游标从头列一次**(静默重置成「接着上一页」会得到一份既漏行
  * 又重行的清单);从头再撞一次 ⇒ 如实报 cursor-stale,由调用方(人按 r 刷新)决定。
- * 🔴 **调用方 cursor 不收**(codex F2 对抗复审 [medium]):类型上剔掉 `cursor` 还不够 —— JS
+ * 🔴 **调用方 cursor 不收**(复审 F2 对抗复审 [medium]):类型上剔掉 `cursor` 还不够 —— JS
  * 调用方仍能塞进来,而首页的 `...params` 会把它原样送出 ⇒ 「列全」从**中途**开始却报 `ok:true`
  * 完整清单(治理面据此藏掉仍然生效的规则)。运行期显式剥除 + 留痕:drain 恒从第一页起,
  * 「接着别人的 keyset」证明不了完整性,与本函数的契约(rules 恒完整)结构性冲突。
@@ -104,7 +104,7 @@ export async function listAllPersistedRules(facade, params = {}, opts) {
                 }
                 return { ok: false, failure };
             }
-            // 🔴 页体 fail-closed 窄化(codex F2 轮二 [high]):SDK 传输层只 JSON.parse,不做运行期
+            // 🔴 页体 fail-closed 窄化(复审 F2 轮二 [high]):SDK 传输层只 JSON.parse,不做运行期
             // schema 校验 —— 一个 2xx 的 `{rev:9}`(无 rules 数组)在旧读法下会被认证成「完整的空清单」
             // (`ok:true, rules:[]`),治理面据此宣称「没有持久规则」而活规则不可见、无法撤销
             // (版本偏斜/后端降级下静默发生)。坏形页 = 判不出,绝不当「读到了空的」:
@@ -124,7 +124,7 @@ export async function listAllPersistedRules(facade, params = {}, opts) {
                     },
                 };
             }
-            // 🔴 跨页 rev 钉(codex F2 轮三 [high]):游标契约上绑 rev —— 清单变了,续页**该** 400
+            // 🔴 跨页 rev 钉(复审 F2 轮三 [high]):游标契约上绑 rev —— 清单变了,续页**该** 400
             // cursor-stale。一个 2xx 却换了 rev 的续页 = server 违约或降级形,拼起来是**混合快照**;
             // 认证它为完整清单,比 400 那条腿(丢游标重列)更坏 —— 这里不猜不修补,如实 failure。
             if (rev !== null && res.rev !== rev) {

package/dist/index.d.ts

@@ -246,6 +246,7 @@ export * from './model/catalogLoader.js';
 export * from './model/providerAuth.js';
 export * from './model/providerCatalog.js';
 export * from './model/tierVocabulary.js';
+export * from './model/modelSupplyRules.js';
 export * from './websearch/searchProviderPresets.js';
 export * from './env/localeGeo.js';
 export * from './env/localeTag.js';

package/dist/index.js

@@ -428,6 +428,10 @@ export * from './model/providerCatalog.js';
 // 🔴 `model/tierVocabulary.ts` = 档位五档词表 + CC 别名 + isTier 校验 + resolveTierBinding
 //    fail-open 降档派生。此前跨两仓三份;settings 读写那半场仍归宿主(cli tierCore 只留存储)。
 export * from './model/tierVocabulary.js';
+// 🔴 `model/modelSupplyRules.ts` = **Model Hub 供给面的三端公共判定**(#318 件③ 上收,cli [4752]
+//    预告的三纯函数):vision 生效值+来源三态 / 删除断链核(拒删)/ 删除降级后果(照删但必说)。
+//    零 IO —— 读盘那半场留各端(壳 modelChannels 读完再调这里);`doc === null` 的两义由调用方分流。
+export * from './model/modelSupplyRules.js';
 // ── 搜索 provider 目录 + 地域预选(2026-07-31)──────────────────────────────────────────────────
 // `websearch/searchProviderPresets` = model 目录的**同形不同表**姊妹件:数据在 json、类型与查询
 // 在 ts。它编译出来的不是模型目录而是**引擎部署 env**(`WEB_SEARCH_*`)。