@sema-agent/client-core 0.65.1 → 0.67.0

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -20,6 +20,16 @@ function finiteOr0(v) {
  * 另一种形状,就是本函数 `stats === undefined` 的退化输出 —— 现在它也走这里(单一构造点)。
  */
 function flattenUsage(stats) {
+    // D-2 / L-192②:`webSearchRequests` 修前是**字面量 0**。`TaskStats` 是开集索引 ⇒ 按 CC 的名字
+    // 宽读一次:读得出就是真账(显式 0 = 做了零次,一句正面事实),读不出才是「没有这本账」。
+    const webSearch = stats?.webSearchRequests;
+    const webSearchKnown = typeof webSearch === 'number' && Number.isFinite(webSearch);
+    const totalInput = stats?.totalInputTokens;
+    const totalInputKnown = typeof totalInput === 'number' && Number.isFinite(totalInput);
+    // D-2 族扫(异源对抗复审 [medium]):1 小时 TTL 的缓存写入(core `cacheWriteTokensLong`)此前
+    // 在终局的**两处**投影上都读不到 —— 见 {@link SemaFlatUsage._sema_cache_write_tokens_long}。
+    const longWrite = stats?.cacheWriteTokensLong;
+    const longWriteKnown = typeof longWrite === 'number' && Number.isFinite(longWrite);
     return {
         // 🔴 B-073 ③ 族扫(0.65.0):四格一律走 {@link finiteOr0},不再用 `?? 0`。
         //    `??` 只挡 `null`/`undefined` —— 而 `TaskStats` 带 `[key: string]: unknown` 开集索引,
@@ -36,7 +46,272 @@ function flattenUsage(stats) {
         // (token 计数没报就是没写过),缺席与真 0 在 wire 上本来就同义 —— 成本那一格的缺席是 core
         // 刻意造出来的第三档,故单有判别位(见 `toCcModelUsage`)。
         cacheCreationInputTokens: finiteOr0(stats?.cacheWriteTokens),
-        webSearchRequests: 0,
+        // D-2:值仍是 number(CC 形不破、只读这一格的旧消费者行为逐字不变);「wire 上没有这本账」
+        // 这句话交给同行的判别位,见 {@link SemaFlatUsage._sema_web_search_requests_absent}。
+        webSearchRequests: webSearchKnown ? webSearch : 0,
+        ...(webSearchKnown ? {} : { _sema_web_search_requests_absent: true }),
+        // D-2:cache-INCLUSIVE 总量的超集座位(缺席 ⇒ 键不铸,绝不拿 MISS 分量冒充总量)。
+        ...(totalInputKnown ? { _sema_total_input_tokens: totalInput } : {}),
+        // D-2 族扫:长 TTL 缓存写入分量原样过境(**不求和**,理由见该位注释)。
+        ...(longWriteKnown ? { _sema_cache_write_tokens_long: longWrite } : {}),
+    };
+}
+/** 非空串窄化(空串按缺席归一 —— 空串骑上一个键就是「这一格有值」的冒充)。 */
+function nonEmptyStr(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+/**
+ * 「这条 gate 是**被拒**的」判词表。
+ * 🔴 **识别表,不是合法值表**(同 `engineErrorCodes` 的开集纪律):core 今天在两处铸这一格 ——
+ * 同步 ask 腿写 `resolved.action === 'allow' ? 'allow' : 'deny'`,耐久 resume 腿原样透传
+ * `ResumeOutcome.decision`。后者的 `plan_review` 臂词表是 `approve` / `edit` / `reject` ——
+ * 「人否了一份**计划**」不是「一次**工具调用**被拒」,CC 的 `permission_denials` 逐字是
+ * "One auto-denied **tool call**"。⇒ 认不出的判词一律**不铸** denial:少报一条(消费方还能从
+ * `humanReview` 看见有人工门)远好过把一次计划否决冒充成一次工具拒绝。
+ */
+const GATE_DENIED_DECISIONS = new Set(['deny']);
+/**
+ * **认得出、但不是工具拒绝**的判词。与上面那张表合起来才是「这一行我判得出」的全集 ——
+ * 落在两张表**之外**的词(上游新词 / 大小写变体 / 空串 / 整个缺席)一律**不猜**:既不铸 denial,
+ * 也**不许**让这份清单继续声称完整(异源对抗复审 [medium]:修前这些行被静默跳过,`[]` 于是被
+ * 当成「零拒绝」这句正面事实)。今天的成员:同步 ask 腿的 `allow`,计划复核腿的
+ * `approve`/`edit`/`reject`(那是「人否了一份**计划**」,不是 CC 说的 one auto-denied tool call)。
+ */
+const GATE_NON_DENIAL_DECISIONS = new Set(['allow', 'approve', 'edit', 'reject']);
+/**
+ * D-1 / L-192① —— 终帧拒绝清单的**唯一 mint 点**(成功臂与错误信封共用)。
+ *
+ * 修前两处各写一个字面量 `[]`,于是**两句话被折成一句**:「这条 run 一次都没被拒」与「这条帧
+ * 根本没有这本账」(老引擎 / 409 拒绝信封 / `failed` 事件帧都不带 stats)在 CC 形上都是 `[]`。
+ *
+ * 🔴 **为什么是两条清单而不是把 wire 的记录塞进 CC 数组**(异源复审 [medium] 逼出的口径订正):
+ * CC 的 `SDKPermissionDenial` 三键 `tool_name` / `tool_use_id` / `tool_input` **全是必填**
+ * (agent-types `permissions.d.ts` 与壳侧 zod `SDKPermissionDenialSchema` 皆然),而 wire 的 gate
+ * 账本只有五格、给不出后两键。两条路都不能走:**补零补空 = 编造**;**塞半条记录 = 破坏元素契约**
+ * ——严格消费方 `safeParse` 会把**整条 result 帧**判非法(丢一格 vs 丢整帧,后者严重得多)。
+ * ⇒ CC 数组只收**三键齐全**的记录(今天恒空),wire 上真有的每一条走 sema 载体
+ * `_sema_permission_denials`,键按能兑现的铸。**自动升级腿**:上游哪天把 `toolCallId` /
+ * `toolInput` 串上 gate 账本,CC 数组自己就开始填,本函数一行不用改(门里有那一条的正控)。
+ *
+ * 🔴 判别位 `_sema_permission_denials_absent` = **「CC 那条清单不可声称完整」**,四条路径:
+ *   ① 账本整个读不出(`humanReview` 缺席 / 坏形 / `gates` 不是数组 / 无 stats);
+ *   ② 有读不出的行(非对象);
+ *   ③ 有**认不出的判词**(两张判词表之外的词 / 判词缺席)—— 不猜它是不是拒绝;
+ *   ④ 有被拒记录**没能铸成 CC 形**(今天只要有一条拒绝就必然命中这条)。
+ * 读法因此是两键合读:`[]` + 判别位缺席 = **零拒绝**(正面事实);`[]` + 判别位 `true` = 别渲肯定句。
+ * 判别位**只在该说话时铸,绝不铸 `false`**(本包 additive 一贯纪律)。
+ *
+ * 逐行独立:坏行只丢自己,绝不丢整本账(但会让清单失去「完整」资格,见 ②③)。
+ */
+function permissionDenialParts(stats) {
+    const hr = stats?.humanReview;
+    const gates = hr !== null && typeof hr === 'object' ? hr.gates : undefined;
+    // 账本整个读不出(缺席 / 坏形 / 无 stats)—— 诚实缺席,不猜。
+    if (!Array.isArray(gates))
+        return { permission_denials: [], _sema_permission_denials_absent: true };
+    const denials = [];
+    /** 这份清单还能不能声称「完整」(见头注 ②③④)。 */
+    let complete = true;
+    for (const g of gates) {
+        if (g === null || typeof g !== 'object') {
+            complete = false;
+            continue;
+        }
+        const row = g;
+        const decision = row.decision;
+        if (typeof decision !== 'string' || decision.length === 0) {
+            // 判词缺席(耐久 wake 腿真会这样)⇒ 这一行是不是拒绝**判不出**,不猜、也不再声称完整。
+            complete = false;
+            continue;
+        }
+        if (!GATE_DENIED_DECISIONS.has(decision)) {
+            // 认得出的非拒绝判词照旧跳过(不影响完整性);认不出的词一律降级为「清单不完整」。
+            if (!GATE_NON_DENIAL_DECISIONS.has(decision))
+                complete = false;
+            continue;
+        }
+        const toolName = nonEmptyStr(row.toolName);
+        const toolArg = nonEmptyStr(row.toolArg);
+        // 🔴 开集宽读两键:今天 core 的 gate 账本上没有它们(门里锚着这条缺席证据),按 core 自己的
+        //    命名习惯(`toolName` / `toolArg` 同族)预读 `toolCallId` / `toolInput`;上游若用别的名字
+        //    补上,缺席证据当天红 ⇒ 那一批改读真名。绝不自铸值。
+        const toolUseId = nonEmptyStr(row.toolCallId);
+        const rawInput = row.toolInput;
+        const toolInput = rawInput !== null && typeof rawInput === 'object' && !Array.isArray(rawInput)
+            ? rawInput
+            : undefined;
+        // 键都读不出时仍然 push 一条空记录:**条数**(「这条 run 被拒了几次」)是这本账最要紧的
+        // 事实,丢掉它等于把一次真实发生的拒绝抹成没发生;键按能兑现的铸,不编。
+        denials.push({
+            ...(toolName !== undefined ? { tool_name: toolName } : {}),
+            ...(toolUseId !== undefined ? { tool_use_id: toolUseId } : {}),
+            ...(toolInput !== undefined ? { tool_input: toolInput } : {}),
+            ...(toolArg !== undefined ? { _sema_tool_arg: toolArg } : {}),
+        });
+    }
+    /** CC 元素契约:三键齐全才进 CC 数组(类型窄化由这只谓词负责)。 */
+    const ccList = denials.filter((d) => d.tool_name !== undefined && d.tool_use_id !== undefined && d.tool_input !== undefined);
+    const claimable = complete && ccList.length === denials.length;
+    return {
+        permission_denials: ccList,
+        ...(denials.length > 0 ? { _sema_permission_denials: denials } : {}),
+        ...(claimable ? {} : { _sema_permission_denials_absent: true }),
+    };
+}
+/** 有限数窄化(非数 / 非有限 ⇒ 缺席;`0` 是事实不是缺席)。 */
+function finiteOrAbsent(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
+/**
+ * D-3 / B-068 · L-198 —— 终局成本事实的**唯一读器**(终帧超集键与 chrome 对账臂共用)。
+ *
+ * 🔴 `stats` 不是可读对象(409 拒绝信封 / park 体 / `failed` 事件帧)⇒ 返 `undefined` =
+ * **这条帧没有账**,调用方据此「不说话」(不发臂、不铸键),而不是发一条全缺席的空账。
+ */
+export function readRunCostFacts(stats) {
+    // 数组也不是「一份账」:`typeof [] === 'object'` 会把一条畸形载体放进来,然后它的每一格都读不出
+    // ⇒ 发出一条「own 没定价」的臂,而真相是**这条帧根本没有账**(两句话又折成一句)。
+    if (stats === null || typeof stats !== 'object' || Array.isArray(stats))
+        return undefined;
+    const rawBreakdown = stats.costBreakdown;
+    let breakdown;
+    if (rawBreakdown !== null && typeof rawBreakdown === 'object' && !Array.isArray(rawBreakdown)) {
+        const out = {};
+        // 逐键独立:坏值只丢自己(整段不连坐)。开集 —— 键名不套闭表,词表属主是 core。
+        for (const [k, v] of Object.entries(rawBreakdown)) {
+            const n = finiteOrAbsent(v);
+            if (n !== undefined)
+                out[k] = n;
+        }
+        if (Object.keys(out).length > 0)
+            breakdown = out;
+    }
+    const rawNested = stats.nested;
+    // 🔴 「**委派过**」这件事本身是 load-bearing 的(它决定总额算不算得出来),所以它的判据是
+    //    **原始载体**在不在,而**不是**过滤产物空不空(异源对抗复审 [medium] 的实抓:
+    //    `{costMicroUsd:100, nested:{}}` / `nested:{tokens:'bad'}` 修前被当成「没委派」⇒ 铸出一个
+    //    确定的总额 100,而真相是「委派过、那本账读不出来」)。
+    const nestedRan = rawNested !== null && typeof rawNested === 'object' && !Array.isArray(rawNested);
+    let nested;
+    if (nestedRan) {
+        const n = rawNested;
+        const picked = {};
+        for (const k of ['tokens', 'turns', 'tasks', 'costMicroUsd']) {
+            const v = finiteOrAbsent(n[k]);
+            if (v !== undefined)
+                picked[k] = v;
+        }
+        // 一个数都读不出时仍然铸**空对象**:键在场 = 委派过(与 `costMicroUsd` 缺席 = 那本账不知道
+        // 是两键合读的两半);整键不铸会把「委派过」这句事实一起抹掉。
+        nested = picked;
+    }
+    const ownMicroUsd = finiteOrAbsent(stats.costMicroUsd);
+    const nestedMicroUsd = nested?.costMicroUsd;
+    // 「委派过但那本账没定价/读不出」与「压根没委派」是两句话:前者判别位立起来,后者什么都不说。
+    const nestedUnknown = nestedRan && nestedMicroUsd === undefined;
+    // 求和自身也必须是有限数:两个合法但极端的值相加可以溢出成 Infinity,而 Infinity 会被下游
+    // 当成真数字摊进总计(与 `microUsdToUsd` 同一条规约)⇒ 宁可不铸。
+    const sum = ownMicroUsd !== undefined && !nestedUnknown ? ownMicroUsd + (nestedMicroUsd ?? 0) : undefined;
+    // 0.67.0(core 7.14.0):usage 下界位。**严格 true 才铸**(core 契约:`true` 或缺席,恒不写
+    // `false`/`null`;认宽了就会把一个 falsy 值渲成「数得不全」)。它与成本三段正交,所以读在这里、
+    // 与三段同一只读器出 —— 两面(终帧超集键 / chrome 对账臂)因此永远不会各算各的。
+    const usageLowerBound = stats.usageMissing === true;
+    const reconcile = {
+        ...(ownMicroUsd !== undefined ? { ownMicroUsd } : { costAbsent: true }),
+        ...(usageLowerBound ? { usageLowerBound: true } : {}),
+        ...(nestedMicroUsd !== undefined ? { nestedMicroUsd } : {}),
+        ...(nestedUnknown ? { nestedCostAbsent: true } : {}),
+        ...(breakdown?.compactionMicroUsd !== undefined ? { compactionMicroUsd: breakdown.compactionMicroUsd } : {}),
+        ...(breakdown?.llmRootMicroUsd !== undefined ? { llmRootMicroUsd: breakdown.llmRootMicroUsd } : {}),
+        // 对账值:own 读得出、子代那一边不是「跑了却不知道多少钱」、且和本身有限时才算得出来。
+        ...(sum !== undefined && Number.isFinite(sum) ? { reconciledMicroUsd: sum } : {}),
+    };
+    return {
+        ...(breakdown !== undefined ? { breakdown } : {}),
+        ...(nested !== undefined ? { nested } : {}),
+        reconcile,
+    };
+}
+/**
+ * D-3 —— 终帧上的两个成本超集键(成功臂与错误信封共用的**唯一** mint 点)。
+ * 🔴 CC 同名键 `total_cost_usd` **语义零改**:它仍然只是 own 花费,`nested` **不折进去**
+ * (超集键纪律:CC 形上已有的位不许塞我们自己的含义)。「fully-reconciled spend」由消费方按
+ * 这两个超集键自己加 —— 包给的是**可对账的事实**,不是一个改了口径的数。
+ */
+function costFactParts(stats, ctx) {
+    const facts = readRunCostFacts(stats);
+    // 🔴 **下界位与成本三段分开算**(异源对抗复审 [medium] 实抓):`stats` 读不出(`failed` 事件帧 /
+    //    409 拒绝信封 / park 体)时**成本**那三段确实没有账、一条都不该说;但「这条流观测到过一轮
+    //    没有 usage」这件事**照旧成立**,而那种终帧的 `usage` 恰恰是 `flattenUsage(undefined)` 的
+    //    全零 —— 早退回空对象等于把「不知道」渲成精确零(正是本位要修的病的另一条路径)。
+    //    ⇒ 两者**取并**:stats 说了算一半,流内观测算另一半。
+    const lowerBound = facts?.reconcile.usageLowerBound === true || ctx.usageMissingObserved === true;
+    const lowerBoundPart = lowerBound ? { _sema_usage_lower_bound: true } : {};
+    if (facts === undefined)
+        return lowerBoundPart;
+    return {
+        ...lowerBoundPart,
+        ...(facts.breakdown !== undefined ? { _sema_cost_breakdown: facts.breakdown } : {}),
+        ...(facts.nested !== undefined ? { _sema_nested_usage: facts.nested } : {}),
+        // ── 0.67.0(core 7.14.0 `TaskResult.stats.usageMissing`)────────────────────────────────
+        // 🔴 CC 同名键**语义零改**:`usage` / `modelUsage` / `total_cost_usd` 的字节一个不动,本位是
+        //    一个 `_sema_` 超集**判别位**,说的是「上面那些数字是**下界**」。把它折进数字里(比如
+        //    把 tokens 抹成 null)会让每一个既有消费者当场坏掉,而它们今天读到的是一笔**看起来
+        //    已知**的账 —— 那正是本位要修的病。
+        // 🔴 **缺席不铸**(never false):缺席 ⇔ 每一轮都报了 usage。
+        // 🔴 与 §31d 的 `usage._sema_total_input_tokens` **同帧不同问**:那一位答「这一行报了多少总
+        //    输入」,本位答「这一整条 run 的账数全了没有」。
+        //    (本位在上面与流内观测取并后已铸;这里不再重复。)
+    };
+}
+/**
+ * L-228 —— 流内子代分表 → 终帧两个超集键的**唯一 mint 点**(成功臂与错误信封共用)。
+ *
+ * **不导出**:它的入参是一个只有 `runStream` 攒得出来的累加表,推上公面等于邀请宿主自己攒一份
+ * 「看见了多少」的账(而那份账的 `partial` 判据在宿主手上不成立)。包侧门走**端到端**素材:
+ * 喂子流 `turn_end` + `done` 给 `runStream`,断言终帧上那两个键 —— 那也是三端真正拿到它的路。
+ *
+ * ── 🔴 `partial` 怎么判(设计定谳,与派车单的「恒铸于重连车道」不同,理由写在这里)────────────
+ * 派车单给的形是「本条流不是从 run 起点观测 ⇒ 恒铸 partial」。而本层**没有**「从不从起点观测」
+ * 这个读数:`runStream` 手上只有**同一条流内**的事件序号去重表(`seen`),它答的是「这一帧重放过
+ * 没有」,答不了「这条流之前还有没有别的帧」;`--resume` / 重连开出来的流与首开的流在本层
+ * **逐位不可分**。按一个读不出来的量铸判别位 = 编一件事实。
+ * ⇒ 判据改锚在**真正决定结果的量**上([anchor-on-the-deciding-quantity]):拿引擎自己的**权威
+ * 合计** `stats.nested` 对账 —— 分表的 `turns` 之和等于 `nested.turns` **且**行数等于 `nested.tasks`
+ * 时,这张表**可证**覆盖了整条 run ⇒ 不铸 partial;任何一边对不上、或 `stats.nested` 根本读不出来
+ * ⇒ **铸 partial**。
+ * 🔴 失效方向是安全的那一侧:上游哪天让某类嵌套轮不上子流 `turn_end`(比如更深一层的编排),
+ *    本判据只会**多**铸 partial(把一张其实完整的表说成不完整),**永远不会**把一张残表说成完整。
+ * 🔴 **两个键不互证、也不相加**:`_sema_nested_usage`(合计,引擎报的)与本表(流内看见的)是
+ *    两份独立的账;`partial` 在场时两者**本来就该不等**,消费方不许拿其中一份去「修正」另一份。
+ */
+function nestedUsageByTaskParts(stats, rollup) {
+    // 🔴 一行都没有 ⇒ **什么都不说**:空表会被读成「这条 run 一个子代都没委派」,而真相可能是
+    //    「委派了,但这条流没看见任何一轮」(重连车道)。两句话不许折成一句。
+    if (rollup === undefined || rollup.size === 0)
+        return {};
+    const rows = {};
+    let turnsSeen = 0;
+    for (const [taskId, r] of rollup) {
+        turnsSeen += r.turns;
+        rows[taskId] = {
+            turns: r.turns,
+            inputTokens: r.inputTokens,
+            outputTokens: r.outputTokens,
+            ...(r.cacheReadTokens !== undefined ? { cacheReadTokens: r.cacheReadTokens } : {}),
+            ...(r.usageMissing === true ? { usageMissing: true } : {}),
+        };
+    }
+    const nested = stats !== null && typeof stats === 'object' && !Array.isArray(stats)
+        ? stats.nested
+        : undefined;
+    const authTurns = finiteOrAbsent(nested?.turns);
+    const authTasks = finiteOrAbsent(nested?.tasks);
+    const complete = authTurns !== undefined && authTasks !== undefined &&
+        authTurns === turnsSeen && authTasks === Object.keys(rows).length;
+    return {
+        _sema_nested_usage_by_task: rows,
+        ...(complete ? {} : { _sema_nested_usage_by_task_partial: true }),
     };
 }
 /** P1-5 — real elapsed ms since the stream opened (runStream stamps startedAtMs); 0 only pre-stamp. */
@@ -112,13 +387,15 @@ function mapModelUsage(stats) {
         if (u === undefined || u === null || typeof u !== 'object')
             continue;
         const m = u;
-        out[modelId] = toCcModelUsage({
+        out[modelId] = withTerminalUsageFacts(toCcModelUsage({
             inputTokens: numOrAbsent(m.inputTokens),
             outputTokens: numOrAbsent(m.outputTokens),
             cacheReadTokens: numOrAbsent(m.cacheReadTokens),
             cacheWriteTokens: numOrAbsent(m.cacheWriteTokens),
             costMicroUsd: numOrAbsent(m.costMicroUsd),
-        });
+            // D-2(0.66.0):per-model 行今天也不带这一格 ⇒ 宽读一次,读不出由 mint 点立判别位。
+            webSearchRequests: numOrAbsent(m.webSearchRequests),
+        }), m);
     }
     return out;
 }
@@ -139,16 +416,37 @@ function modelUsageFor(stats, model) {
     // stats?.costUsd === 'number'` 的旧写法在 SDK 1.x 下照样编译得过,只是恒假 ⇒ 合成行的
     // costUSD 静默恒 0(比报错更隐蔽)。tsc 只红了 6 处直传,这处靠人核 + pure 门的行为钉。
     return {
-        [model]: toCcModelUsage({
+        [model]: withTerminalUsageFacts(toCcModelUsage({
             inputTokens: stats?.promptTokens,
             outputTokens: stats?.outputTokens,
             cacheReadTokens: stats?.cachedTokens,
             // B-073 ③ 族扫:合成行是 `flattenUsage` 的**同形第二处**,同批一并改读真值。
             cacheWriteTokens: stats?.cacheWriteTokens,
             costMicroUsd: stats?.costMicroUsd,
-        }),
+            // D-2(0.66.0):与扁平 usage 同一格同一读法(开集宽读,读不出由 mint 点立判别位)。
+            webSearchRequests: stats?.webSearchRequests,
+        }), stats),
     };
 }
+/**
+ * 给一条已铸好的 CC `ModelUsage` 行挂上终局那三个座位(读不出的一律不铸)。
+ * `raw` = 这一行的 wire 原形(分表的那一行,或扁平 `TaskStats` —— 两处键名相同)。
+ */
+function withTerminalUsageFacts(row, raw) {
+    const total = finiteOr0Absent(raw?.totalInputTokens);
+    const long = finiteOr0Absent(raw?.cacheWriteTokensLong);
+    const basis = nonEmptyStr(raw?.usageBasis);
+    return {
+        ...row,
+        ...(total !== undefined ? { _sema_total_input_tokens: total } : {}),
+        ...(basis !== undefined ? { _sema_usage_basis: basis } : {}),
+        ...(long !== undefined ? { _sema_cache_write_tokens_long: long } : {}),
+    };
+}
+/** 有限数窄化(非数 / 非有限 ⇒ 缺席;`0` 是读数不是缺席)。 */
+function finiteOr0Absent(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
 /**
  * TaskResult 五键最小消费批([1543] SDK-M,2026-07-23)之一 —— `degraded` = 模型降级链实录
  * (from/to/reason/atTurn;多模型网关部署的关键可观测面)。
@@ -264,7 +562,13 @@ function errorResult(ctx, parts) {
         total_cost_usd: costOrNull(parts.stats), // P1-5: null when unknown, never a fake 0
         usage: flattenUsage(parts.stats),
         modelUsage: modelUsageFor(parts.stats, parts.model),
-        permission_denials: [],
+        // D-1 / L-192①:两句话不再折成一句 —— 清单 + 「有没有这本账」的判别位,见 permissionDenialParts。
+        ...permissionDenialParts(parts.stats),
+        // D-3 / B-068:失败/到限/park 的 run 一样花过钱,账不因结局不好就不报。
+        ...costFactParts(parts.stats, ctx),
+        // L-228(0.67.0):流内 per-subagent 分表的收口快照(判据本体在 `nestedUsageByTaskParts`)。
+        // 🔴 与成本三段同理 —— 失败的 run 一样委派过,账不因结局不好就不报。
+        ...nestedUsageByTaskParts(parts.stats, ctx.nestedUsageByTask),
         errors: [...parts.errors],
         ...(parts.errorCode !== undefined && parts.errorCode.length > 0 ? { errorCode: parts.errorCode } : {}),
         ...(parts.degraded !== undefined ? { degraded: parts.degraded } : {}),
@@ -454,7 +758,13 @@ export function doneToSdkResult(ev, ctx) {
         usage: flattenUsage(stats),
         // MF-25/P1-5 — the per-model usage split (wire `stats.modelUsage`, or the synthesized current-model row).
         modelUsage: modelUsageFor(stats, r.model),
-        permission_denials: [],
+        // D-1 / L-192①:同形第二处 —— 与错误信封共用**同一个** mint 点(修前两处各一个字面量 [])。
+        ...permissionDenialParts(stats),
+        // D-3 / B-068:成本明细与子代那本账(micro-USD 原值);`total_cost_usd` 语义一字不动。
+        ...costFactParts(stats, ctx),
+        // L-228(0.67.0):流内 per-subagent 分表的收口快照;与 `_sema_nested_usage`(引擎报的合计)
+        // 是**两份独立的账**,不相加、不互证(见 `nestedUsageByTaskParts` 顶注)。
+        ...nestedUsageByTaskParts(stats, ctx.nestedUsageByTask),
         // MF-25 — the effective served model id (`done.result.model`, e.g. "deepseek-v4-pro"). The CC
         // SDKResultSuccess schema has no `model` field, so this rides as an additive seam field a cost/overview
         // consumer reads (it is ALSO surfaced as the `modelUsage` key). Omitted when the wire didn't carry it.

package/dist/adapter/downstream/turnUsageToModelUsage.d.ts

@@ -16,6 +16,9 @@
  * `maxOutputTokens` — the missing `contextWindow` denominator is mock-fill from
  * a static per-model table (contract 02 §2.7 VERIFY). Defaulted to 0 to satisfy
  * the CC `ModelUsage` shape without inventing a number.
+ * 🔴 0.66.0 / D-2:这三格里的 `webSearchRequests` 现在**开集宽读**(读得出就是真账),读不出时
+ * 值仍 0 但同行立 `_sema_web_search_requests_absent` —— 「这一格是 0」与「这一格没有账」在
+ * CC 形上此前不可分。另两格维持 0 且**不立判别位**,理由见 {@link SemaModelUsage} 的该位注释。
  *
  * core 3.0.0 语义翻转注(2026-08-02,[2318] 提货):wire 的 `inputTokens` 从「含 cache 总量」
  * 翻为「归一化未命中分量(cache-MISS)」。本映射**一个字节没动**,但语义上恰好从错变对 ——
@@ -49,6 +52,12 @@ export interface EngineUsageLike {
     readonly cacheReadTokens?: number | undefined;
     readonly cacheWriteTokens?: number | undefined;
     readonly costMicroUsd?: number | undefined;
+    /**
+     * D-2 / L-192②(0.66.0):CC 同名格的宽读位。今天 wire 上**没有**任何一条腿发它
+     * (core 的 `TaskStats` / per-model 行都没有这一格)⇒ 恒缺席、镜像上的 `webSearchRequests`
+     * 恒 0 + 判别位;开集读是为了上游真发那天**照读**而不是继续硬编(退出条件在门里)。
+     */
+    readonly webSearchRequests?: number | undefined;
 }
 /**
  * B-073 ②(0.65.0)—— CC `ModelUsage` 的 sema 超集形:多一个**成本缺席判别位**。
@@ -70,6 +79,15 @@ export interface EngineUsageLike {
 export type SemaModelUsage = ModelUsage & {
     /** 在场且为 `true` ⇒ 这一行的 `costUSD: 0` 是「**没定价**」,不是「免费」。 */
     readonly _sema_cost_absent?: true;
+    /**
+     * D-2 / L-192②(0.66.0)—— 在场且为 `true` ⇒ 这一行的 `webSearchRequests: 0` 是
+     * 「**wire 上没有这本账**」,不是「这一轮一次网搜都没做」。与 `_sema_cost_absent` 同一条
+     * 两键合读纪律;同形第二处在终帧的扁平 usage(`SemaFlatUsage`),两处一个规矩。
+     * 🔴 `contextWindow` / `maxOutputTokens` 那两格**刻意不给判别位**:它们是**模型的静态元数据**
+     * 而不是这一轮的账,权威来源是模型目录(`/v1/models[].contextWindow`),不是 usage 面;
+     * 给它们立位会把「去目录里取」误导成「等 usage 面补上」(登记见 INTEGRATION §31d)。
+     */
+    readonly _sema_web_search_requests_absent?: true;
 };
 /**
  * 🔴 **CC `ModelUsage` 八键形状的唯一 mint 点**(REF-CC-062 / xlate-08,E1 单源构造)。
@@ -85,7 +103,8 @@ export type SemaModelUsage = ModelUsage & {
  *   cacheReadTokens  → cacheReadInputTokens
  *   cacheWriteTokens → cacheCreationInputTokens
  *   costMicroUsd     → costUSD(/1e6;micro-USD 是 wire 单位,字段名即单位)
- * DROPPED(wire 无此数,填 0 而不是编一个):webSearchRequests / contextWindow / maxOutputTokens。
+ *   webSearchRequests→ webSearchRequests(0.66.0 / D-2 起开集宽读;读不出 ⇒ 0 + 判别位)
+ * DROPPED(wire 无此数,填 0 而不是编一个):contextWindow / maxOutputTokens。
  *
  * 收编时的**一处语义统一**(REF-CC-062,记在这里以免被读成无意的漂移):cost 的换算此前两份
  * 写法不同 —— 本文件是裸 `/1e6`(非有限值原样传播出 Infinity/NaN),`terminalToSdkResult` 是

package/dist/adapter/downstream/turnUsageToModelUsage.js

@@ -16,7 +16,8 @@ function finiteOrZero(v) {
  *   cacheReadTokens  → cacheReadInputTokens
  *   cacheWriteTokens → cacheCreationInputTokens
  *   costMicroUsd     → costUSD(/1e6;micro-USD 是 wire 单位,字段名即单位)
- * DROPPED(wire 无此数,填 0 而不是编一个):webSearchRequests / contextWindow / maxOutputTokens。
+ *   webSearchRequests→ webSearchRequests(0.66.0 / D-2 起开集宽读;读不出 ⇒ 0 + 判别位)
+ * DROPPED(wire 无此数,填 0 而不是编一个):contextWindow / maxOutputTokens。
  *
  * 收编时的**一处语义统一**(REF-CC-062,记在这里以免被读成无意的漂移):cost 的换算此前两份
  * 写法不同 —— 本文件是裸 `/1e6`(非有限值原样传播出 Infinity/NaN),`terminalToSdkResult` 是
@@ -28,17 +29,21 @@ export function toCcModelUsage(raw) {
     // 没报就是没花),而成本的缺席是 core **刻意**造出来的一档语义(`ABSENT when any spend was
     // unpriced … rather than a fabricated 0`)。故这里单独判一次,而不是继续走 `finiteOrZero`。
     const costPriced = typeof raw.costMicroUsd === 'number' && Number.isFinite(raw.costMicroUsd);
+    // D-2 / L-192②(0.66.0):`webSearchRequests` 与成本那一格同族 —— 修前是**字面量 0**,
+    // 把「wire 上没有这本账」渲成「做了零次」。值仍留 0(CC 形必填 number),判别位说真话。
+    const webSearchKnown = typeof raw.webSearchRequests === 'number' && Number.isFinite(raw.webSearchRequests);
     return {
         inputTokens: finiteOrZero(raw.inputTokens),
         outputTokens: finiteOrZero(raw.outputTokens),
         cacheReadInputTokens: finiteOrZero(raw.cacheReadTokens),
         cacheCreationInputTokens: finiteOrZero(raw.cacheWriteTokens),
-        webSearchRequests: 0, // dropped on the wire
+        webSearchRequests: webSearchKnown ? raw.webSearchRequests : 0,
         // CC 形不破:值仍是 number。「不知道」由同行的判别位说,见 {@link SemaModelUsage}。
         costUSD: costPriced ? raw.costMicroUsd / 1_000_000 : 0,
         contextWindow: 0, // dropped on the wire → mock-fill (static per-model table)
         maxOutputTokens: 0, // dropped on the wire → mock-fill
         ...(costPriced ? {} : { _sema_cost_absent: true }),
+        ...(webSearchKnown ? {} : { _sema_web_search_requests_absent: true }),
     };
 }
 export function turnUsageToModelUsage(usage) {

package/dist/adapter/runStream.js

@@ -1,6 +1,7 @@
 import { eventSeq, } from './types.js';
 import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.js';
-import { terminalToSdkResult } from './downstream/terminalToSdkResult.js';
+// D-3(0.66.0):终局对账臂与终帧超集键共用**同一个**成本读器(readRunCostFacts)。
+import { readRunCostFacts, terminalToSdkResult } from './downstream/terminalToSdkResult.js';
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
 /**
  * 409 session-busy 拒绝的 **canonical errorCode**([2377]C-1,server main `049ff2c`,随 5.0.0 发)。
@@ -12,6 +13,28 @@ import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 /** 本文件发的 chrome 事件全在 leader lane(子代内容在上面就被 divert 走了)。 */
 const MAIN = { lane: 'main' };
+/**
+ * **fire-and-forget 的 chrome 发射口**(0.66.0 / 异源对抗复审 [high] 逼出的同形族扫)。
+ *
+ * 病形:`try { void ctx.emitChrome(...) } catch {}` 只接得住**同步**抛出 —— 而端口的契约是
+ * `void | Promise<void>`,一个返回被拒 Promise 的 sink 会在 try/catch **之外**变成
+ * `unhandledRejection`;把未处理拒绝当致命错误的宿主(`--unhandled-rejections=strict`、
+ * Electron 主进程的全局钩子)会**整只退出**。fail-soft 的承诺在那一刻反而成了最响的失败。
+ *
+ * ⇒ 两条腿一起接:同步抛在 `try` 里吞,异步拒绝挂 `.catch`。语义与此前逐字一致
+ * (不 await、不改时序、sink 失败不影响流);`await` 的那一处(plan_review park)**不走本口**,
+ * 它的时序是刻意的(卡片先于完成行上屏)。
+ */
+function emitChromeFireAndForget(ctx, event) {
+    try {
+        const settled = ctx.emitChrome?.(event);
+        // thenable 才挂手柄:`void` 返回的同步 sink 上没有 `.catch` 可挂。
+        if (settled !== undefined && settled !== null && typeof settled.catch === 'function') {
+            void settled.catch(() => { });
+        }
+    }
+    catch { /* fail-soft — sink 抛错不影响流(原语义) */ }
+}
 /**
  * `pendingGate` 的**单向**同一性判断(#285 件2,0.36.0):「我现在看到的这道门,能不能**证明**它
  * 不是刚才那一道?」
@@ -287,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);
@@ -356,6 +388,14 @@ 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);
@@ -377,11 +417,11 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 // ——壳内向的动态边。改成 chrome 事件(宿主消费义务见 seam.ts `last_turn_usage` 臂);
                 // 与原式同样**不 await**(fire-and-forget),sink 抛错不影响流(fail-soft 原语义)。
                 if (!isSubFlow && ctx.emitChrome) {
-                    try {
+                    {
                         // engineUsage = [2295] 裁 ② 逐字原形(additive 键,契约见 seam.ts 本臂 doc):
                         // 总量/命中率消费面吃它,镜像 usage 保纯。eopt:additive 键按「诚实缺席」= 键不在
                         // (与 turn_end.usage 本身「整体 optional,缺席≠空对象」同一语义,不是「键在值 undefined」)。
-                        void ctx.emitChrome({
+                        emitChromeFireAndForget(ctx, {
                             kind: 'last_turn_usage',
                             laneProof: MAIN,
                             usage,
@@ -394,7 +434,65 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                         });
                     }
-                    catch { /* fail-soft — statusline 退回 null,原语义 */ }
+                }
+            }
+            // ── 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;
+                if (taskId !== undefined && parent !== undefined) {
+                    // 🔴 发臂条件与主臂 0.65.1 / B-088 **逐字同族**:core 真会发**裸**
+                    //    `{type:'turn_end', usageMissing:true}`(无 usage、无 stopReason),旧条件「有 usage 才发」
+                    //    会让**最诚实的那一帧**整条静默 —— 那是本仓已定谳的病形,子代这条腿不许再犯一次。
+                    //    三者任一在场即发;三者皆缺席仍不发。
+                    if ((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 };
+                    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;
@@ -554,6 +652,22 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 }
                 catch { /* fail-soft — the terminal frame below still renders */ }
             }
+            // D-3 / B-068 · L-198(0.66.0):**终局对账那一拍**。与终帧超集键
+            // (`_sema_cost_breakdown` / `_sema_nested_usage`)同一个读器 `readRunCostFacts` ⇒ 两面同源。
+            // 🔴 没有账就不说话:`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);
+                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;
         }