@sema-agent/client-core 0.66.0 → 0.67.1

package/dist/adapter/runStream.js

@@ -310,6 +310,15 @@ async function* runStreamInner(events, ctx, handle = {}) {
     // projector can emit a REAL `duration_ms` (the wire carries no duration; the old hardcoded 0 was fake).
     if (ctx.startedAtMs === undefined)
         ctx.startedAtMs = Date.now();
+    // ── L-228(0.67.0):per-subagent turn usage 的**流内**累加表 ─────────────────────────────────
+    // 🔴 **每条流一张**(局部量,不是模块级):两条并发的流各自攒各自看见的账;做成模块级单例会让
+    //    A 流的子代用量落进 B 流的终帧(本仓在册的「共享 store 跨流污染」病形)。
+    // 🔴 它**只在终帧那一拍**挂到 `ctx` 上(见下面 `done`/`failed` 分支),不是开流时就挂 ——
+    //    终帧的铸点在 `terminalToSdkResult`(单一 mint 点,见该文件顶注:给信封加一个位要改六处
+    //    正是它收编掉的病),而 `ctx` 是**调用方**的对象:宿主若把同一个 ctx 复用给两条并发的流,
+    //    开流时挂等于让后开的那条把先开的那条的表顶掉,先开的终帧于是报出别人的账。
+    //    挂在终帧那一拍 + 与 `terminalToSdkResult(...)` 在**同一个同步步**里,那个窗按构造不存在。
+    const nestedUsageByTask = new Map();
     for await (const ev of events) {
         // event-id idempotency — drop a re-seen durable seq (contract 02 §1.1).
         const seq = eventSeq(ev);
@@ -379,14 +388,38 @@ async function* runStreamInner(events, ctx, handle = {}) {
             //    `usage` **可以同帧**)。把它剥掉,本批新开的这条 usage 通道就会把「不知道」渲成一笔
             //    全零的已知账 —— 与本批要根治的病(B-073 的成本 0/缺席)逐字同形,只是换了个量。
             const usageMissing = ev.usageMissing === true;
+            // 🔴 L-215③ 的**终局对偶**(异源对抗复审 [medium] 实抓):这条流上**只要有一轮**报过
+            //    「这一轮没有 usage」,终帧上那些数字就是**下界**。`stats.usageMissing` 只在带得出
+            //    `TaskResult` 的终帧上有,而 `failed` 事件帧 / 409 拒绝信封 / park 体**根本没有 stats**
+            //    ⇒ 只读 stats 的话,一条已经观测到缺口的 run 会在终帧上被读成「每一轮都报了 usage」
+            //    (而 `usage` 那几格恰好是 `flattenUsage(undefined)` 的全零)——「不知道」渲成了精确零。
+            //    ⇒ 流内观测到就记下来,终帧那一拍与 stats 的读数**取并**(见 costFactParts)。
+            if (usageMissing)
+                ctx.usageMissingObserved = true;
             const stopReasonRaw = ev.stopReason;
             const stopWord = typeof stopReasonRaw === 'string' && stopReasonRaw.length > 0 ? stopReasonRaw : undefined;
             const usage = turnEndUsage(ev);
             // §E2 identity (service 1.78) — a SUB-FLOW's turn_end (orchestration/subagent round, carries
-            // parentToolCallId) must NOT drive the leader's C1a `end` reconcile: its outputTokens are the
-            // child's, and reconciling the leader's responseLength against them is the token-jump bug
+            // the identity envelope) must NOT drive the leader's C1a `end` reconcile: its outputTokens are
+            // the child's, and reconciling the leader's responseLength against them is the token-jump bug
             // (blackboard dogfood #2 / upstreamBridge TODO #9). Fold its usage into the rollup only.
-            const isSubFlow = ev.parentToolCallId !== undefined;
+            // ── 🔴 0.67.1 / B-090(下游验收轨实抓)—— **身份键盲区** ────────────────────────────────
+            // 修前这条判据只认 `parentToolCallId`,而 §32g「归属钥匙」段自己写的读法是「`sourceTaskId`
+            // 优先,wire 缺席时回落 `parentToolCallId`」—— 那句话隐含「只带 `sourceTaskId`」是一条合法
+            // 组合。于是那一形的子代轮被判成**主流**,后果双重且都是本件当初要防的病:
+            //   ① `!isSubFlow` 为真 ⇒ 它的 usage 去驱动 `last_turn_usage` chrome 臂与 `turn_usage` 消息臂
+            //      —— §E2 断闸要防的 token-jump 在这条路上原样重现(子代的窗口占用落进主会话 Context);
+            //   ② `isSubFlow` 为假 ⇒ 整条不进分表(下面那条 `if (isSubFlow)` 腿)—— 那只子代的账消失。
+            // 🔴 判据锚在 core 真字节上(`task-event.d.ts` `TaskEventIdentity`,不是本包的口味):
+            //    `sourceTaskId` 逐字「stamped ONLY on the content events of a task running AS A SUB-AGENT
+            //    (same condition as `parentToolCallId`)」,且「A TOP-LEVEL task's own events carry NO
+            //    `sourceTaskId`」⇒ **两键同条件盖章、顶层一个都不带** ⇒ 任一在场 = 这条帧属于子流。
+            // 🔴 判据是**键在不在**(`!== undefined`),不是「是不是非空串」:空串 / 坏形也算信封在场,
+            //    于是按子流走 —— 失效方向是安全的那一侧(宁可少发一拍主会话的 usage,也绝不把子代的账
+            //    混进主会话;反过来那一侧就是 token-jump)。**行键**那一层才做非空串窄化(见下面的
+            //    `parent` / `sourceTaskId`),两层问的不是同一个问题:信封在不在 vs 这一行归到谁名下。
+            const isSubFlow = ev.parentToolCallId !== undefined ||
+                ev.sourceTaskId !== undefined;
             if (usage) {
                 handle.latestUsage = usage;
                 // [2295] 裁 ② 逐字通道:与镜像同拍存一份引擎原形(六键含 totalInputTokens)。
@@ -419,6 +452,88 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     }
                 }
             }
+            // ── L-228(0.67.0):子流那条腿 —— **additive 第三条腿**,主臂两处 `!isSubFlow` 断闸不动 ────
+            // 病(车 E 件⑥ 实抓):core 终局只有合计 `stats.nested`(**无 per-task 分项**),而流里每条
+            // 子流 turn_end 都带着它自己那一轮的 usage —— 本包此前在 §E2 断闸处**折而未读**,于是壳的
+            // 子代详情面只渲得出 `_sema_usage_absent`。⇒ 分表只能由流内累加得出,这就是那条通道。
+            // 🔴 **归属钥匙**:`sourceTaskId` 优先,wire 缺席时回落 `parentToolCallId`(同一只子代的每一轮
+            //    至少归得到同一行)。两个都读不出 ⇒ **整条不入表**(编一个 `"unknown"` 行就是把几只子代的
+            //    账混成一只)。身份位为什么**不是** `taskId`,见下面那段 🔴。
+            // 🔴 **`usageMissing` 与数字同帧并存**:core 明说那一轮的 usage 是 UNKNOWN 不是 0 ⇒ 数字照
+            //    累加(它是**下界**),判别位在行上立起来;把那一轮整个丢掉会让下界更假。
+            if (isSubFlow) {
+                const parentToolCallId = ev.parentToolCallId;
+                // 🔴 **身份键读 `sourceTaskId`,不是 `taskId`**(异源对抗复审 [high] 实抓,core 真字节直证):
+                //    core `TaskEventIdentity` 顶注逐字「the `WorkflowRun.sourceTaskId` family, **NOT a second
+                //    `taskId`** — that field already exists on `task_progress` and a duplicate would bite
+                //    consumers」⇒ 子代内容事件上**根本没有** `taskId` 这一位,读它恒缺席、恒回落到父调用 id,
+                //    于是**同一个父调用下的多只子任务会并成一行**(sdk 的 `turn_end` 臂也没有声明任何身份位,
+                //    两条腿都读 cast —— 这正是「按 d.ts 抄,不按印象猜」那条纪律要防的形)。
+                const rawSourceTaskId = ev.sourceTaskId;
+                const parent = typeof parentToolCallId === 'string' && parentToolCallId.length > 0 ? parentToolCallId : undefined;
+                const sourceTaskId = typeof rawSourceTaskId === 'string' && rawSourceTaskId.length > 0 ? rawSourceTaskId : undefined;
+                // 行键:`sourceTaskId` 优先,缺席回落父调用 id(同一只子代的每一轮至少归得到同一行)。
+                // ⚠️ 回落**有损**:同父调用多子任务会并成一行 —— 那时终帧那张表的 `partial` 判别位会因
+                //    行数对不上 `nested.tasks` 而立起来(诚实缺席优先于假装分得开)。
+                const taskId = sourceTaskId ?? parent;
+                // 🔴 0.67.1 / B-090:入表条件从「行键 **且** 父调用 id 都读得出」放宽到「**行键**读得出」。
+                //    修前那个 `&& parent !== undefined` 把「只带 `sourceTaskId`」的子代整条挡在表外 ——
+                //    而 `parent` 在这里的唯一用处是**铸 chrome 增量臂的车道证明**,不是行的身份。
+                //    行键读不出(两键都缺 / 都是空串)仍然整条不入表:编一个 `"unknown"` 行会把几只子代
+                //    的账混成一只(C3 那一格守的就是这条)。
+                if (taskId !== undefined) {
+                    // 🔴 发臂条件与主臂 0.65.1 / B-088 **逐字同族**:core 真会发**裸**
+                    //    `{type:'turn_end', usageMissing:true}`(无 usage、无 stopReason),旧条件「有 usage 才发」
+                    //    会让**最诚实的那一帧**整条静默 —— 那是本仓已定谳的病形,子代这条腿不许再犯一次。
+                    //    三者任一在场即发;三者皆缺席仍不发。
+                    // 🔴 **`parent` 缺席时本臂不发,而行照进表**(0.67.1 定谳,理由如实写在这里):
+                    //    chrome 信封的车道证明 `LaneProof` 的子流臂是 `{lane:'subagent', parentToolCallId: string}`
+                    //    (`seam.ts`),座位门 `seatContract.checkLaneProof` 对它是**硬要求**(缺伴随位的信封
+                    //    当场被吃掉,且 `run-client-core-pure-test.mjs` FIX7 ④ 有专门的投毒格守着)。这一形上
+                    //    **没有**父调用 id ⇒ 唯一能把臂发出去的办法是拿 `sourceTaskId` 去填那一格,而那是在
+                    //    一个「父调用 id」的位上放一个**任务 id** —— 正是 C4/C5 两格守的身份位互串,也是
+                    //    车道纪律(REF-CC-064)存在的理由。放宽 `LaneProof` 则是**三端 BREAKING**(宿主今天
+                    //    按 `parentToolCallId: string` 读),不是一个 patch 能做的事。
+                    //    ⇒ 增量腿在这一形上静默,**收口快照(终帧 `_sema_nested_usage_by_task`)照带这一行**
+                    //    —— 账不丢,少的只是这一形的实时增量;两者本来就是「同一份账的两个时刻」。
+                    if (parent !== undefined && (usage !== undefined || usageMissing || stopWord !== undefined) && ctx.emitChrome) {
+                        emitChromeFireAndForget(ctx, {
+                            kind: 'subagent_turn_usage',
+                            laneProof: { lane: 'subagent', parentToolCallId: parent },
+                            taskId,
+                            ...(sourceTaskId !== undefined ? { sourceTaskId } : {}),
+                            parentToolCallId: parent,
+                            ...(usage !== undefined ? { usage } : {}),
+                            ...(ev.usage !== undefined ? { engineUsage: ev.usage } : {}),
+                            ...(usageMissing ? { usageMissing: true } : {}),
+                            ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
+                        });
+                    }
+                    const row = nestedUsageByTask.get(taskId) ?? { turns: 0, inputTokens: 0, outputTokens: 0 };
+                    // 🔴 0.67.1(异源复审 [medium] 实抓):记下**这一行的键是回落来的**(真身份缺席)。
+                    //    B-090 放宽入表条件之后行键可以有两种出身,而混合出身时「拆一行 + 并一行」的计数
+                    //    误差方向相反、可以恰好抵消 ⇒ 终帧那张表的 `partial` 判据要看得见出身
+                    //    (理由与反例逐字在 `MutableSubagentUsageRow.keyFromParentFallback` 的头注里)。
+                    //    出身按行均匀:`taskId = sourceTaskId ?? parent` ⇒ 真身份在场的轮永远不会落到
+                    //    回落键那一行上,所以这一位只会被同一种出身的轮反复写成同一个值。
+                    if (sourceTaskId === undefined)
+                        row.keyFromParentFallback = true;
+                    row.turns += 1;
+                    row.inputTokens += usage?.inputTokens ?? 0;
+                    row.outputTokens += usage?.outputTokens ?? 0;
+                    // 🔴 `cacheReadTokens` 读的是**引擎原形** `ev.usage`,不是 CC 镜像:镜像的
+                    //    `cacheReadInputTokens` 是**必填** number,缺席在那儿已经被折成 0
+                    //    (`toCcModelUsage` 的 `finiteOrZero`)⇒ 从镜像读就再也分不出「没报」与「零命中」。
+                    //    ⇒ 一轮都没报过 ⇒ 键**不铸**;报过之后再加 0 的那些轮是真的零命中。
+                    const cacheRead = ev.usage?.cacheReadTokens;
+                    if (typeof cacheRead === 'number' && Number.isFinite(cacheRead)) {
+                        row.cacheReadTokens = (row.cacheReadTokens ?? 0) + cacheRead;
+                    }
+                    if (usageMissing)
+                        row.usageMissing = true;
+                    nestedUsageByTask.set(taskId, row);
+                }
+            }
             const outputTokens = ev.usage?.outputTokens;
             // 🔴 异源对抗复审 [medium]③:发臂条件从「有 outputTokens」放宽到「**有话可说**」——
             //    core 会发 `{type:'turn_end', usageMissing:true, stopReason:'error'}` 这种合法帧,而
@@ -578,16 +693,26 @@ async function* runStreamInner(events, ctx, handle = {}) {
             }
             // D-3 / B-068 · L-198(0.66.0):**终局对账那一拍**。与终帧超集键
             // (`_sema_cost_breakdown` / `_sema_nested_usage`)同一个读器 `readRunCostFacts` ⇒ 两面同源。
+            // 🔴 0.67.1 / B-091:「同源」此前只到**读器**这一层,取并那一层(下界位的两个来源)还留在
+            //    终帧那一面上 ⇒ 两面在「流内观测到缺口、终局 stats 缄默」这一形上各说各的。现在取并
+            //    在读器里面,两面读的是**同一次计算**(第二参就是那一半来源)。
             // 🔴 没有账就不说话:`stats` 读不出(409 拒绝信封 / park 体 / `failed` 事件帧)⇒ 不发。
             // 🔴 子流断闸(§E2)一字不动:子代花费只经本臂的 `nestedMicroUsd`(终局 stats.nested)到账。
             // fail-soft 同 plan_review_park:sink 抛错不影响终帧照常投影。
             if (ev.type === 'done' && ctx.emitChrome) {
                 const doneStats = ev.result?.stats;
-                const costFacts = readRunCostFacts(doneStats);
+                // 🔴 0.67.1 / B-091:**第二参必须传** —— 下界位的取并(`stats.usageMissing` ∪ 流内观测
+                //    `ctx.usageMissingObserved`)已经下沉进读器;不传就是把「臂绕开取并」那条不对称原样
+                //    种回去(终帧铸了 `_sema_usage_lower_bound`、同一拍的臂上却没有 `usageLowerBound`)。
+                const costFacts = readRunCostFacts(doneStats, ctx);
                 if (costFacts !== undefined) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: MAIN, ...costFacts.reconcile });
                 }
             }
+            // L-228:见本表声明处的头注 —— 挂表与铸终帧在**同一个同步步**里,复用 ctx 的并发流不会串账。
+            // (`usageMissingObserved` 是 per-ctx 的**单调布尔**,没有「顶掉别人」这一形:复用 ctx 的两条流
+            //  里只要有一条观测到缺口,两条的数字就都该按下界读 —— 取并是安全的那一侧。)
+            ctx.nestedUsageByTask = nestedUsageByTask;
             yield terminalToSdkResult(ev, ctx);
             return;
         }

package/dist/adapter/types.d.ts

@@ -36,6 +36,7 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import type { ModelUsage, SDKMessage } from '@sema-agent/agent-types';
 import type { ChromeEvent } from '../seam.js';
+import type { MutableSubagentUsageRow } from './downstream/terminalToSdkResult.js';
 export type { ModelUsage, SDKMessage };
 export type StampedAgentEvent = AgentEvent & {
     id?: string;
@@ -100,6 +101,32 @@ export interface EmitContext {
      *   · sink 抛错**绝不影响流**,并且痕迹落回 console —— 让位的前提是它真接住了。
      */
     onDroppedFrame?(info: DroppedFrameInfo): void;
+    /**
+     * L-228(0.67.0)—— **这条流上看见的 per-subagent turn 用量分表**,键 = 子任务 id
+     * (wire 缺席时回落 `parentToolCallId`)。终帧的两个超集键
+     * `_sema_nested_usage_by_task` / `_sema_nested_usage_by_task_partial` 由它铸出
+     * (唯一 mint 点 = `terminalToSdkResult.ts` 的 `nestedUsageByTaskParts`)。
+     *
+     * 🔴 **由 `runStream` 在流内写,宿主不要自己填** —— 与同接口的 `startedAtMs` 同一类
+     *    (「请求是宿主构造的,这一格是驱动自己攒的」)。宿主塞一份进来 = 把一份**不是这条流看见的**
+     *    账当成这条流的,而下游那个 `partial` 判别位恰恰是靠「这条流看见了多少」才成立的。
+     * 🔴 **缺席 / 空表 ⇒ 终帧两个键都不铸**:空表会被读成「一个子代都没委派」,而真相可能是
+     *    「委派了但这条流没看见任何一轮」。
+     */
+    nestedUsageByTask?: ReadonlyMap<string, MutableSubagentUsageRow>;
+    /**
+     * 0.67.0 —— **这条流上观测到过「某一轮没有 usage」**(core 的 `turn_end.usageMissing`)。
+     * 终帧的 `_sema_usage_lower_bound` 与 chrome 对账臂的 `usageLowerBound` 与 `stats.usageMissing`
+     * **取并**读它。
+     *
+     * 🔴 **为什么非有它不可**:`stats.usageMissing` 只在带得出 `TaskResult` 的终帧上有,而
+     *    `failed` 事件帧 / 409 拒绝信封 / park 体**根本没有 stats** ⇒ 只读 stats 的话,一条**已经
+     *    观测到缺口**的 run 会在终帧上落成「判别位缺席」,而按新合同那读作「每一轮都报了 usage」——
+     *    偏偏那种终帧的 `usage` 是 `flattenUsage(undefined)` 的**全零**:「不知道」被渲成了精确零。
+     * 🔴 **由 `runStream` 在流内写,宿主不要自己填**(同 `nestedUsageByTask` / `startedAtMs`)。
+     * 🔴 **只置 `true`,从不置回 false**:一轮不知道,整条流的数字就是下界,后面的轮补不回来。
+     */
+    usageMissingObserved?: true;
 }
 /** Stamp `uuid` + `session_id` onto a freshly-built arm body. */
 export declare function stamp<T extends {

package/dist/autoModeUnavailable.d.ts

@@ -1,93 +1,118 @@
 /**
- * src/autoModeUnavailable.ts — 「这只 ask 是因为**分类器跑不了**才问人」的事实读器 + 唯一措辞铸点
- * (0.63.0 件⑧;core 7.10.0 #616 —— **0.65.0 随 core 7.12.0 收窄,见下方「熔断族退役」段**)。
+ * src/autoModeUnavailable.ts — 「这一次 deny 是**分类器那一轮没能裁决**」的事实读器 + 唯一措辞铸点
+ * (0.63.0 件⑧ 起;**0.67.0 随 core 7.14.0 整只换面,见下方「卡面退役 / 拒绝面继任」段**)。
  *
  * -- 它答的是哪一问 ---------------------------------------------------------------------------
- * auto 模式下,门会就一只 ask 去咨询分类器。分类器**没跑成**时,引擎在这只 ask 上盖一格
- * `classifierUnavailable: { cause }` —— 卡上那句「问你是因为分类器这次跑不了(超时)」的事实来源。
- * 🔴 **它是显示元数据,不是裁决位**:没有任何东西读它来决定放行与否(引擎在门上已经判完了),
+ * auto 模式下,门会就一只调用去咨询分类器。分类器结束一轮有**三种**收场,而只有两种带一个**结构位**:
+ *   · `unavailable` —— 分类器**跑不了**(模型那条腿抛了/被拒/跑过上限):一条**说得出口**的 fail-closed
+ *     拒绝,过一会儿重试就行;
+ *   · `parse_error` —— 分类器**跑了并且答了**,只是答在裁决契约之外:按 BLOCK 处置,并像一次裁决一样
+ *     被拒绝上限计数;
+ *   · **缺席**(在 `deniedBy: "classifier"` 旁)—— 分类器**自己的裁决**(一次 `<block>yes`)。
+ * 🔴 **它是显示元数据,不是裁决位**:引擎在门上已经判完了,没有任何东西读它来决定放行与否,
  *    所以消费端只拿它渲一句话,**绝不**据它翻转任何裁决。
- * 🔴 **缺席 ≠「分类器跑成了」**:绝大多数 ask 根本没咨询过分类器(部署没武装 auto、或这只 ask 走的
- *    是别的门)。缺席只意味着「这只 ask 上没有这条事实」。
+ * 🔴 **缺席 ≠「分类器跑成了」**:绝大多数 deny 根本没咨询过分类器(部署没武装 auto、或这次走的是
+ *    别的层)。缺席只意味着「这条门记录上没有这条事实」。
  *
- * -- 🔴 熔断族退役(0.65.0;core 7.12.0 CHANGELOG「Removed (BREAKING)」)--------------------------
- * core 7.12.0 把 `AUTO_MODE_BREAKER_CAUSES` 与 `WiringManifest.autoMode.breaker` 整族删掉,
- * `AUTO_MODE_UNAVAILABLE_CAUSES` 同批收成 `["error","timeout"]`(`dist/core/auto-mode.d.ts:9` 真字节);
- * server 7.70.0([6927])读面同批收窄,`classifierUnavailable.cause` 不再发 `breaker_open`。
- * ⇒ 本模块把 `AUTO_MODE_BREAKER_CAUSES` / `ClassifierBreakerView` / `classifierBreakerOf` 与
- *   `breaker_open` 这个词**干净切**(clean-cut,不留别名、不留兼容读):留一个读不到的读器只会让
- *   三端继续为一件上游已经不发的事实写渲染分支,而那正是「校旧物」的门自己要拦的形。
- * 🔴 **`cause` 的开集读一个字节不动**:一台比本端**新**的引擎发一个新成因词时照收(见
- *    {@link classifierUnavailableOf});退役掉的只是本端**认得**的那张表里的一个成员 —— 旧引擎真发
- *    `breaker_open` 时它照旧过境,只是走 {@link classifierUnavailableDetail} 的兜底句
- *    (「这个词比这一端新/旧」那一类),不再冒充一句本端自铸的解释。
+ * -- 🔴 卡面退役 / 拒绝面继任(0.67.0;core 7.14.0 `docs/wire-consumption/7.14.0.md` 的
+ *       **Retired keys (BREAKING)** 表逐字)----------------------------------------------------
+ * core 7.14.0 把 `classifierUnavailable` 这一格**从六个载体上整族删掉**(`PermissionDeniedPayload` /
+ * `PermissionResult` 的 deny 与 ask 两臂 / `AskRequest` / `AskCarry`·`AskRequestCarry` /
+ * `PendingAction.tool_approval`·`CheckpointSummary`),其中 **ask 那几处自 #661 起引擎就没写过**
+ * (退役表逐字 "never engine-written since #661" / "dead since #661")。继任者是**一个**结构位:
+ *   `GateDisposition.denied.cause ∈ {"unavailable","parse_error"}`(`dist/core/gate-outcome.d.ts:168`
+ *   `CLASSIFIER_DENY_CAUSES`),挂在 `tool_end.gate` / `PermissionDeniedPayload.gate` / 耐久行的
+ *   resolved outcome 上,且只在 `deniedBy ∈ {classifier, policy}` 旁(`DENIED_BY_MAY_CARRY_CAUSE`)。
+ * ⇒ 本模块把 `ClassifierUnavailableView` / `classifierUnavailableOf` / `classifierUnavailableDetail`
+ *   **干净切**(clean-cut,不留别名、不留兼容读),换成 {@link classifierDenyCauseOf} 与
+ *   {@link classifierDenyCauseDetail}。留一个读不到的读器只会让三端继续为一件上游已经不发的事实写
+ *   渲染分支,而那正是「校旧物」的门自己要拦的形(登记在 `run-retired-vocabulary-census-test.mjs`)。
+ * 🔴 **旧耐久行的处置 = 忽略**:一条 pre-7.14 的 park 行上仍带着 `classifierUnavailable` 时,本包
+ *    **不读、不渲、不崩** —— 投影按新形办(退役表逐字「a stored key on an old row is ignored by the
+ *    projection」)。
  *
- * -- 🔴 判据轴与成因轴不是一张表 --------------------------------------------------------------
- *   · {@link AUTO_MODE_UNAVAILABLE_CAUSES}(`error` / `timeout`)—— 「这一轮分类**为什么没跑成**」。
- *     这是 `classifierUnavailable.cause` 的值域(词表属主 = core)。
- *   · core `AutoModeVerdict` 的**判据轴**另有一个 `parse_error` 臂 —— 分类器**跑了并且答了**,
- *     只是答在契约之外(`dist/core/auto-mode.d.ts:29-32` 逐字:「The model responded but not in the
- *     `<block>…` contract shape. Handled as a BLOCK …」)。它**一个字节都不 stamp** 到
- *     `classifierUnavailable` 上,那是**另一句话**。
- * 🔴 本读器因此把 {@link NEVER_STAMPED_CAUSES}(今天 = `{parse_error}`)判**缺席** —— 把一个判据词
- *    读成「没跑成」的成因,就是替引擎编一件它明说没发生的事。0.63.0 起的黑盒判据 G-19 钉的正是这
- *    一条,退役熔断族**没有改动它的行为**(修前这一格由「熔断轴 − 不可用轴」的差集派生,而差集的
- *    右操作数随熔断表一起没了;排除的**理由**从来就不在熔断轴上,现按理由的真出处直写)。
+ * -- 🔴 两条轴不是一张表(退役后仍然成立,只是坐标换了)--------------------------------------
+ *   · {@link CLASSIFIER_DENY_CAUSES}(`unavailable` / `parse_error`)—— 「这一轮分类**是怎么收场的**」,
+ *     `GateDisposition.cause` 的值域(词表属主 = core)。**闭集**:core 的 `screenGateOutcome` 把
+ *     出集的 cause 列为记录缺陷(不变量 I5),而有缺陷的门记录 server 整条不上帧。
+ *   · {@link AUTO_MODE_UNAVAILABLE_CAUSES}(`error` / `timeout`)—— 一个 `unavailable` 背后的
+ *     **为什么**。core 退役表逐字:「The WHY behind an `unavailable` (error vs timeout) is **not a
+ *     branching fact**: the deny sentence spells it and the `auto_mode.classified` trace frame carries
+ *     it」。⚠️ **本包今天不投影那条 trace 帧**(`src/` 全树 `auto_mode` 零命中),所以这张表在本包
+ *     手上**没有到达任何一条投影臂的路**:它留在公面上是作为三端共用的**词表抄件**(core 7.16.0 仍
+ *     导出它,故不构成退役),消费端**不得**期待它出现在某个 deny cause 旁边 —— 那一格的值域是上一条。
  *
  * -- 为什么是镜像而不是 import ---------------------------------------------------------------
- * 这张表与 `classifierUnavailable` 的型面在 sdk 8.8.0 与 agent-types 上**都还没有**(亲验:两棵树
- * 全树零命中),唯一的出处是 `@sema-agent/core` 的 `dist/core/auto-mode.js` / `tool-policy.d.ts`。
- * 而 core **不是本包消费者的依赖**(既非 peer 也非 runtime dep),本包的 `.d.ts` 一旦引用它,装了
- * 本包却没装 core 的下游会当场编译不过。⇒ 与 `engineNoticeCodes.ts` / `toolResult.ts` /
+ * `@sema-agent/core` **不是本包消费者的依赖**(既非 peer 也非 runtime dep),本包的 `.d.ts` 一旦引用
+ * 它,装了本包却没装 core 的下游会当场编译不过。⇒ 与 `engineNoticeCodes.ts` / `toolResult.ts` /
  * `retryStatus.ts` 同一条处置:**按真字节镜像,把代价交给门** ——
  * `run-auto-mode-unavailable-test.mjs` 对**实装 devDep core** 的产物逐词双向对账,core 一动这里就先红。
- * 🔴 **候上游导出即换**:sdk 哪天镜像了这张表与那一格,本模块的表应当整只退役改成从 sdk 取。
+ * 🔴 **候上游导出即换**:sdk 哪天镜像了 `CLASSIFIER_DENY_CAUSES` 与 `GateDisposition.cause`,
+ *    本模块的表应当整只退役改成从 sdk 取。
  */
 /**
- * 一轮分类**为什么没跑成**(core `AUTO_MODE_UNAVAILABLE_CAUSES`;逐词逐序镜像,core 7.12.0 起两词)。
- *   · `error` —— 模型那条腿抛了/被拒(分类时的路由失败也读在这里:派生路由的前置在任何 decide
- *     之前就回落了,所以没有单独的词);
- *   · `timeout` —— 往返上限到了。
-
+ * 一轮分类**怎么收场的** —— `GateDisposition.denied.cause` 的值域
+ * (core `CLASSIFIER_DENY_CAUSES`,`gate-outcome.d.ts:168` 逐词逐序镜像,7.14.0 起两词)。
+ *   · `unavailable` —— 分类器跑不了(模型那条腿抛了/被拒/跑过上限);一次说得出口的 fail-closed 拒绝,
+ *     这次调用**可以过一会儿再试**;
+ *   · `parse_error` —— 分类器跑了并且答了,只是答在裁决契约之外;**为安全起见拦下**,并像一次裁决一样
+ *     被拒绝上限计数 —— 与上一条的下一步**不同**,所以两个词、两句话。
+ *
  * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
  *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
  */
-export declare const AUTO_MODE_UNAVAILABLE_CAUSES: readonly string[];
-/** 「分类器这次跑不了」的事实(只有成因一格 —— 它是显示元数据,不是裁决位)。 */
-export interface ClassifierUnavailableView {
-    /** {@link AUTO_MODE_UNAVAILABLE_CAUSES} 之一(**开集读**:比本端新的引擎的新词照收)。 */
-    cause: string;
-}
+export declare const CLASSIFIER_DENY_CAUSES: readonly string[];
+/**
+ * 这个词是不是 {@link CLASSIFIER_DENY_CAUSES} 的成员(core `isClassifierDenyCause` 的镜像)。
+ *
+ * 🔴 **这一格与 `origin` / `ruleOffersAbsence` 的开集纪律刻意不同**,理由在**上游的形**上:
+ *    `cause` 出闭集时 core 的 `screenGateOutcome` 判**记录缺陷**(不变量 I5),而有缺陷的门记录
+ *    server **整条不上帧** ⇒ 一个表外的 cause **结构上到不了消费端**;它到达的形式是 `gate` 整键缺席。
+ *    所以在这一格上按闭集判不会「把一个合法的新词吞成缺席」——真读到表外词只说明那条记录本不该长
+ *    这样,而把它渲成一句成因就是替引擎编事实。(`deniedBy` 那张表在 `gateVocabulary.ts` 上同一条。)
+ */
+export declare function isClassifierDenyCause(v: unknown): boolean;
 /**
- * 一只 ask(或一条 durable park 行的 `tool_approval` 载荷)→ 「分类器跑不了」的事实;
- * 没有这条事实 / 形坏 ⇒ `undefined`,绝不抛出。
+ * 一条**门记录**(`tool_end.gate` / `PermissionDeniedPayload.gate` / 耐久行的 resolved outcome,
+ * 或本包 `gateOutcomeOf` 投出的 {@link import('./gateOutcome.js').GateOutcomeView})→
+ * 「这次 deny 是分类器那一轮**没能裁决**」的成因词;不是这一形 ⇒ `undefined`,绝不抛出。
  *
- * 🔴 **两处同一只读器**:`AskRequest.classifierUnavailable` 与
- *    `PendingAction.tool_approval.classifierUnavailable`(durable park 行的孪生位)**键路同形**,
- *    所以一只读器吃两处 —— 各写一份就是两份台账各漂各的,本包一贯要根治的形。
- * 🔴 **`cause` 按开集读 + 一条有出处的排除**(**0.64.2 订正,行为面**;修前是「unavailable 闭集」):
- *    · **非空串即收** —— 词表的属主是 core,而 server 侧除了「非空串」之外**不做词表校验**
- *      (engine fixture `approval-card.js:240` 的 `z.string().min(1)`)。在这里抄一份闭集表,只会在
- *      core 加词那天把一个**合法**值判没,而丢掉的正是「这次不可用是**新出现的那一类**」这条信息
- *      —— 与 `AskRequest.origin` / `ruleOffersAbsence` / `denialLimitFallback.limit` 逐字同一条纪律。
- *      修前那条路是可复现的:一台比本端新的引擎发一个新成因词 ⇒ 卡上那一行**整段消失**,而
- *      {@link classifierUnavailableDetail} 早就为这一形备好了兜底句(「a word newer than this client」)
- *      —— 那句话在修前**永远不可达**,这本身就是判据写错了的证据。
- *      ⚠️ 0.65.0 起 `breaker_open` 也走这一条(core 7.12.0 已删该词)—— **旧引擎的合法帧照旧过境**,
- *        只是本端不再为它自铸一句解释。
- *    · **{@link NEVER_STAMPED_CAUSES} 里的词仍判缺席** —— 今天只有 `parse_error`。这不是「表外词一律拒」,
- *      而是一条**有出处的排除**:core 的判据轴逐字说它「跑了并且答了」,读它就是替引擎编一件
- *      它明说没发生的事。0.63.0 起的黑盒判据 G-19 钉的正是这一条,行为**一字未变**。
- * 🔴 **只交 `cause` 一格**:顺手把整只 ask 的别的键带出来会长成第二份 ask 读面。
- * 🔴 **端不许在自己那一侧再补一张闭集表**:未知词的正解是渲兜底句(措辞铸点已经有),不是不渲。
+ * 🔴 **一只读器吃三处**:wire 的原始 `gate` 对象、包投出的视图、以及**带 `gate` 的整只帧**
+ *    —— 三者键路同形(`disposition.kind` / `disposition.cause`),各写一份就是三份台账各漂各的,
+ *    本包一贯要根治的形。
+ * 🔴 **只在 `kind === "denied"` 上答**:`allowed` 臂上不存在这一位;一条读不出处置词的记录是坏记录,
+ *    同样答缺席。
+ * 🔴 **闭集判据**(理由见 {@link isClassifierDenyCause}):表外词 ⇒ 缺席。
+ * 🔴 **不校 `deniedBy`**:core 的 `DENIED_BY_MAY_CARRY_CAUSE` 说的是 cause 只能站在 `classifier` /
+ *    `policy`(继承链上祖先的冻结分类器)旁边,那是**引擎的段内不变量**,server 已按它铸;包再校一遍
+ *    只会在上游合法演进的当天把一个真读数判没(与 `gateOutcome.ts` 顶注的 I1–I4 同一条处置)。
+ * 🔴 **缺席不是断言**:缺席同时覆盖「分类器自己裁决 block 了」「这次不是分类器轮」「本部署没接分类器」
+ *    三形,端**禁**读成「分类器好着呢」。
  */
-export declare function classifierUnavailableOf(ask: unknown): ClassifierUnavailableView | undefined;
+export declare function classifierDenyCauseOf(gate: unknown): string | undefined;
+/**
+ * 一轮分类**为什么**跑不了(core `AUTO_MODE_UNAVAILABLE_CAUSES`;逐词逐序镜像,core 7.12.0 起两词)。
+ *   · `error` —— 模型那条腿抛了/被拒(分类时的路由失败也读在这里:派生路由的前置在任何 decide
+ *     之前就回落了,所以没有单独的词);
+ *   · `timeout` —— 往返上限到了。
+ *
+ * ⚠️ **本表在本包手上没有到达任何投影臂的路**(0.67.0 如实登记,见模块顶注第三段):它是一个
+ *    `auto_mode.classified` **trace 帧**上的量,而本包不投影 trace 帧。留在公面上的唯一身份是
+ *    **三端共用的词表抄件**(core 7.16.0 仍导出它 ⇒ 不构成退役);消费端**不得**期待它出现在
+ *    {@link classifierDenyCauseOf} 的产物旁边。
+ *
+ * 🔴 形制:`Object.freeze` 的数组,理由同 {@link CLASSIFIER_DENY_CAUSES}。
+ */
+export declare const AUTO_MODE_UNAVAILABLE_CAUSES: readonly string[];
 /**
- * 一个成因词 → 一句人话。**唯一措辞铸点**(三端共用;端零自拼)。
+ * 一个 deny 成因词 → 一句人话。**唯一措辞铸点**(三端共用;端零自拼)。
  *
  * 🔴 **按自有属性查表**(与本包其余措辞铸点同一条纪律):`Object.freeze` 不移除原型,裸下标会让
  *    一个来自 wire 的 `constructor` / `toString` 命中 `Object.prototype` 上的**函数**并被当成一句话。
- * 🔴 表外词 / 坏值 ⇒ 一句**兜底**:仍然告诉用户「这只 ask 是分类器那条腿引出来的」,但**不冒充**
- *    三句里的任何一句(成因读不懂 ≠ 成因是别的什么);原样带上那个词供运维追问上游。
+ * 🔴 表外词 / 坏值 ⇒ 一句**兜底**:仍然告诉用户「这次拒是分类器那条腿引出来的」,但**不冒充**
+ *    两句里的任何一句;原样带上那个词供运维追问上游。
+ *    ⚠️ 与 {@link classifierDenyCauseOf} 的闭集判据**不矛盾**:那一层答「这条事实在不在」(闭集,
+ *    出集 = 坏记录),本层答「拿到一个词怎么渲」——**渲判据面**的消费端(以及一条从旧持久态恢复
+ *    回来的视图)可能手里就是一个表外词,它必须渲出一句诚实的话,而不是整屏崩或冒充一句已知的。
  */
-export declare function classifierUnavailableDetail(cause: unknown): string;
+export declare function classifierDenyCauseDetail(cause: unknown): string;