@sema-agent/server 7.141.0 → 7.143.0

package/dist/observability/run-terminal.d.ts

@@ -1,5 +1,6 @@
-import { type PersistedTaskResult, type RunRecord } from "../plugins/store-contracts.js";
-import { type StoredResultReadSeat } from "../terminal.js";
+import type { CollapseUnder, ExitResult, SeatKeyPaths, TextLeafPaths } from "../trace/core-keyset-guard.js";
+import { type PersistedResultSideKeys, type PersistedTaskResult, type RunRecord } from "../plugins/store-contracts.js";
+import { type PauseSeat, type StoredResultReadSeat } from "../terminal.js";
 /** 一次终局写口交给观测面的原料(store 侧装配,**未脱敏** —— 脱敏在本模块内做,见 {@link notifyRunTerminal})。 */
 export interface RunTerminalRecord {
     /** 这条 run 的账本 id = `GET /v1/runs/:id` 的 id(本仓 run 行主键名为 taskId,同一个值)。 */
@@ -165,35 +166,87 @@ export declare function redactModelText(raw: string): string;
 /** 回声座上的值留不留:形内 ⇒ `true`(原样留);`undefined` / 空串 ⇒ `false`(缺席本身,不计数);其余越界 ⇒ `false` + 计数。
  *  调用方按 `false` 删键 / 不铸键 —— 本函数是全部回声座(结果面 / 账本孪生 / 子代通告 / side-query 200 体)的**唯一**判决口。 */
 export declare function admitProviderEcho(value: unknown, seat: string): value is string;
-/** {@link redactTerminalResult} 会碰的全部顶层键 = 现行形里**不是** `"verbatim"` 的行(`"redacted"` ∪ [ref] 的
- *  `"provider-echo"`)∪ 旧形平面键;`memoRedactTerminalResult` 的记忆键由它派生(两处同源,见 `RESULT_KEY_TREATMENT` 顶注)。
- *  🔴 [ref] 起改名(原 `REDACTABLE_RESULT_LEAVES`):回声键不脱敏但**会被改**(越界 ⇒ 删键),漏进记忆键集 = 读面记忆腿对存量行
- *  O(1) 原样直返,读面纵深对那几片恒不生效([ref] 立案时 `editedFiles` 那一格的同一个病)。 */
+/**
+ * 🔴 **[ref]:一条结果上的文本叶一张座表** —— 结果汇点({@link redactTerminalResult})判「哪片叶要脱、怎么脱」的**唯一**一处。
+ *
+ * 键 = 一条结果上**每一片自由文本叶**的路径(装得下任意文字的串 / 模板串 / 品牌串 / `unknown`;点分;数组元素记 `[]`;索引签名记 `*`),值 = 闭集处置词。结果形 = 本仓结算点交给封口的三种出口结果
+ * (普通腿 `TaskResult` / verify 腿 `VerificationResult` / cascade 腿 `CascadeRunResult`,与停驻座门 ⑩f 同一组)∪ server 侧记键(`PersistedResultSideKeys`)。
+ * 键集**由类型派生**(`trace/core-keyset-guard.ts` ⑩g 的 `TextLeafPaths`),表的型就是派生键集上的映射 ⇒ core 在任何一种出口结果的任何一层加一片
+ * 自由文本叶(或把数字座 / 闭集词座放宽成串、加一个 `unknown` 座)⇒ 少一行 **TS2741**;表里留了 core 没有的残条目 ⇒ **TS2353**。数字 / 布尔 /
+ * 闭集字面量联合装不下文字,不进表(闭集词逐字过境是它的型担保的,不是一行表上的判断)。
+ *
+ * 存在理由(两次「按层记键」的病,第二次是本表的来历):
+ *  · [ref] U2:读面记忆手抄过自己的叶集 ⇒ 收成「`TaskResult` 顶层键 × 处置」一张表(`RESULT_KEY_TREATMENT`,本表取代,零别名);
+ *  · [ref]:那张表按 `keyof TaskResult` 记,组合腿结果的**超形**(verify 的 `verification`、cascade 的五键)不在键集里 ⇒
+ *    `verification.findings[]` / `evidence`(验证器模型写的自由文本)、`attempts[].gateError` / `diagnostics`(门的异常文案 / 门附的理由)原样落 run 行 /
+ *    账本 done 行 / 同步 200 体,读面整只回放;而且表只到顶层,叶在哪一层由六只手写臂各自去够(`terminal.message` / `reason`、`remoteEnvFailures[]`、
+ *    `editedFiles[].path`、`result` / `salvagedOutput`、`rewindNotes[]`),回声键另有一张实现表外加一段加载期对账。
+ *    现在:一张表 + 一只走表函数({@link applyResultTextLeaves}),写入口(店 / 账本)与读出口(同步体 / 读面)同调。
+ *
+ * **处置词(闭集,穷尽 `switch` 消费 —— 加词不加臂 = 编译红)**:
+ *  · `"model-text"`        —— 模型自由文本 / 模型可控字节 ⇒ {@link redactModelText}([ref]:与 CoT 同一只 `redactSecrets`、同一张替换串表;不设体量上限,抛则占位);
+ *  · `"error-text"`        —— 有界的披露散文(异常文案 / 引擎披露行)⇒ {@link redactErrorMessage};
+ *  · `"provider-echo"`     —— 服务商回声、引擎逐字转交的不透明 id ⇒ 只做形状校验({@link admitProviderEcho}:形内原样、越界删键 + 计数),不过脱敏器;
+ *  · `"provider-join-key"` —— 出身 provider 的跨面 join 键(工具调用 id)⇒ 本面逐字(形状在 core brain 入口一次施加,见 {@link admitProviderEcho} 顶注);
+ *  · `"verbatim"`          —— 本栈内部铸造的 id / 部署配置 / 引擎观测面 ⇒ 不碰。**唯一的模型可控逐字座**是 `structuredOutput`(见该行注)。
+ *  · `"outward-code"`      —— 机器码座(因由的 `terminal.code`、cascade 每一级的 `attempts[].errorCode`:同一类码)⇒ 本汇点不碰 —— 折码的属主是出口封口
+ *    (`terminal.ts` 的写封 / 读封,{@link sealResultForExit}):出了本服务码形的码在汇点之前已折成 `internal.store_error` 并留运维线索,汇点再折一次就是第二个属主。
+ *  · 归属词 —— 该路径下是一棵**另有派生表**的子树,本表只登记属主,不在两张表里各判一次:`"stats-tree"`(stats 五表)/ `"terminal-detail"`(detail 三臂表)/
+ *    `"api-failure"`({@link API_FAILURE_TREATMENT};结果面与账本子代通告面两张脸共用)/ `"stranded-answer"`({@link STRANDED_ANSWER_TREATMENT},逐行)。
+ *    属主表的型是 ⑩g 的 `OwnerTable`:每个成员只许盖得住它之下全部自由文本叶的词 ⇒ 子树里多一片叶而属主那一行盖不住(数字袋 `stats.nested` 里加一个串)
+ *    同样 tsc 红 —— 折叠只换了「在哪张表上红」,不留盲区。
+ * 停驻座的凭据与门(`PAUSE_SEATS` 的六条路径)**不在本表**:凭据归出口封口摘、门归 {@link redactCheckpointGate};键集从座表派生后减掉,不手抄。
+ *
+ * [ref] / [ref](7.75.1)那条规则在这里成文:**结果上的模型自由文本一律过脱敏器**,没有「别的 sink 自判」这条退路;留 `"verbatim"` 的是本栈铸的
+ * id / 目录 id / 部署配置(`structuredOutput` 一座除外,见行内注),逐叶理由见行内注。
+ */
+export type TextLeafTreatment = "model-text" | "error-text" | "provider-echo" | "provider-join-key" | "verbatim" | "outward-code" | "stats-tree" | "terminal-detail" | "api-failure" | "stranded-answer";
+/**
+ * 子树另有属主的路径前缀 —— 派生出的叶路径落在它之下就折成它本身(⑩g 的 `CollapseUnder`:按**路径**折,不按类型停 —— 结构类型的「停在某型」
+ * 会把恰好同形的别处子树一起吞掉)。前四只各对应一只归属词;`attempts.[].model` 是 core 的 `ModelRef`(`string | Model`):本服务的梯子只给目录 id 串
+ * (`http/run-meta.ts` 的 `cascadeConfig`,后台腿与同步腿同一只),对象臂不可达 ⇒ 整座按串处置,不展开 `Model` 的二十余格(对象臂真到达那天,它的凭据座
+ * —— `headers` —— 是出口封口的事,与 `PAUSE_SEATS` 同类,不是文本表的事)。
+ * ⚠️ 五只前缀里**只有这一只没有属主表接着判**(前四只的属主表是 `OwnerTable`,子树里多一片叶盖不住即红):`Model` 加一个串成员不会红 ——
+ * 它与「对象臂不可达」是同一个前提,前提翻了(梯子交对象)就得给它一张属主表或展开成行。
+ */
+type TextLeafOwnedPrefix = "stats" | "terminal.detail" | "apiFailure" | "strandedHumanAnswers.[]" | "attempts.[].model";
+/** 停驻座的凭据 / 门路径(从 `PAUSE_SEATS` 派生):先折叠(门是一棵子树),再从键集里减掉。 */
+type PauseSeatPath = SeatKeyPaths<PauseSeat, "token" | "gate">;
+/** 本表的键集(派生)。 */
+export type ResultTextLeafPath = Exclude<CollapseUnder<TextLeafPaths<ExitResult | PersistedResultSideKeys>, TextLeafOwnedPrefix | PauseSeatPath>, PauseSeatPath>;
+export declare const RESULT_TEXT_LEAVES: {
+    readonly [P in ResultTextLeafPath]: TextLeafTreatment;
+};
+/** {@link redactTerminalResult} 会碰的全部顶层键 = 文本叶表上**会动字节**的行的根键 ∪ 旧形平面键 ∪ 停驻座的根键 ∪ `editedFiles`(条目上界);
+ *  `memoRedactTerminalResult` 的记忆键由它派生(两处同源,不手抄)。漏进记忆键集 = 读面记忆腿对存量行那几片 O(1) 原样直返,读面纵深恒不生效
+ *  ([ref] 立案时 `editedFiles` 那一格、[ref] 立案时 `attempts` 那一格的同一个病 —— 后者修前不在任何键表里)。
+ *  回声行不脱敏但**会被改**(越界 ⇒ 删键),所以同样进集([ref] 起名 `TREATED_…`,原 `REDACTABLE_…`)。 */
 export declare const TREATED_RESULT_LEAVES: readonly string[];
-export declare function redactTerminalResult<T extends {
-    terminal?: unknown;
-    /** 旧形(≤7.63.0)的三个顶层座;形上取 `unknown` —— 读盘面对盘上字节不作假设。 */
-    errorMessage?: unknown;
-    blockedReason?: unknown;
-    checkpointGate?: unknown;
-    remoteEnvFailures?: readonly {
-        message?: string | undefined;
-    }[] | undefined;
-    /** [ref]:模型自由文本两叶 + 引擎披露散文一族。形上同样取 `unknown`(读面纪律,见下)。 */
-    result?: unknown;
-    salvagedOutput?: unknown;
-    rewindNotes?: unknown;
-    /** 🔴 形上**故意**是 `unknown`:本函数也是**读面**(旧持久 blob / 非 core Runner 的形不可信),
-     *  声明成 `{path,edits}[]` 会逼每一个喂坏形的调用点铸一次宽松断言 —— 而「坏形从哪来」正是本座要
-     *  处理的事(同一份不信任在 `remoteEnvFailures` 的实现里也已成文)。运行期逐项判形,不抛。 */
-    editedFiles?: unknown;
-    /** [ref]:形上同样 `unknown` —— 本函数是读盘面,`stats` 的树形逐层现判(见 {@link redactStats})。 */
-    stats?: unknown;
-    /** [ref]:provider 回声三键(形上 `unknown`,读盘面纪律同上;处置见 {@link PROVIDER_ECHO_SHAPERS})。 */
-    apiFailure?: unknown;
-    strandedHumanAnswers?: unknown;
-    responseModel?: unknown;
-} | null | undefined>(result: T): T;
+/**
+ * 同口:终态 `result` 整块也持久化(`GET /v1/runs/:id` 直出),写入前把里面的**自由文本座**脱敏,其余键
+ * 逐字不动;`undefined`/`null` 透传。
+ *
+ * 🔴 [ref](core 7.6.0 [ref] D-8):自由文本座**搬家了** —— 失败文案与阻塞理由从顶层平面键
+ * (`errorMessage` / `blockedReason`)搬进因由 `terminal` 的两条臂(`failed.message` / `blocked.reason`)。
+ * 本函数**两种形都认**,而这不是「兼容读臂」(codex 对抗复审 r1 [high],亲读验真后**改判**;首版删掉了旧键
+ * 臂,那是错的):本函数是**读盘面**,而 `task_run.result` / `task_event(done).result` 里躺着 7.63.0 及以前
+ * 写下的**真字节**,它们本来就是平面形。写口只剩因由一条(没有任何东西会再写出旧形),所以这里不存在
+ * 「两个写者」;而不认旧形的代价是**可复现的凭据回放**:上线前落盘的原文经 `GET /v1/runs/:id/events` 重新
+ * 明文外发(读面这一层纵深正是为那批行存在的)。⇒ 规则仍只有一条:**读盘认盘上真有的形,写盘只写一种形**。
+ *
+ * 读面也走本函数,所以形上一律取宽:旧持久 blob 与非 core 的 Runner 实现给的形不可信,运行期逐层判形、不抛(走表函数与各属主同款不信任)。
+ */
+/**
+ * **结果整块的唯一汇点** —— 三孪生 store 的 `setTerminal` / park 两口(经 {@link sealRunRowResult})、`redactLedgerEventData` 的 `done.result`、
+ * `POST /v1/tasks` 200 体(`http/routes/tasks.ts` 的 `mintSubmitExitResult`)、读面(`GET /v1/runs/:id` / `/events`,经 {@link memoRedactTerminalResult})
+ * 全调它,于是新铸与**存量回放**同时被覆盖(core 铸点修不回溯已写行)。四段,各有一个属主:
+ *  ① `editedFiles` 条目上界(容器界,不是文本处置;先截后走表,不为越界条目付扫描);
+ *  ② **文本叶表** {@link RESULT_TEXT_LEAVES} 一张走完({@link applyResultTextLeaves})—— 自由文本 / 回声 / 两棵另有属主的子树都在这一步;
+ *  ③ 停驻座的门({@link PAUSE_SEATS} × {@link redactCheckpointGate});
+ *  ④ 旧形(≤7.63.0)的三个顶层平面键 —— 盘上冻结形,不在任何活类型上(见 {@link LEGACY_RESULT_LEAVES})。
+ * 形上取宽:本函数也是**读盘面**(旧持久 blob / 非 core Runner 的形不可信),每一段逐层判形、不抛;字节没变 ⇒ **同一引用**。
+ */
+export declare function redactTerminalResult<T extends object | null | undefined>(result: T): T;
 /**
  * 🔴 **[ref] —— run 行 `result` 列的唯一入口**:先过出口封口({@link sealResultForExit}:摘恢复凭据 + 折域外码),
  * 再过 {@link redactTerminalResult}。三家 run 店(SQL 两方言 / file / memory)的**三个**写口 —— `setTerminal` 与
@@ -207,10 +260,14 @@ export declare function redactTerminalResult<T extends {
  *
  * `null` 原样(= 这条腿没有结果可落:引擎没给终局就收流 / 断连竞态 park / 重开 re-park)。
  *
- * `readSeat`:读面借这同一只组合读存量行时(`GET /v1/runs/:id` 的非终态臂)给出读座 —— 只决定折码运维行是「一件新的失败」还是「同一行的再观看」
- * (见 `sealResultForExit`);店的写口不给。
+ * 本函数是**写入口**(结果第一次落盘 ⇒ 折码运维线索 `at=exit`);读面读存量行用 {@link sealStoredRunRowResult}(读座必填)。
+ */
+export declare function sealRunRowResult(result: PersistedTaskResult | null): PersistedTaskResult | null;
+/**
+ * {@link sealRunRowResult} 的**读入口**(`GET /v1/runs/:id` 的非终态臂读停驻行):同一套封口 + 同一只汇点,只差折码运维线索的观看点 ——
+ * 读座必填({@link StoredResultReadSeat}),再观看走 fail-open 纪律(见 `terminal.ts` 的 `sealStoredResult`)。
  */
-export declare function sealRunRowResult(result: PersistedTaskResult | null, readSeat?: StoredResultReadSeat): PersistedTaskResult | null;
+export declare function sealStoredRunRowResult(result: PersistedTaskResult | null, seat: StoredResultReadSeat): PersistedTaskResult | null;
 /** [ref](第五轮合并重扫 wf_f00c00bc 两根 [high]):同一个 `TaskResult` 除 run 行外还被逐字追加进 run_events 的 `done` 行
  *  (bg/verify/cascade/stream/resume 五腿),`failed` 行带原文 `errorMessage`,`GET /v1/runs/:id/events` 原样回放。
  *  三孪生 `appendEvent` 入口 + 事件读面(旧行纵深)同调本函数:只认 `done.result`(整块走 `redactTerminalResult`)与
@@ -255,7 +312,7 @@ export declare function redactLeaderResultWithFlag(result: unknown): {
 };
 export declare function memoRedactedRead<T>(seat: string, raw: T, redact: (v: T) => T): T;
 /** run 终态 result 的读面记忆只按**本函数会改字节的那几叶**({@link TREATED_RESULT_LEAVES}:脱敏叶 ∪ [ref] 回声叶 ∪ 旧形平面键,属主是
- *  `RESULT_KEY_TREATMENT`)做键与留体——
+ *  文本叶表 {@link RESULT_TEXT_LEAVES})做键与留体——
  *  第十六轮重扫:按整块 result 摘要每次轮询要 stringify 一份可能数 MB 的 result,且大 result 的脏行永远存不进去。叶全缺席
  *  ⇒ O(1) 直返(`redactTerminalResult` 本就同引用)。
  *  🔴 [ref](core 7.6.0 D-8):新形把前两片搬进了 `terminal`(同属一个键,按它整只做叶更省);旧形的两片
@@ -294,4 +351,5 @@ export declare function redactLedgerEventForRead(type: string, data: unknown): u
 export declare function diffScanShadowCountForTest(): number;
 export declare function resetDiffScanShadowCountForTest(): void;
 export declare function resetReadRedactionMemoForTest(): void;
+export {};
 //# sourceMappingURL=run-terminal.d.ts.map

package/dist/observability/run-terminal.js

@@ -3,7 +3,7 @@ import { redactSecrets } from "../trace/redact.js";
 import { isProviderEchoShape } from "@sema-agent/core";
 import { isModelTextLedgerEventType, isParkLedgerEventType } from "../trace/ledger-events.js";
 import { isUnsuccessfulRunStatus } from "../plugins/store-contracts.js";
-import { mapPauseSeats, PAUSE_SEATS, sealResultForExit } from "../terminal.js";
+import { mapPauseSeats, PAUSE_SEATS, sealResultForExit, sealStoredResult } from "../terminal.js";
 import { errorText } from "./err-text.js";
 import { recordFailOpen } from "./fail-open.js";
 import { toolEndMediaAsDescriptors } from "../trace/tool-output-media.js";
@@ -128,43 +128,140 @@ function shapeEchoMembers(node, table, seat) {
     }
     return out ?? node;
 }
-function shapeEchoRows(rows, table, seat) {
-    if (!Array.isArray(rows))
-        return rows;
-    const next = rows.map((row) => shapeEchoMembers(row, table, seat));
-    return next.every((x, i) => x === rows[i]) ? rows : next;
-}
 const MAX_EDITED_FILES = 1000;
-const RESULT_KEY_TREATMENT = {
-    terminal: "redacted",
-    remoteEnvFailures: "redacted",
-    editedFiles: "redacted",
-    responseModel: "provider-echo",
-    apiFailure: "provider-echo",
-    strandedHumanAnswers: "provider-echo",
+export const RESULT_TEXT_LEAVES = {
     taskId: "verbatim",
     runId: "verbatim",
     sessionId: "verbatim",
+    placementRoot: "verbatim",
     model: "verbatim",
-    compaction: "verbatim",
-    effectiveReasoning: "verbatim",
-    result: "redacted",
-    salvagedOutput: "redacted",
-    retryAfterMs: "verbatim",
-    degraded: "verbatim",
+    "terminal.code": "outward-code",
+    "terminal.message": "error-text",
+    "terminal.reason": "error-text",
+    "terminal.detail": "terminal-detail",
+    "terminal.checkpointId": "verbatim",
+    "terminal.requestedByCallId": "provider-join-key",
+    "terminal.nestedPause.checkpointId": "verbatim",
+    "terminal.nestedPause.requestedByCallId": "provider-join-key",
+    result: "model-text",
+    salvagedOutput: "model-text",
+    "remoteEnvFailures.[].message": "error-text",
+    "rewindNotes.[].message": "error-text",
+    "editedFiles.[].path": "model-text",
+    responseModel: "provider-echo",
+    apiFailure: "api-failure",
+    "strandedHumanAnswers.[]": "stranded-answer",
+    "degraded.from": "verbatim",
+    "degraded.to": "verbatim",
+    "degraded.chain.[]": "verbatim",
+    "effectiveReasoning.endpoint": "verbatim",
+    "resultEntryIds.[]": "verbatim",
+    "pendingApproval.askIds.[]": "verbatim",
+    "effectiveReadDenyPatterns.[].pattern": "verbatim",
+    "effectiveMemoryScopes.writeScope": "verbatim",
+    "effectiveMemoryScopes.scopes.[].scope": "verbatim",
+    "effectiveMemoryScopes.projectKey.scope": "verbatim",
+    "effectiveMemoryScopes.materializedResidue.[]": "verbatim",
     structuredOutput: "verbatim",
-    resultEntryIds: "verbatim",
-    rewindNotes: "redacted",
-    haltedOnUserRejection: "verbatim",
-    haltedByUser: "verbatim",
-    pendingApproval: "verbatim",
-    approvalWaitedMs: "verbatim",
-    effectiveReadFace: "verbatim",
-    effectiveWriteFace: "verbatim",
-    effectiveReadDenyPatterns: "verbatim",
-    effectiveMemoryScopes: "verbatim",
-    stats: "redacted",
+    stats: "stats-tree",
+    "verification.findings.[]": "model-text",
+    "verification.evidence": "model-text",
+    "verification.verifierPause.sessionId": "verbatim",
+    "verification.verifierPause.checkpointId": "verbatim",
+    "attempts.[].model": "verbatim",
+    "attempts.[].errorCode": "outward-code",
+    "attempts.[].gateError": "error-text",
+    "attempts.[].diagnostics": "model-text",
+    "cancelContext.lastEventKind": "verbatim",
+    "cancelContext.lastBrainStatus.phase": "verbatim",
+    "cancelContext.lastBrainStatus.errClass": "verbatim",
 };
+const DROP_LEAF = Symbol("drop-leaf");
+function textLeafAct(treatment) {
+    switch (treatment) {
+        case "verbatim":
+        case "provider-join-key":
+        case "outward-code":
+            return undefined;
+        case "model-text":
+            return (v) => (typeof v === "string" ? redactModelText(v) : v);
+        case "error-text":
+            return (v) => (typeof v === "string" ? redactErrorMessage(v) : v);
+        case "provider-echo":
+            return (v, _holder, seat) => (admitProviderEcho(v, seat) ? v : DROP_LEAF);
+        case "stats-tree":
+            return (v) => redactStats(v);
+        case "terminal-detail":
+            return (v, holder) => shapeTerminalDetail(v, holder);
+        case "api-failure":
+            return (v) => shapeEchoMembers(v, API_FAILURE_TREATMENT, "apiFailure");
+        case "stranded-answer":
+            return (v) => shapeEchoMembers(v, STRANDED_ANSWER_TREATMENT, "strandedHumanAnswers[]");
+        default: {
+            const unhandled = treatment;
+            throw new Error(`unhandled text-leaf treatment: ${String(unhandled)}`);
+        }
+    }
+}
+const ACTIVE_TEXT_LEAVES = Object.entries(RESULT_TEXT_LEAVES).flatMap(([seat, treatment]) => {
+    const act = textLeafAct(treatment);
+    return act === undefined ? [] : [{ seat, segments: seat.split("."), act }];
+});
+function mapTextLeaf(node, segments, depth, holder, act, seat) {
+    if (depth === segments.length)
+        return act(node, holder, seat);
+    if (node === null || typeof node !== "object")
+        return node;
+    const segment = segments[depth];
+    if (segment === "[]") {
+        if (!Array.isArray(node))
+            return node;
+        let changed = false;
+        const next = [];
+        for (const el of node) {
+            const n = el === undefined ? el : mapTextLeaf(el, segments, depth + 1, node, act, seat);
+            if (n === DROP_LEAF) {
+                changed = true;
+                continue;
+            }
+            if (!Object.is(n, el))
+                changed = true;
+            next.push(n);
+        }
+        return changed ? next : node;
+    }
+    if (Array.isArray(node))
+        return node;
+    const obj = node;
+    let out;
+    for (const key of segment === "*" ? Object.keys(obj) : Object.hasOwn(obj, segment) ? [segment] : []) {
+        const child = obj[key];
+        if (child === undefined)
+            continue;
+        const n = mapTextLeaf(child, segments, depth + 1, obj, act, seat);
+        if (n === DROP_LEAF)
+            delete (out ??= { ...obj })[key];
+        else if (!Object.is(n, child))
+            (out ??= { ...obj })[key] = n;
+    }
+    return out ?? node;
+}
+function applyResultTextLeaves(result) {
+    let out = result;
+    for (const row of ACTIVE_TEXT_LEAVES)
+        out = mapTextLeaf(out, row.segments, 0, undefined, row.act, row.seat);
+    return out;
+}
+function shapeTerminalDetail(detail, terminal) {
+    const kind = terminal !== null && typeof terminal === "object" ? terminal.kind : undefined;
+    if (kind === "failed")
+        return shapeArmedDetail(detail, TERMINAL_FAILURE_DETAIL_TREATMENT);
+    if (kind === "completed")
+        return shapeArmedDetail(detail, TERMINAL_COMPLETED_DETAIL_TREATMENT);
+    if (kind === "blocked")
+        return shapeTerminalBlockedDetail(detail);
+    return shapeArmedDetail(detail, {});
+}
 const API_FAILURE_TREATMENT = {
     status: "verbatim",
     requestId: "provider-echo",
@@ -182,6 +279,8 @@ const TERMINAL_FAILURE_DETAIL_TREATMENT = {
         providerConditionSource: "verbatim",
         providerResetAtMs: "verbatim",
         route: "verbatim",
+        errorKind: "verbatim",
+        tool: "verbatim",
     },
     coded: { kind: "verbatim", detail: "free-text-tree" },
     model_output_invalid: { kind: "verbatim", cause: "verbatim", outputLimit: "verbatim" },
@@ -209,12 +308,15 @@ function redactStringLeaves(node, depth = 0) {
 }
 const OFF_ARM_MEMBER_TREATMENT = "free-text-tree";
 const redactDetailMember = (v) => redactStringLeaves(v, 1);
-function shapeTerminalFailureDetail(detail) {
+const TERMINAL_COMPLETED_DETAIL_TREATMENT = {
+    finish_reason_unknown: { kind: "verbatim", finishReasonUnknown: "provider-echo" },
+};
+function shapeArmedDetail(detail, arms) {
     if (detail === null || typeof detail !== "object" || Array.isArray(detail))
         return detail;
     const d = detail;
     const kind = d.kind;
-    const arm = typeof kind === "string" && Object.hasOwn(TERMINAL_FAILURE_DETAIL_TREATMENT, kind) ? TERMINAL_FAILURE_DETAIL_TREATMENT[kind] : {};
+    const arm = typeof kind === "string" && Object.hasOwn(arms, kind) ? arms[kind] : {};
     let out;
     for (const key of Object.keys(d)) {
         const v = d[key];
@@ -237,7 +339,7 @@ function shapeTerminalFailureDetail(detail) {
             }
             default: {
                 const unhandled = treatment;
-                throw new Error(`unhandled failure-detail treatment: ${String(unhandled)}`);
+                throw new Error(`unhandled detail-member treatment: ${String(unhandled)}`);
             }
         }
     }
@@ -282,153 +384,60 @@ function shapeTerminalBlockedDetail(detail) {
     }
     return out ?? detail;
 }
-const PROVIDER_ECHO_SHAPERS = {
-    responseModel: (v) => (admitProviderEcho(v, "responseModel") ? v : undefined),
-    apiFailure: (v) => shapeEchoMembers(v, API_FAILURE_TREATMENT, "apiFailure"),
-    strandedHumanAnswers: (v) => shapeEchoRows(v, STRANDED_ANSWER_TREATMENT, "strandedHumanAnswers[]"),
-};
-{
-    const judged = Object.entries(RESULT_KEY_TREATMENT).filter(([, t]) => t === "provider-echo").map(([k]) => k).sort();
-    const wired = Object.keys(PROVIDER_ECHO_SHAPERS).sort();
-    if (judged.join(",") !== wired.join(","))
-        throw new Error(`run-terminal: provider-echo classification [${judged.join(",")}] ≠ shaper table [${wired.join(",")}]`);
-}
 const LEGACY_RESULT_LEAVES = ["errorMessage", "blockedReason", "checkpointGate"];
 export const TREATED_RESULT_LEAVES = [
     ...new Set([
-        ...Object.entries(RESULT_KEY_TREATMENT).filter(([, t]) => t !== "verbatim").map(([k]) => k),
+        ...ACTIVE_TEXT_LEAVES.map((row) => row.segments[0]),
         ...LEGACY_RESULT_LEAVES,
         ...PAUSE_SEATS.map((seat) => seat.path[0]),
+        "editedFiles",
     ]),
 ];
 export function redactTerminalResult(result) {
     if (result === undefined || result === null)
         return result;
-    const r = result;
-    let changed = false;
-    const out = { ...r };
-    if (typeof r.errorMessage === "string") {
-        out.errorMessage = redactErrorMessage(r.errorMessage);
-        changed = true;
-    }
-    if (typeof r.blockedReason === "string") {
-        out.blockedReason = redactErrorMessage(r.blockedReason);
-        changed = true;
-    }
-    if (r.checkpointGate !== undefined) {
-        const legacyGate = redactCheckpointGate(r.checkpointGate);
-        if (legacyGate !== r.checkpointGate) {
-            out.checkpointGate = legacyGate;
-            changed = true;
-        }
-    }
-    if (r.terminal !== null && typeof r.terminal === "object") {
-        const t = r.terminal;
-        let nt;
-        if (t.kind === "failed" && typeof t.message === "string")
-            nt = { ...t, message: redactErrorMessage(t.message) };
-        else if (t.kind === "blocked" && typeof t.reason === "string")
-            nt = { ...t, reason: redactErrorMessage(t.reason) };
-        if (t.kind === "blocked") {
-            const cur = nt ?? t;
-            const detail = cur.detail;
-            const shaped = shapeTerminalBlockedDetail(detail);
-            if (shaped !== detail)
-                nt = { ...cur, detail: shaped };
-        }
-        const base = nt ?? t;
-        if (t.kind === "failed") {
-            const cur = nt ?? base;
-            const detail = cur.detail;
-            const shaped = shapeTerminalFailureDetail(detail);
-            if (shaped !== detail)
-                nt = { ...cur, detail: shaped };
-        }
-        if (nt !== undefined) {
-            out.terminal = nt;
-            changed = true;
-        }
-    }
-    const gated = mapPauseSeats(out, (seat, keys) => {
+    return redactLegacyPlaneLeaves(redactPauseSeatGates(applyResultTextLeaves(capEditedFiles(result))));
+}
+function capEditedFiles(result) {
+    const files = result.editedFiles;
+    if (!Array.isArray(files) || files.length <= MAX_EDITED_FILES)
+        return result;
+    return { ...result, editedFiles: files.slice(0, MAX_EDITED_FILES) };
+}
+function redactPauseSeatGates(result) {
+    return mapPauseSeats(result, (seat, keys) => {
         if (!Object.hasOwn(seat, keys.gate))
             return seat;
         const g = seat[keys.gate];
         const ng = redactCheckpointGate(g);
         return ng === g ? seat : { ...seat, [keys.gate]: ng };
     });
-    if (gated !== out) {
-        Object.assign(out, gated);
-        changed = true;
-    }
-    if (r.remoteEnvFailures !== undefined) {
-        out.remoteEnvFailures = Array.isArray(r.remoteEnvFailures)
-            ? r.remoteEnvFailures.map((f) => (f && typeof f === "object" && typeof f.message === "string" ? { ...f, message: redactErrorMessage(f.message) } : f))
-            : r.remoteEnvFailures;
-        changed = true;
-    }
-    if (r.editedFiles !== undefined) {
-        out.editedFiles = Array.isArray(r.editedFiles)
-            ? r.editedFiles
-                .slice(0, MAX_EDITED_FILES)
-                .map((f) => {
-                if (f === null || typeof f !== "object")
-                    return f;
-                const path = f.path;
-                return typeof path === "string" ? { ...f, path: redactSecrets(path) } : f;
-            })
-            : r.editedFiles;
-        changed = true;
-    }
-    if (typeof r.result === "string") {
-        const next = redactModelText(r.result);
-        if (next !== r.result) {
-            out.result = next;
-            changed = true;
-        }
-    }
-    if (typeof r.salvagedOutput === "string") {
-        const next = redactModelText(r.salvagedOutput);
-        if (next !== r.salvagedOutput) {
-            out.salvagedOutput = next;
-            changed = true;
-        }
+}
+function redactLegacyPlaneLeaves(result) {
+    const r = result;
+    let out;
+    if (typeof r.errorMessage === "string") {
+        const next = redactErrorMessage(r.errorMessage);
+        if (next !== r.errorMessage)
+            (out ??= { ...result }).errorMessage = next;
     }
-    if (r.rewindNotes !== undefined) {
-        out.rewindNotes = Array.isArray(r.rewindNotes)
-            ? r.rewindNotes.map((n) => {
-                if (n === null || typeof n !== "object")
-                    return n;
-                const message = n.message;
-                return typeof message === "string" ? { ...n, message: redactErrorMessage(message) } : n;
-            })
-            : r.rewindNotes;
-        changed = true;
-    }
-    if (r.stats !== undefined) {
-        const next = redactStats(r.stats);
-        if (next !== r.stats) {
-            out.stats = next;
-            changed = true;
-        }
+    if (typeof r.blockedReason === "string") {
+        const next = redactErrorMessage(r.blockedReason);
+        if (next !== r.blockedReason)
+            (out ??= { ...result }).blockedReason = next;
     }
-    const rr = result;
-    for (const [key, shape] of Object.entries(PROVIDER_ECHO_SHAPERS)) {
-        const v = rr[key];
-        if (v === undefined || shape === undefined)
-            continue;
-        const next = shape(v);
-        if (next === v)
-            continue;
-        if (next === undefined)
-            delete out[key];
-        else
-            out[key] = next;
-        changed = true;
+    if (r.checkpointGate !== undefined) {
+        const next = redactCheckpointGate(r.checkpointGate);
+        if (next !== r.checkpointGate)
+            (out ??= { ...result }).checkpointGate = next;
     }
-    return changed ? out : result;
+    return out === undefined ? result : out;
+}
+export function sealRunRowResult(result) {
+    return result === null ? null : redactTerminalResult(sealResultForExit(result));
 }
-export function sealRunRowResult(result, readSeat) {
-    return result === null ? null : redactTerminalResult(sealResultForExit(result, readSeat));
+export function sealStoredRunRowResult(result, seat) {
+    return result === null ? null : redactTerminalResult(sealStoredResult(result, seat));
 }
 export function redactLedgerEventData(type, data) {
     if (data === null || typeof data !== "object" || Array.isArray(data))
@@ -897,7 +906,7 @@ export function memoRedactedRead(seat, raw, redact) {
 export function memoRedactTerminalResult(seat, raw) {
     if (raw === undefined || raw === null)
         return raw;
-    const result = sealResultForExit(raw, seat);
+    const result = sealStoredResult(raw, seat);
     const r = result;
     if (TREATED_RESULT_LEAVES.every((k) => r[k] === undefined))
         return result;

package/dist/orchestration/workflow-completion-inbox.d.ts

@@ -46,10 +46,9 @@ export interface WorkflowCompletionInbox {
      *  the ownerless fence silently starved the new claimant's push). Omitted `purgedOwner` = conservative
      *  fence-all (an ownerless caller can't distinguish). */
     purge(sessionId: string, purgedOwner?: string | null): Promise<void>;
-    /** The originating session OBSERVED this run's terminal state through a model-facing poll
-     *  (core 1.232 `WorkflowCompletionNotifier.ackServed` fires this), so the push would be
-     *  a pure duplicate ("poll-then-also-notify" double delivery: the model burns turns dismissing a completion
-     *  it already summarized). Drops the pending entry (a deliberate ack) AND arms a {@link SERVED_FENCE_MS}
+    /** The originating session already OBSERVED this run's terminal state on another delivery (the fleet bus's
+     *  task-notification fold acks the family it delivered), so the push would be a pure duplicate (double
+     *  delivery: the model burns turns dismissing a completion it already summarized). Drops the pending entry (a deliberate ack) AND arms a {@link SERVED_FENCE_MS}
      *  enqueue fence for this (session, runId) so a LATE-arriving notify (the notifier races the poll) is
      *  dropped too. Fence is in-memory only — a crash between poll and notify re-delivers (at-least-once; the
      *  shell's own runId dedup + the model tolerate it), mirroring the purge fence's restart posture. */
@@ -147,7 +146,7 @@ export declare class InMemoryWorkflowCompletionInbox implements WorkflowCompleti
      *  refused. Swept on BOTH enqueue and purge (a purge-heavy, enqueue-quiet process must not accumulate
      *  stamps unboundedly — review). */
     private readonly purgedAt;
-    /** servedKey(sessionId, runId) → stamp: terminal-poll-served fences; an enqueue for the pair within
+    /** servedKey(sessionId, runId) → stamp: served fences; an enqueue for the pair within
      *  {@link SERVED_FENCE_MS} is refused (the poll already told the model). Swept alongside the purge fence. */
     private readonly servedAt;
     constructor(onWarn?: ((msg: string, meta: Record<string, unknown>) => void) | undefined);
@@ -323,7 +322,7 @@ export declare function externalNotificationInboxEntry(sessionId: string, owner:
  * UNTRUSTED free text). `status` collapses onto the inbox's completed|failed column; the ORIGINAL status rides
  * the payload extras and overrides on drain (killed/cancelled reach the shell verbatim). Workflow-type
  * notifications are the CALLER's job to filter (they have their own durable chain — double-enqueueing here would
- * re-open the poll-served double-push). External notifications enter through {@link externalNotificationInboxEntry}.
+ * deliver the same completion twice). External notifications enter through {@link externalNotificationInboxEntry}.
  */
 export declare function taskNotificationInboxEntry(sessionId: string, owner: string | null, n: EngineNotificationParkInput, enqueuedAt: number, 
 /** lead-b (dual-ID audit): the PARENT run's durable taskId (the uuid the shell's footer rows
@@ -372,18 +371,5 @@ export declare function resolveCompletionRoute(p: {
     sessionId: string;
     owner: string | null;
 } | undefined>;
-/**
- * core 1.232 — resolve WHICH session's inbox entry a poll-served ack targets: the payload's
- * `originatingSessionId` directly (core threads it on `ackServed`), else the originating run row via
- * `sourceTaskId` (mirrors {@link resolveCompletionRoute}'s session half — same fallback, same reason:
- * older runs may predate the lookup-free field). Returns undefined when there is no attribution — the
- * entry stays pending (at-least-once; the shell's own dedup covers a rare duplicate).
- */
-export declare function resolveServedSession(p: {
-    originatingSessionId?: string;
-    sourceTaskId?: string;
-}, getRun?: (taskId: string) => Promise<{
-    sessionId?: string | null;
-} | undefined | null>): Promise<string | undefined>;
 export {};
 //# sourceMappingURL=workflow-completion-inbox.d.ts.map

package/dist/orchestration/workflow-completion-inbox.js

@@ -429,16 +429,4 @@ export async function resolveCompletionRoute(p, getRun, requirePrincipal) {
     }
     return { sessionId, owner };
 }
-export async function resolveServedSession(p, getRun) {
-    if (p.originatingSessionId)
-        return p.originatingSessionId;
-    if (p.sourceTaskId && getRun) {
-        try {
-            return (await getRun(p.sourceTaskId))?.sessionId ?? undefined;
-        }
-        catch {
-        }
-    }
-    return undefined;
-}
 //# sourceMappingURL=workflow-completion-inbox.js.map