@sema-agent/server 7.134.0 → 7.135.0

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

@@ -4,7 +4,7 @@ export interface RunTerminalRecord {
     /** 这条 run 的账本 id = `GET /v1/runs/:id` 的 id(本仓 run 行主键名为 taskId,同一个值)。 */
     runId: string;
     /**
-     * 🔴 **只在「这条终局要出声」时在场**(S-450):三只 store 只在 `runTerminalLogLevel(...) !== undefined`
+     * 🔴 **只在「这条终局要出声」时在场**([ref]):三只 store 只在 `runTerminalLogLevel(...) !== undefined`
      * 时才多付那一次 PK 读去装它(成功终局零额外查询 —— 那条注在 `run-store-sql.ts` 的 `setTerminal` 里)。
      * 日志腿恰好只在同一形下运行,所以**它读到的恒是在场的**;行为订阅者不得依赖它。
      */
@@ -24,7 +24,7 @@ export interface RunTerminalRecord {
 /** **日志腿**收到的是**已判级 + 已脱敏 + 已截断**的成品——装配层只负责把它送进 logger。 */
 export type RunTerminalLogObserver = (level: "error" | "info", fields: Record<string, unknown>) => void;
 /**
- * **行为订阅者**(S-450):CAS 赢的那一刻收到整只 {@link RunTerminalRecord}。
+ * **行为订阅者**([ref]):CAS 赢的那一刻收到整只 {@link RunTerminalRecord}。
  *
  * 🔴 载荷是**这次写自己的视角**,不是回读的 durable 行 —— 只有 `runId` / `status` 两位在**任何**形下
  * 都为真(CAS 赢 ⇒ 行就是这个词)。日志腿专用的那几位在成功终局上**刻意缺席**(store 不为它们多付一次
@@ -35,14 +35,14 @@ export type RunTerminalSubscriber = (rec: RunTerminalRecord) => void;
  * 终局行的级别判据。`undefined` = 不打行。
  *
  * 一句话:**非成功终局才出声**(`failed` / `blocked`),用户主动取消降 `info`。词的分类不在本模块做 ——
- * 它的唯一属主是 `plugins/store-contracts.ts` 的 `RUN_STATUS_CLASS` 表(S-213③:本模块此前手抄了一张
+ * 它的唯一属主是 `plugins/store-contracts.ts` 的 `RUN_STATUS_CLASS` 表([ref]③:本模块此前手抄了一张
  * 穷举 switch,并在 `blocked` 那一格给出与 fleet 读面互斥的答案)。表的编译期双向钉在属主处。
  */
 export declare function runTerminalLogLevel(status: RunRecord["status"], errorCode: string | undefined): "error" | "info" | undefined;
 /** **日志腿**的装配点(`boot/stage-01-config.ts` 唯一)。传 `undefined` 卸载(测试隔离)。 */
 export declare function setRunTerminalLogObserver(fn: RunTerminalLogObserver | undefined): void;
 /**
- * **行为订阅者**的登记口(S-450)。返回解除登记的句柄。
+ * **行为订阅者**的登记口([ref])。返回解除登记的句柄。
  *
  * 与 {@link setRunTerminalLogObserver} 是**两个语义不同的席**,不是一个带旗的列表:
  *  · 日志腿**恰一只**、装配层亲接、**不隔离**(抛出会让 `setTerminal` reject —— 见 {@link notifyRunTerminal});
@@ -65,7 +65,7 @@ export declare function resetRunTerminalSubscribersForTest(): void;
  * 为什么日志腿**刻意不 try**(原文保留,[ref] 的成文理由):静默吞掉观测者异常 = 又造一条「走了兜底与
  * 一切正常同形」的路,方向与本模块的存在理由相反;生产装配的那一只只调 `Logger`(`createLogger` 的 emit
  * 内部已把 JSON.stringify 与 write 全部 try 住,结构上不抛)。
- * 为什么行为订阅者**必须 try**(S-450 新加的那一半):它们是**行为腿**,不是一只结构上不抛的 logger;
+ * 为什么行为订阅者**必须 try**([ref] 新加的那一半):它们是**行为腿**,不是一只结构上不抛的 logger;
  * 而本函数跑在 `setTerminal` 的调用栈上、**CAS 已经赢了、行已经落盘**,此时把订阅者的 bug 放大成
  * 「终局写 reject」= run 卡 `running` 到 reaper + claim 悬挂([ref] 指纹)。吞但**不静默**:
  * `recordFailOpen("server.fleet.terminal-notify")`(F 类,普查登记在案)。
@@ -75,17 +75,17 @@ export declare function resetRunTerminalSubscribersForTest(): void;
  * 而引擎日志是运维面、常被整条采集走。`errorCode` / `model` 是闭集式短标量,verbatim。
  */
 export declare function notifyRunTerminal(rec: RunTerminalRecord): void;
-/** S-105(test [ref] 旁生):终态**持久化**的 `errorMessage` 与日志副本同一脱敏口——provider 错误体(403 体带回显请求头/
+/** [ref](test [ref] 旁生):终态**持久化**的 `errorMessage` 与日志副本同一脱敏口——provider 错误体(403 体带回显请求头/
  *  订阅链接)里的密钥形不得原文落 run 行再由 `GET /v1/runs/:id` 直出。三 run store 的 `setTerminal` 写入前同调此函数;
  *  `undefined` 透传(缺席仍缺席),不截断(日志上限是日志的事,行上保留全文供取证)。 */
-/** r4 最终轮 [medium]:`redactSecrets` 曾会抛 `RangeError`(关键字/前缀臂那一形由 S-219 的 `atLeast` 铸点闭掉;JSON 秘密字段臂的
- *  转义对循环与 PEM 栅栏臂的标签交替循环由 S-265 换成手写线性扫描器闭掉 —— 已知形全部闭掉);S-105 把脱敏
+/** r4 最终轮 [medium]:`redactSecrets` 曾会抛 `RangeError`(关键字/前缀臂那一形由 [ref] 的 `atLeast` 铸点闭掉;JSON 秘密字段臂的
+ *  转义对循环与 PEM 栅栏臂的标签交替循环由 [ref] 换成手写线性扫描器闭掉 —— 已知形全部闭掉);[ref] 把脱敏
  *  挪到 `setTerminal` **入口**后,这个抛会先于 CAS/claim 释放 ⇒ run 卡 `running`、会话 claim 悬挂到 reaper。这里 **fail-closed
  *  不抛**:脱敏失败 ⇒ 落固定占位 `«redacted:oversized»`(绝不落原文,也绝不阻断终态翻转),并走既有 fail-open 遥测 tag。
- *  🔴 S-265 之后这条 throw 臂**照留**(结构性兜底,不依赖「脱敏器今天抛不抛」):它守的是「终态翻转不被一次脱敏异常拦下」,
+ *  🔴 [ref] 之后这条 throw 臂**照留**(结构性兜底,不依赖「脱敏器今天抛不抛」):它守的是「终态翻转不被一次脱敏异常拦下」,
  *  而脱敏器是一张会长新臂的表 —— 计数 `server.run-terminal.redact-threw` 恒零是证据,不归零就是新形,运维按 detail 回溯。 */
 export declare const OVERSIZED_REDACTION_PLACEHOLDER = "\u00ABredacted:oversized\u00BB";
-/** S-107 窄范围重扫 [medium]:`redactSecrets` 对 PEM 起始栅栏密集的多 MB 文案**不抛但慢**(实测 1MB 1.4s / 8MB 7.9s 同步阻塞
+/** [ref] 窄范围重扫 [medium]:`redactSecrets` 对 PEM 起始栅栏密集的多 MB 文案**不抛但慢**(实测 1MB 1.4s / 8MB 7.9s 同步阻塞
  *  事件循环),而终态座每次写要扫两遍(appendEvent + setTerminal 入口)、每次读再扫一遍。超过本上限的自由文本**整段**换占位
  *  (fail-closed:不截断——截断会把密钥切成半截,[ref] 的病;不扫——O(1)),取证面丢的是「>256KB 的错误文案」这一档。 */
 /** codex r2 [medium]:上限按**边界最坏耗时**定——PEM 栅栏密集形 256KB 一次扫 0.25–0.46s、终态一次写扫两遍再加读面,一行
@@ -97,13 +97,13 @@ export declare const REDACT_INPUT_CAP = 65536;
 export declare const REDACT_OUTPUT_MAX_BYTES = 65000;
 export declare function redactErrorMessage(raw: string | undefined): string | undefined;
 /**
- * 🔴 **模型自由文本的唯一装载口**(B-106 / S-268,7.75.1)——`TaskResult.result` / `TaskResult.salvagedOutput`
+ * 🔴 **模型自由文本的唯一装载口**([ref] / [ref],7.75.1)——`TaskResult.result` / `TaskResult.salvagedOutput`
  * 与账本的 `text` / `reasoning` 两行,四座同调本函数。
  *
  * 它**不是第二只脱敏器**:零自有规则表、零自有词表,判「什么算凭据」的仍然只有 {@link redactSecrets} 一只。
  * 本函数只定两件**写回**的事,而这两件事在三条既有纪律面前各只有一个正确答案:
  *
- * ① **认出凭据形才改写字节;没认出就回原串** —— 这就是 `redactSecrets` 自己的语义,本函数不另立读法(S-1435 起):
+ * ① **认出凭据形才改写字节;没认出就回原串** —— 这就是 `redactSecrets` 自己的语义,本函数不另立读法([ref] 起):
  *    臂只在剥 `\p{Cf}` 后的视图上认凭据,产物按**原文**坐标拼 ⇒ 没有跨度的文本逐字节原样(`👨‍👩‍👧` 的 ZWJ、波斯语
  *    `می‌خواهم` 的 ZWNJ 都在),有跨度时只有跨度内的字节被盖 —— 夹在密钥中间的零宽字符随整段密钥一起换成记号,
  *    消费端拿不到可拼回原钥的残片。此前 `redactSecrets` 的产物是剥后文本,本函数为此另比一次「输出 === 剥后原文 ⇒
@@ -114,7 +114,7 @@ export declare function redactErrorMessage(raw: string | undefined): string | un
  *    裸调用会让异常穿过 `redactTerminalResult` → 三孪生 `setTerminal`,**一条跑成功的 run 落成 failed + result:null**
  *    (实测读数)。⇒ 与本文件既有的 {@link redactErrorMessage} / `redactDiagnosticText` / `redactArtifactText`
  *    三座**同一条**处置:抛就换占位、计数、留痕([ref] 的 loud,不是静默 fail-open)。丢的是这一条病态文本,
- *    不是这条 run。根因(那条正则)由 S-265(7.105.0)换成手写线性扫描器闭掉(同批闭掉同类第二例 PEM 栅栏标签循环);
+ *    不是这条 run。根因(那条正则)由 [ref](7.105.0)换成手写线性扫描器闭掉(同批闭掉同类第二例 PEM 栅栏标签循环);
  *    本处置**照留** —— 理由同 {@link OVERSIZED_REDACTION_PLACEHOLDER} 顶注末句。
  * ③ **不设体量上限**(裁定):`result` 住在 `result` JSON/JSONB 列(亲核 `plugins/tidb-pool.ts` 与
  *    `plugins/pg-pool.ts` 的 DDL),数 MB 终稿是正常形 —— {@link redactErrorMessage} 的两道上限是为
@@ -122,40 +122,40 @@ export declare function redactErrorMessage(raw: string | undefined): string | un
  */
 export declare function redactModelText(raw: string): string;
 /**
- * 🔴 **provider 回声字段的形状闸 —— 唯一铸点**(S-283,7.105.0;test [ref] 附带;动作经 S-889 与 core 源头闸归一)。
+ * 🔴 **provider 回声字段的形状闸 —— 唯一铸点**([ref],7.105.0;test [ref] 附带;动作经 [ref] 与 core 源头闸归一)。
  *
  * **回声字段是什么**:模型服务商(上游模型 API / 中间网关)在响应里给、引擎**逐字转交**的不透明标识 ——
  * `apiFailure.requestId`(响应头 `request-id` / `x-request-id`,core `brain/errors.js` 的 `readProviderRequestId`)、
  * `responseModel`(服务商自报的模型名,与账本 `turn_end.responseModel` 是孪生)。字节由**部署方接的那个端点**决定,本栈一个都没铸 ⇒ **不可信**。
- * 工具调用 id(`strandedHumanAnswers[].toolCallId` / `stats.humanReview.gates[].toolCallId`)**出身**同样是服务商,但自 core 7.36.0(#1207)起
+ * 工具调用 id(`strandedHumanAnswers[].toolCallId` / `stats.humanReview.gates[].toolCallId`)**出身**同样是服务商,但自 core 7.36.0([ref])起
  * 它进引擎之前已**准入一次**:三只 brain 在建调用的那一行(`brain/tool-call-id.js` 的 `admitToolCallId`)—— 缺席 ⇒ 车道兜底铸;
  * 在形(可见 ASCII 1–128 且不含 `~`)⇒ 原样;越界 ⇒ 单射折叠成引擎 id(`<前 32 码元,越界字符记 `-`>~<sha256 前 32 hex>`),原字节只挂在
  * 转录的 `ToolCall.wireId` 上、只回给 provider。⇒ 一方 brain 在 7.107.0 起新铸的调用,到达本仓任何一张脸的 `toolCallId` 恒在形。
- * 残余两条(S-921,如实):① ≤7.106.0 写下的存量行(待批 park 行 `boundCallId` / 检查点 `pendingAction.toolCallId` / 转录)是服务商原串逐字 —— 新版不对存量行二次准入(e2e G4 钉);② 宿主自己的 `Brain`(不经三只一方 adapter)铸的 id 不准入(core KL-1207-a;本仓生产装配的 brain 恒是 `createBrain` 的一方 adapter 外套委托装饰,这一形只经嵌入 / 测试注入的 brain 到达)。两条残余里的 id 仍是跨面 join 键、每张脸同值,只是形状不保证(本闸照旧不动它们:动一张脸 = join 断)。
+ * 残余两条([ref],如实):① ≤7.106.0 写下的存量行(待批 park 行 `boundCallId` / 检查点 `pendingAction.toolCallId` / 转录)是服务商原串逐字 —— 新版不对存量行二次准入(e2e G4 钉);② 宿主自己的 `Brain`(不经三只一方 adapter)铸的 id 不准入(core KL-1207-a;本仓生产装配的 brain 恒是 `createBrain` 的一方 adapter 外套委托装饰,这一形只经嵌入 / 测试注入的 brain 到达)。两条残余里的 id 仍是跨面 join 键、每张脸同值,只是形状不保证(本闸照旧不动它们:动一张脸 = join 断)。
  *
  * 🔴 **本闸只施加在「这个值出现的每一张脸都被覆盖到」的回声上**(codex r1 F1,实测成立的回归后改判):工具调用 id 是
  * **跨面 join 键** —— 同一枚 id 同时逐字出现在 `tool_start` / `tool_end` / 审批卡等逐帧面上。只在结果面动它 ⇒ 结果面与逐帧面
  * join 不上。所以它的处置词是 `"provider-join-key"`:出身是 provider,形状在**全部面的共同入口一次施加** —— 那个入口就是上面那条
- * core brain 准入(S-890 v1 / v2 小稿提给 core、#1207 落地;本仓零闸,不加第二道门),本面逐字 = 每张脸同一枚引擎 id,join 成立。`requestId` / `responseModel` 的每一张脸(结果面四处 + 账本孪生 + 子代通告 + `POST /v1/side-query` 200 体的 `responseModel`,
+ * core brain 准入([ref] v1 / v2 小稿提给 core、[ref] 落地;本仓零闸,不加第二道门),本面逐字 = 每张脸同一枚引擎 id,join 成立。`requestId` / `responseModel` 的每一张脸(结果面四处 + 账本孪生 + 子代通告 + `POST /v1/side-query` 200 体的 `responseModel`,
  * 后者 7.105.0 合并复审 X1 补上 —— `http/routes/side-query.ts` 的 `shapeSideQueryEcho`)本闸都覆盖到了。
  *
- * **只做形状校验,不过脱敏器**(本车裁,与 S-270 / clay [ref] ② 的 `structuredOutput` 逐字回声面同一方向):回声值
+ * **只做形状校验,不过脱敏器**(本车裁,与 [ref] / clay [ref] ② 的 `structuredOutput` 逐字回声面同一方向):回声值
  * 语义上是**不透明 id**(工单号 / join 键),脱敏器的值臂会把形似密钥的 id 改坏(`sk-…` 形的 id 整段成 `«redacted:key»`),
  * 而 id 被改坏 = 下游 join / 支持工单对不上;该防的是**形**(超长串撑爆终局体与日志、控制字符 / 终端转义序列改写
  * 显示、bidi / 非 ASCII 冒充),不是「里面像不像密钥」。
  *
- * 🔴 **形状与动作 = core 源头闸同一条规则**(S-889,主会话裁;core **#1204**,原排 7.34.1、随 7.35.0 到货,包根导出 `PROVIDER_ECHO_SHAPE` +
+ * 🔴 **形状与动作 = core 源头闸同一条规则**([ref],主会话裁;core **[ref]**,原排 7.34.1、随 7.35.0 到货,包根导出 `PROVIDER_ECHO_SHAPE` +
  * `isProviderEchoShape(value: string): boolean`,字母表采本仓提出的这一张):
  *  · **形内** = 字符串、长度 1–128、每个码元都是可见 ASCII(0x21–0x7E;空格、空串与一切控制 / 非 ASCII 码元都在外)⇒ 原样;
  *  · **越界**(含非串值)⇒ **缺席**(键删掉 / 不铸)+ 计数 `server.run-terminal.provider-echo-shaped`(detail 只带座位与原长 / 类型,
  *    **不带值**)。不截断、不带记号 —— 首版的「截成 127 + `…`」与 core 的「越界 ⇒ 缺席」是同一个键上两种处置,那一形 7.105.0 不发;
  *    截断记号、「截过的形是不动点」那套逻辑随之删除(规则变少)。缺席本来就是这几个键在 wire 上的一等状态(`apiFailure` 留下
  *    `{}` = 「provider 故障、无可补充标签」,core 契约原句),消费端不需要新读法。
- *  · `undefined` 与**空串** = 缺席本身(服务商什么都没说),不计数、不铸键 —— 空串一臂是 S-877 / core 7.35.0 #1204 的读法
+ *  · `undefined` 与**空串** = 缺席本身(服务商什么都没说),不计数、不铸键 —— 空串一臂是 [ref] / core 7.35.0 [ref] 的读法
  *    (`brain/errors.d.ts` 的 `providerEchoReading` 逐字「a non-string or the empty string states nothing (`absent` — no field,
  *    nothing counted)」;修前本仓把空串算越界计一次)。非串值本仓**照旧计数**:core 那句说的是 brain 读服务商原始响应,本口读的是
  *    持久行 / 非 core 的 Runner 给的形,一个非串的回声座是坏行,响亮([ref])。
- * ✅ 谓词 = core 包根导出的 `isProviderEchoShape`(S-877 起换调;本地那两行定义已删 —— 字母表同源,本仓不留第二份)。
+ * ✅ 谓词 = core 包根导出的 `isProviderEchoShape`([ref] 起换调;本地那两行定义已删 —— 字母表同源,本仓不留第二份)。
  * 🔴 **core 7.35.0 起 core 的 brain 在写侧先判一次**(`brain/stream-shared.js` `noteResponseModel` / `brain/errors.js`
  *    `readProviderRequestId`:越界 ⇒ 不写、run 里发 trace `brain.echo_dropped {field}`)⇒ 真 brain 链上越界值到不了本口,本口的
  *    计数只剩「不经 core brain 写侧」的 producer(存量行、宿主自己的 Brain / 自接 `sideQuery` 席)。
@@ -164,9 +164,9 @@ 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"` ∪ S-283 的
+/** {@link redactTerminalResult} 会碰的全部顶层键 = 现行形里**不是** `"verbatim"` 的行(`"redacted"` ∪ [ref] 的
  *  `"provider-echo"`)∪ 旧形平面键;`memoRedactTerminalResult` 的记忆键由它派生(两处同源,见 `RESULT_KEY_TREATMENT` 顶注)。
- *  🔴 S-283 起改名(原 `REDACTABLE_RESULT_LEAVES`):回声键不脱敏但**会被改**(越界 ⇒ 删键),漏进记忆键集 = 读面记忆腿对存量行
+ *  🔴 [ref] 起改名(原 `REDACTABLE_RESULT_LEAVES`):回声键不脱敏但**会被改**(越界 ⇒ 删键),漏进记忆键集 = 读面记忆腿对存量行
  *  O(1) 原样直返,读面纵深对那几片恒不生效([ref] 立案时 `editedFiles` 那一格的同一个病)。 */
 export declare const TREATED_RESULT_LEAVES: readonly string[];
 export declare function redactTerminalResult<T extends {
@@ -178,7 +178,7 @@ export declare function redactTerminalResult<T extends {
     remoteEnvFailures?: readonly {
         message?: string | undefined;
     }[] | undefined;
-    /** B-106:模型自由文本两叶 + 引擎披露散文一族。形上同样取 `unknown`(读面纪律,见下)。 */
+    /** [ref]:模型自由文本两叶 + 引擎披露散文一族。形上同样取 `unknown`(读面纪律,见下)。 */
     result?: unknown;
     salvagedOutput?: unknown;
     rewindNotes?: unknown;
@@ -186,19 +186,19 @@ export declare function redactTerminalResult<T extends {
      *  声明成 `{path,edits}[]` 会逼每一个喂坏形的调用点铸一次宽松断言 —— 而「坏形从哪来」正是本座要
      *  处理的事(同一份不信任在 `remoteEnvFailures` 的实现里也已成文)。运行期逐项判形,不抛。 */
     editedFiles?: unknown;
-    /** S-394:形上同样 `unknown` —— 本函数是读盘面,`stats` 的树形逐层现判(见 {@link redactStats})。 */
+    /** [ref]:形上同样 `unknown` —— 本函数是读盘面,`stats` 的树形逐层现判(见 {@link redactStats})。 */
     stats?: unknown;
-    /** S-283:provider 回声三键(形上 `unknown`,读盘面纪律同上;处置见 {@link PROVIDER_ECHO_SHAPERS})。 */
+    /** [ref]:provider 回声三键(形上 `unknown`,读盘面纪律同上;处置见 {@link PROVIDER_ECHO_SHAPERS})。 */
     apiFailure?: unknown;
     strandedHumanAnswers?: unknown;
     responseModel?: unknown;
 } | null | undefined>(result: T): T;
 /**
- * 🔴 **S-173 —— run 行 `result` 列的唯一入口**:先过出口封口({@link sealResultForExit}:摘恢复凭据 + 折域外码),
+ * 🔴 **[ref] —— run 行 `result` 列的唯一入口**:先过出口封口({@link sealResultForExit}:摘恢复凭据 + 折域外码),
  * 再过 {@link redactTerminalResult}。三家 run 店(SQL 两方言 / file / memory)的**三个**写口 —— `setTerminal` 与
  * park 两口 `setSuspended` / `setNeedsReview` —— 入口各调一次,列上的字节因此只有一条来路。
  *
- * 为什么封口也挪到店的入口(而不只靠调用方):S-173 之前这一列只收终局结果,而终局结果上凭据只可能藏在
+ * 为什么封口也挪到店的入口(而不只靠调用方):[ref] 之前这一列只收终局结果,而终局结果上凭据只可能藏在
  * `failed.nestedPause` 一处、且每个调用点都已先封口。park 两口收的是 **`paused` 因由** —— 那一臂按 core 的
  * 类型**必带** `token`(引擎内契约)。凭据挂在「每个调用点都记得先封口」上 = 漏一处就是一次凭据落盘、且
  * 不会红([ref] 安全轴:fail-closed,不是约定)。两件事都**幂等**(封过口的再封是同形、脱过的再脱是同一引用),
@@ -207,12 +207,12 @@ export declare function redactTerminalResult<T extends {
  * `null` 原样(= 这条腿没有结果可落:引擎没给终局就收流 / 断连竞态 park / 重开 re-park)。
  */
 export declare function sealRunRowResult(result: PersistedTaskResult | null): PersistedTaskResult | null;
-/** S-107(第五轮合并重扫 wf_f00c00bc 两根 [high]):同一个 `TaskResult` 除 run 行外还被逐字追加进 run_events 的 `done` 行
+/** [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`)与
  *  `failed.errorMessage`,其余事件类型/键逐字不动(它们各有自己的 sink 侧脱敏);形不合(非对象)原样返回,不抛。 */
 export declare function redactLedgerEventData(type: string, data: unknown): unknown;
-/** S-107 第三轮窄范围重扫 [high]×2:leader 面的三处原文座——①`WorkerReport.error`(生产路径经 `runWorker` 构造,`fanout.ts`
+/** [ref] 第三轮窄范围重扫 [high]×2:leader 面的三处原文座——①`WorkerReport.error`(生产路径经 `runWorker` 构造,`fanout.ts`
  *  的 runTaskStream 回退座不是生产座);②`LeaderResult.error`(plan/provision 失败带 `e.message`);③`merge.reason`
  *  (coordinator push 失败把 `git clone <带凭据的 durableRemote>` 命令行整段回显)。全部随 leader_run.result JSON 落库并经
  *  `GET /v1/leader/:id` 直出。修=**咽喉**:fanOut 边界对每份报告脱一次(不问谁产的),endpoint 落库前 + 读面各脱一次
@@ -250,13 +250,13 @@ export declare function redactLeaderResultWithFlag(result: unknown): {
     changed: boolean;
 };
 export declare function memoRedactedRead<T>(seat: string, raw: T, redact: (v: T) => T): T;
-/** run 终态 result 的读面记忆只按**本函数会改字节的那几叶**({@link TREATED_RESULT_LEAVES}:脱敏叶 ∪ S-283 回声叶 ∪ 旧形平面键,属主是
+/** run 终态 result 的读面记忆只按**本函数会改字节的那几叶**({@link TREATED_RESULT_LEAVES}:脱敏叶 ∪ [ref] 回声叶 ∪ 旧形平面键,属主是
  *  `RESULT_KEY_TREATMENT`)做键与留体——
  *  第十六轮重扫:按整块 result 摘要每次轮询要 stringify 一份可能数 MB 的 result,且大 result 的脏行永远存不进去。叶全缺席
  *  ⇒ O(1) 直返(`redactTerminalResult` 本就同引用)。
- *  🔴 S-136(core 7.6.0 D-8):新形把前两片搬进了 `terminal`(同属一个键,按它整只做叶更省);旧形的两片
+ *  🔴 [ref](core 7.6.0 D-8):新形把前两片搬进了 `terminal`(同属一个键,按它整只做叶更省);旧形的两片
  *  **照留**——盘上真有那样的行,而读面纵深正是为它们存在的(codex 对抗复审 r1 [high] 验真后补)。
- *  🔴 **B-106 起「叶全缺席」这条捷径实际上不再触发**(如实写明,不是漏改):`result` 在 core 类型上是
+ *  🔴 **[ref] 起「叶全缺席」这条捷径实际上不再触发**(如实写明,不是漏改):`result` 在 core 类型上是
  *  **必填**串,进了叶集就恒在场 ⇒ 每次读面都要对叶子做一次 sha256。代价是有意接受的,因为省下的那条
  *  捷径对**含自由文本的 run(即全部 run)**本来就不成立 —— 不把 `result` 放进叶集才是真的漏:
  *  `memoRedactTerminalResult` 会对它 O(1) 直返明文,读面纵深对这一叶恒不生效(这正是 [ref] 立案时
@@ -264,7 +264,7 @@ export declare function memoRedactedRead<T>(seat: string, raw: T, redact: (v: T)
  *  一次即进 clean 集,脏行超过 {@link READ_MEMO_DIRTY_MAX_ENTRY_BYTES} 时退化为每次重扫(既有形)。 */
 export declare function memoRedactTerminalResult<T extends Parameters<typeof redactTerminalResult>[0]>(seat: string, result: T): T;
 /**
- * 🔴 **账本行的读面口 —— 全部耐久读腿共用这一只**(S-269,7.105.0)。
+ * 🔴 **账本行的读面口 —— 全部耐久读腿共用这一只**([ref],7.105.0)。
  *
  * 脱敏的**属主**仍是 {@link redactLedgerEventData}(写读共用的唯一汇点,规则一张:哪些行型有自由文本座、怎么脱);
  * 本函数**不是第二只脱敏器**,只在汇点外面加一层**按型记忆**(读面每次轮询 / 每个观看者 / 每次重连都重放同一批
@@ -275,8 +275,8 @@ export declare function memoRedactTerminalResult<T extends Parameters<typeof red
  *
  * **三条耐久读腿同调**:`GET /v1/runs/:id/events`(账本裸回放)、`GET /v1/tasks/:id/turns`(`projectEvents`)、
  * trace SSE `GET /v1/tasks/:id/stream`(`mapTraceEvent`)。此前只有第一条在 `formatEvent` 里手写了这段分派,后两条
- * **直吃原行** —— 新行在三孪生 `appendEvent` 落库前已脱,所以只打在**存量行**上:7.75.1(B-106)之前 `text` 行的写口
- * 不脱,那批行在两条 trace 腿上原字节回放(S-269,车EC U-2)。分派收进本函数、三条腿同调 ⇒ 读面纵深一条规则。
+ * **直吃原行** —— 新行在三孪生 `appendEvent` 落库前已脱,所以只打在**存量行**上:7.75.1([ref])之前 `text` 行的写口
+ * 不脱,那批行在两条 trace 腿上原字节回放([ref],车EC U-2)。分派收进本函数、三条腿同调 ⇒ 读面纵深一条规则。
  *
  * **性能取舍(读实现后定)**:汇点对已脱行在**输出**上幂等(`redactModelText` 认不出凭据形就回同一引用),但**代价不是
  * 空过** —— 每次都整段重扫(`redactSecrets` 全池一遍)。所以读面走记忆:同一行第二次起只付一次 sha256 摘要 + 集合查找

package/dist/observability/secret-env-scrub.d.ts

@@ -14,7 +14,7 @@
  * ## 形(照 `fail-open.ts` 的仓内先例)
  *  1. **计数(逐次)** —— `secret_env_scrubbed_total{site,kind,confidence}`;
  *  2. **结构化披露(每 site×key 一次)** —— 首次在某条腿上丢掉某个 key 时一条 `info`,之后同 key 只走计数。
- *     有部署级出路的现场(S-699:`server.lsp.spawn-env`;7.103.0 起 + `server.bake-runner.spawn-env`)升 `warn`,并带当前放行名单与出路句
+ *     有部署级出路的现场([ref]:`server.lsp.spawn-env`;7.103.0 起 + `server.bake-runner.spawn-env`)升 `warn`,并带当前放行名单与出路句
  *     —— 规则见 `SecretEnvScrubSiteSpec`。
  *     不是「每 site 一次」:一个**新**的密钥形 key 后来才出现(部署加了一个凭证)时,那才是最该看见的一行。
  *  findings 全部是 core 的 `SecretEnvFinding`(7.129.0 / core 7.51.1 起只有引擎一只写手,经 `server-secret-env.ts` 的唯一组合):形状臂的五词
@@ -38,7 +38,7 @@ import type { Metrics } from "./metrics.js";
 /**
  * 一个剥除现场的登记:`note` = 这条腿上泄漏意味着什么;`remedy` = 部署方能不能自己把某个被剥的键放回来。
  *
- * 🔴 S-699:`remedy` 在场与否决定披露行的**级别**,规则一句 —— **有出路的现场用 warn,并把出路句与当前放行名单写进同一行**;
+ * 🔴 [ref]:`remedy` 在场与否决定披露行的**级别**,规则一句 —— **有出路的现场用 warn,并把出路句与当前放行名单写进同一行**;
  * 没有出路的现场是纯保护留痕,照旧 info。理由:没有出路的剥除(模型可驱动的 shell、git 钩子)是本服务替部署方做的决定,
  * 读者只需要知道它生效了;有出路的剥除(语言服务器)可能让一件功能静默变差(补全 / 诊断缺了私有 registry 的依赖),
  * 那是部署方要自己决定的事 —— 看不见 = 无从归因。出路句不带任何值。
@@ -96,7 +96,7 @@ interface Sink {
  * 记一次剥除。**总不抛** —— 观测本身绝不能变成故障(同 `recordFailOpen` / reapers 的判据)。
  * `findings` 为空(这一次没丢任何 key)时什么也不做:那不是事件,是常态。
  * `findings` 只许装**没有按原样交给子进程**的键(剥掉 / 换成 core 占位半条)—— 点名放回的键取回源值,不是剥除(不计数、不披露)。
- * `allowed` = 这一次生效的点名放行名单(S-699),只在有出路的现场(`remedy` 在场)写进披露行;没有放行面的腿传 `[]`。
+ * `allowed` = 这一次生效的点名放行名单([ref]),只在有出路的现场(`remedy` 在场)写进披露行;没有放行面的腿传 `[]`。
  */
 export declare function recordSecretEnvScrub(site: SecretEnvScrubSite, findings: readonly SecretEnvFinding[], allowed: readonly string[]): void;
 /** 装配层把 logger/metrics 接上(main.ts,与 `installFailOpenRecorder` 同一处)。装配前累计的次数在此补进 metrics。 */

package/dist/observability/tool-trace.d.ts

@@ -17,7 +17,7 @@ export declare const TOOL_TRACE_REGISTRATION = "server.tool-trace";
  * 🔴 BREAKING(server 7.64.0,core 7.6.0 提货):标签名 `source` → `deniedBy`,词表从七词
  * (`policy/hook/safety/shellGate/planMode/classifier/org`)换成八词
  * (`policy/hook/org/classifier/plan_mode/compliance/write_protection/ask_resolution`)。仪表盘/告警规则要改。
- * 🔁 server 7.106.0(S-877 / core 7.34.0 [ref]):`plan_mode` 这个词退役,换成 `mode`(模式自己拒的那一形:`dontAsk` 拒每一只非授权 ask、
+ * 🔁 server 7.106.0([ref] / core 7.34.0 [ref]):`plan_mode` 这个词退役,换成 `mode`(模式自己拒的那一形:`dontAsk` 拒每一只非授权 ask、
  *    `bypassPermissions` 拒判不出保护的写)—— 标签值原样取 core 的 `isDeniedBy`,按 `deniedBy="plan_mode"` 写的告警规则改 `mode`。
  *
  * 🔴 **第二个计数器 `auto_mode_classifier_deny_cause_total{cause}`(server 7.70.0 生为

package/dist/operator-ask.d.ts

@@ -48,7 +48,7 @@ export type OperatorAskResult = Extract<PermissionResult, {
  */
 export declare function operatorAsk(rule: string, message: string): OperatorAskResult;
 /**
- * 🔴 **S-877 候裁 16 —— 运维声明的「恒问人」**(`APPROVAL_NEVER_AUTO` 的「always human」、耐久资源预算耗尽的「human approval required」):
+ * 🔴 **[ref] 候裁 16 —— 运维声明的「恒问人」**(`APPROVAL_NEVER_AUTO` 的「always human」、耐久资源预算耗尽的「human approval required」):
  * 在 {@link operatorAsk} 之上再盖部署出身 `authoredBy: "deployment"` ⇒ core 类读 `operator_forced`(`ruleClearanceOf`:
  * 「a deployment-authored ask」进强制门 ⇒ `mandated`)—— bypassPermissions 放不掉、**任何**站着的答案(持久规则、会话授权,
  * 任何 scope)退不掉,只有**这一次**的应答能答它。
@@ -67,7 +67,7 @@ export declare function operatorAsk(rule: string, message: string): OperatorAskR
  */
 export declare function operatorAlwaysHumanAsk(rule: string, message: string): OperatorAskResult;
 /**
- * 🔴 **S-1351 —— 请求写下的「恒问人」**(`settings.permissions.neverAuto`):在 {@link operatorAsk} 之上再盖 `requiresRealApproval: true`(core 的治理位 ——
+ * 🔴 **[ref] —— 请求写下的「恒问人」**(`settings.permissions.neverAuto`):在 {@link operatorAsk} 之上再盖 `requiresRealApproval: true`(core 的治理位 ——
  * 「只有判断能清它」:空白的 `onAsk: "allow"`、任何站着的答案(持久规则、会话授权)、auto 分类器都清不掉,只有**这一次**的真人应答能答),不盖部署出身。
  *
  * 为什么不盖 `authoredBy: "deployment"`:出身位说的是「部署自己的治理层写的」,请求里的声明不是部署写的 —— 盖了就是在审计面冒名。`requiresRealApproval` 是 core 明文开给
@@ -77,13 +77,13 @@ export declare function operatorAlwaysHumanAsk(rule: string, message: string): O
  */
 export declare function requestAlwaysHumanAsk(rule: string, message: string): OperatorAskResult;
 /**
- * 🔴 **S-958 —— 治理层的叶策略包装**:`leaf` 产的每一只 ask 盖部署出身(经 {@link withDeploymentAuthorship}),allow / deny 原物交回;
+ * 🔴 **[ref] —— 治理层的叶策略包装**:`leaf` 产的每一只 ask 盖部署出身(经 {@link withDeploymentAuthorship}),allow / deny 原物交回;
  * 成员(`projection` / `pathRules` / `writeTargetGuard` / `nameSets`)经 core `wrapToolPolicy` 随行(契约「包装至少拒内层所拒」:
  * 只加一位、从不放宽)。同步叶保持同步返回;叶抛照抛(fail-closed 的属主仍是叶)。
  *
  * **只收叶**:治理层(`runtime-governance.ts` `applyRuntimeGovernance`)对每一片叶各盖一次,再交 core `combinePolicies` 折**一次**
  * (折叠是最外层,其输出原样交回 —— core 把落选 ask 的类(含本位带出的 `operator_forced`)写进 `foldedAskClasses` 并担保那只对象)。
- * 把一只折叠交给本函数 = 在折叠的输出上展开 —— 那正是 S-958 修掉的病(7.39.0 起按名拒,响亮、fail-closed,不是静默)。
+ * 把一只折叠交给本函数 = 在折叠的输出上展开 —— 那正是 [ref] 修掉的病(7.39.0 起按名拒,响亮、fail-closed,不是静默)。
  */
 export declare function createDeploymentAuthoredPolicy(leaf: ToolPolicy): ToolPolicy;
 //# sourceMappingURL=operator-ask.d.ts.map

package/dist/orchestration/workflow-agent-session-index.d.ts

@@ -24,7 +24,7 @@ export interface WorkflowAgentSessionIndex {
     listByAgentSession(sessionId: string): Promise<WorkflowAgentSessionRow[]>;
 }
 /**
- * 🔴 **park 身份的单一真源**(core 7.17.0 [ref];持有者两成员 core 7.44.0 #1319)—— 引擎写在记录上的 `parks[]` 的元素形。
+ * 🔴 **park 身份的单一真源**(core 7.17.0 [ref];持有者两成员 core 7.44.0 [ref])—— 引擎写在记录上的 `parks[]` 的元素形。
  *
  * 型从 core 的那一位取、不在本仓复述:core 往元素上加一位 ⇒ `trace/core-keyset-guard.ts` 的 ⑬b 成员门与下面那只读者的构造式**同时**红。
  */
@@ -45,7 +45,7 @@ export type WorkflowRunParkKey = NonNullable<WorkflowRun["parks"]>[number];
  */
 export declare function readRunParks(run: unknown): WorkflowRunParkKey[] | undefined;
 /**
- * 🔴 **「这条记录的 run 持有这条停驻」的唯一读法**(core 7.44.0 #1319 逐字):`entry.parkedBy === record.id`。
+ * 🔴 **「这条记录的 run 持有这条停驻」的唯一读法**(core 7.44.0 [ref] 逐字):`entry.parkedBy === record.id`。
  * 继承来、本跑还没走到的条目带上一跑的 id;旧引擎写的条目两成员皆无 —— 两者都不是本记录持有的。
  */
 export declare function heldParksOf(recordId: string, parks: readonly WorkflowRunParkKey[]): WorkflowRunParkKey[];
@@ -126,7 +126,7 @@ export declare function readAgentSessionLedgerLine(v: unknown): WorkflowAgentSes
  *
  * 账本的一行 = **一条 run 当时的整份指针集**(按 runId 后写覆盖;指针只增不删 ⇒ 后一行恒是前一行的超集),所以重放即收敛,不需要压缩腿。
  *
- * 追加 / 重放走本仓 JSONL 店的**共用口**(S-977;此前 ctor 里自写 `truncateTornTail` + 手写 `split("\n") + JSON.parse` 重放):
+ * 追加 / 重放走本仓 JSONL 店的**共用口**([ref];此前 ctor 里自写 `truncateTornTail` + 手写 `split("\n") + JSON.parse` 重放):
  * 追加 = core `AppendLog`(惰性打开、撕尾在**打开与每次追加前**修 —— 修前只在 boot 修,运行期半写后的下一次成功写仍会被粘进残尾),
  * 重放 = `replayJsonlSkipping`(登记座 `workflow-agent-session-index`:中间坏行 —— 含半截 JSON 与形不对的整行 —— 跳过 + 逐条披露 + F tag;
  * 撕尾不计、不披露)。盘上字节 / 0o600 账本 / 0o700 目录与修前逐字同,升级零迁移:一行仍是「这条 run 的指针集」,旧账本行就是旧记录的指针

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

@@ -17,8 +17,10 @@ export interface WorkflowCompletionInboxEntry {
      *  originating leg was IDLE (core's in-process injection had no harness to steer — the durable half
      *  is the deployment's job). `runId` then holds the core task_id (disjoint id spaces). */
     kind?: "workflow_complete" | "task_notification";
-    /** The task_notification extras (JSON: {task_type, toolUseId?, result?, output_file?}) — bounded +
-     *  redacted AT ENQUEUE (the store carries only egress-safe bytes). Absent on workflow_complete entries. */
+    /** The per-kind extras as a JSON text — bounded + redacted AT ENQUEUE (the store carries only egress-safe bytes).
+     *  `task_notification`: {task_type, toolUseId?, result?, output_file?, …}. `workflow_complete`: at most `{"completionId": …}`
+     *  (see {@link buildWorkflowCompleteInboxEntry}; absent when the engine minted none). The SQL stores' existing `payload`
+     *  column carries it verbatim for both kinds — no DDL. */
     payload?: string;
 }
 /** Session-keyed queue of finished-workflow completions awaiting a push to the originating session.
@@ -96,12 +98,12 @@ export declare function taskNotificationFoldKey(n: {
  *  型取 core 载荷的那五位(`Partial`:帧上任一位都可能缺,缺了就不成键,见 {@link taskNotificationStreamKeyOf})。 */
 export type TaskNotificationKeyFields = Partial<Pick<TaskNotificationPayload, "task_type" | "task_id" | "status" | "seq" | "attempt">>;
 /**
- * **唯一**从一帧上读键字段的地方(S-616 按类修):此前七个调用点各自手抄 `{ task_type, task_id, status, seq }` 四字段投影,
+ * **唯一**从一帧上读键字段的地方([ref] 按类修):此前七个调用点各自手抄 `{ task_type, task_id, status, seq }` 四字段投影,
  * core 给帧身份加一个分量(本版的 `attempt`)时,每一处手抄都得有人记得补 —— 漏一处就是那一腿的重供帧被吞。现在调用点
  * 把整只帧交过来,键字段只在这里读。
  *
  * 🔴 **键 = core `taskNotificationDedupKey` 的输出**(NP-6,7.100.0 合并复审 [ref] 交叉表 #8,opus A3;[ref]):本仓流侧键此前
- * 是 core 那只注入去重键的手抄孪生(`域:id:status[#seq]`),S-616 又逐字抄了它的 `:a<attempt>` 尾 —— core 改一次键规则,
+ * 是 core 那只注入去重键的手抄孪生(`域:id:status[#seq]`),[ref] 又逐字抄了它的 `:a<attempt>` 尾 —— core 改一次键规则,
  * 这里就得有人记得跟。键只活在进程内(每腿 {@link NotifiedKeys},不落盘、不上 wire),换成 core 的输出零迁移面。
  * core 那只键同样按车道分域(external 车道 `external:<id>`,其余裸 id —— codex F2 的「external 帧不许与内部帧撞键」照旧成立)、
  * status 保 RAW、`seq` 折入、`attempt` 缺席 / 1 时字节不变。调用点手里已有 core 载荷的(observer 臂)直接调 core 函数。
@@ -198,6 +200,19 @@ export declare class FileWorkflowCompletionInbox extends InMemoryWorkflowComplet
     /** Close the ledger fd (shutdown). */
     close(): void;
 }
+/**
+ * 一次 workflow 完成 → 入箱条目(`workflow_complete` 家族;启动期投递闭包的**唯一**构造点)。`summary` 在 core 的 notifier seam 上已脱敏 + 限长,这里原样入箱;
+ * `completionId`(引擎铸,`WorkflowCompletionPayload` 上在场 iff 引擎给了)逐字落进 `payload` 列 —— 同一次完成的补投帧与 live 帧同一个相关 id,本服务零自铸。
+ */
+export declare function buildWorkflowCompleteInboxEntry(route: {
+    sessionId: string;
+    owner: string | null;
+}, p: {
+    runId: string;
+    status: "completed" | "failed";
+    summary: string;
+    completionId?: string;
+}, enqueuedAt: number): WorkflowCompletionInboxEntry;
 /**
  * P1 ①② delivery half, TWO-PHASE since 1.80: read the session's pending completions, emit
  * one `workflow_complete` out-of-band frame per entry, and `ack` (remove) each entry only AFTER its emit
@@ -270,7 +285,7 @@ export type EngineNotificationParkInput = ParkedNotificationFields & {
         body: string;
     };
     _sema_provenance?: SemaProvenanceInput;
-    /** S-616(core 7.30.0 [ref] S1 / #1034 / #1036):委派终态帧三枚 facet + 重供两键 —— 判据与 live 腿同一只
+    /** [ref](core 7.30.0 [ref] S1 / [ref] / [ref]):委派终态帧三枚 facet + 重供两键 —— 判据与 live 腿同一只
      *  (`trace/task-notification-facets.ts`,入参按 `unknown` 收、判过形才成 typed)。 */
     spawnName?: string;
     handback?: string;

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

@@ -264,6 +264,33 @@ export class FileWorkflowCompletionInbox extends InMemoryWorkflowCompletionInbox
         }
     }
 }
+function readEntryExtras(payload) {
+    let extras = {};
+    try {
+        extras = payload ? JSON.parse(payload) : {};
+    }
+    catch {
+    }
+    return typeof extras === "object" && extras !== null && !Array.isArray(extras) ? extras : {};
+}
+function encodeWorkflowCompleteExtras(completionId) {
+    return completionId ? { payload: JSON.stringify({ completionId }) } : {};
+}
+function workflowCompleteFrameExtras(payload) {
+    const id = readEntryExtras(payload).completionId;
+    return typeof id === "string" && id !== "" ? { completionId: id } : {};
+}
+export function buildWorkflowCompleteInboxEntry(route, p, enqueuedAt) {
+    return {
+        sessionId: route.sessionId,
+        owner: route.owner,
+        runId: p.runId,
+        status: p.status,
+        summary: p.summary,
+        enqueuedAt,
+        ...encodeWorkflowCompleteExtras(p.completionId),
+    };
+}
 export async function emitPendingWorkflowCompletions(inbox, sessionId, callerPrincipal, emit, diag) {
     if (!inbox || !sessionId)
         return;
@@ -289,16 +316,11 @@ export async function emitPendingWorkflowCompletions(inbox, sessionId, callerPri
                 continue;
             }
             if (e.kind === "task_notification") {
-                let extras = {};
-                try {
-                    extras = e.payload ? JSON.parse(e.payload) : {};
-                }
-                catch {
-                }
+                const extras = readEntryExtras(e.payload);
                 await emit({ type: "task_notification", task_id: e.runId, status: e.status, summary: e.summary, ...extras, injected: false });
             }
             else {
-                await emit({ type: "workflow_complete", runId: e.runId, status: e.status, summary: e.summary });
+                await emit({ type: "workflow_complete", runId: e.runId, status: e.status, summary: e.summary, ...workflowCompleteFrameExtras(e.payload) });
             }
             await inbox.ack(sessionId, e.runId);
             dlog("workflow_complete_emitted", {

package/dist/orchestration/workflow-notify-journal.d.ts

@@ -1,21 +1,44 @@
-import { type WorkflowRun, type WorkflowRunStore, type WorkflowRunStatus, type WorkflowRunSummary } from "@sema-agent/core";
+import { type WorkflowCompletionNotifier, type WorkflowRun, type WorkflowRunStore, type WorkflowRunStatus, type WorkflowRunSummary } from "@sema-agent/core";
 import { type FleetEventBus } from "../fleet/fleet-bus.js";
 import { type WorkflowAgentSessionIndex } from "./workflow-agent-session-index.js";
-/** A workflow completion notification's terminal payload — the bounded, redacted shape core's notifier seam
- *  carries, re-derivable from a durable {@link import("@sema-agent/core").WorkflowRun} on the recovery path. */
-export interface WorkflowCompletionPayload {
-    runId: string;
-    status: "completed" | "failed";
-    /** Redacted + length-bounded — never host-internal paths/tokens (parity with core's `boundedSummary`). */
-    summary: string;
-    sourceTaskId?: string;
-    principal?: string;
-    /** core 1.208: the ORIGINATING session id, closed over by the Runner at RunWorkflow mount time —
-     *  the lookup-free routing key for the completion inbox. Present on the LIVE notify path; ABSENT on the
-     *  crash-recovery path (the durable `WorkflowRun` does not carry it — relayed to core to thread it there too,
-     *  parity with `sourceTaskId`'s 1.187 story), where the delivery falls back to the `sourceTaskId` run-row lookup. */
-    originatingSessionId?: string;
-}
+/**
+ * core 的 notify seam 递来的**每一个键**在这条通知链上的处置 —— 载荷型 {@link WorkflowCompletionPayload} 的**唯一来源**(不再手抄 core 入参型的子集)。
+ * core 给 `WorkflowCompletionNotifier.notify` 的入参加一个键 ⇒ 这里编译红(缺一行),逼人对「它上不上这条链」表态;core 删 / 改名一个键 ⇒ 同样红(多一行)。
+ *  · `carry`:搬运到投递(journal 门 → 收件箱 → `workflow_complete` 帧 / 账本行)。`runId` / `status` / `summary` 必带;其余可选键引擎没给(或空串)⇒ 载荷上缺席。
+ *    `completionId` = 引擎的一次完成的相关 id(fill-once,终态转换上铸):逐字、不脱敏、本服务零自铸。
+ *  · `drop`:这条持久链只搬运一句受限摘要 + 路由键 —— `task_id` / `task_type` / `toolUseId` 是 live `task_notification` 帧的键(那条路径自带),`result` / `usage` /
+ *    `diagnostics` 是完整结果 / 计量 / 诊断路由(终态轮询 `TaskOutput` / `WorkflowStatus` 读得到),不进补投帧。
+ * 键名直呼 core 的入参型(型文本里就有 core 名)⇒ 读表的 literals 段收得到这些键。
+ */
+export declare const WORKFLOW_NOTIFY_KEY_DISPOSITION: {
+    readonly runId: "carry";
+    readonly status: "carry";
+    readonly summary: "carry";
+    readonly sourceTaskId: "carry";
+    readonly principal: "carry";
+    readonly originatingSessionId: "carry";
+    readonly completionId: "carry";
+    readonly task_id: "drop";
+    readonly task_type: "drop";
+    readonly toolUseId: "drop";
+    readonly result: "drop";
+    readonly usage: "drop";
+    readonly diagnostics: "drop";
+};
+type NotifyKeyDisposition = typeof WORKFLOW_NOTIFY_KEY_DISPOSITION;
+/** 处置表里 `carry` 的键。 */
+export type WorkflowNotifyCarriedKey = {
+    [K in keyof NotifyKeyDisposition]: NotifyKeyDisposition[K] extends "carry" ? K : never;
+}[keyof NotifyKeyDisposition];
+/**
+ * A workflow completion notification's terminal payload — the bounded, redacted shape core's notifier seam carries,
+ * re-derivable from a durable {@link import("@sema-agent/core").WorkflowRun} on the recovery path.
+ *
+ * **派生型,不是手抄子集**:core `WorkflowCompletionNotifier["notify"]` 入参型按 {@link WORKFLOW_NOTIFY_KEY_DISPOSITION} 里 `carry` 的键挑出来。
+ * 键的语义随键住在 core 的入参型上(`summary` 受限 + 脱敏;`originatingSessionId` = Runner 在挂 RunWorkflow 时闭包的发起会话 id,live 路径在、崩溃恢复路径读
+ * `WorkflowRun` 行上同名键;`completionId` 见处置表)—— 这里不再复述一份会漂的注释。
+ */
+export type WorkflowCompletionPayload = Pick<Parameters<WorkflowCompletionNotifier["notify"]>[0], WorkflowNotifyCarriedKey>;
 /** The downstream delivery the journal guards (the deployment's real completion route — log+meter today, a full
  *  re-invoke into the originator's stream/inbox tomorrow). Idempotent on `runId` by contract; the journal still
  *  de-dups so it is invoked AT MOST once per run in steady state and at most one extra time across a crash. */
@@ -201,7 +224,7 @@ export declare class WorkflowNotifyGate {
  * appends, atomic single-line records. Single-instance / TOC-local: a cross-replica TiDB/PG port is a follow-on
  * (the recovery sweep + gate are backend-agnostic).
  *
- * 追加 / 重放走本仓 JSONL 店的**共用口**(S-977;此前是第二 / 第三份私有实现):追加 = core `AppendLog`(惰性打开;单条 `writeSync`
+ * 追加 / 重放走本仓 JSONL 店的**共用口**([ref];此前是第二 / 第三份私有实现):追加 = core `AppendLog`(惰性打开;单条 `writeSync`
  * 循环写满、失败的写截回开写处;**撕尾在打开与每次追加前修**,所以崩在一次 append 中途之后的下一条成功写不会被粘进残尾),
  * 重放 = `replayJsonlSkipping`(登记座 `workflow-notify-journal`:中间坏行跳过 + 逐条披露 + F tag;撕尾不计 —— 它是崩溃的正常落盘形;
  * 末行 JSON 完整但缺换行的认下、下一次追加补换行)。盘上字节 / 0o600 账本 / 0o700 目录与修前逐字同,升级零迁移。
@@ -274,7 +297,7 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     /** MF-Fleet (data contract): publish the workflow's fleet row on every put/update (the same write-observation
      *  point as the notify journal). Optional — undefined ⇒ no fleet publish. */
     private readonly fleetBus?;
-    /** S-185 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
+    /** [ref] 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
     private readonly agentSessionIndex?;
@@ -287,7 +310,7 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     /** MF-Fleet (data contract): publish the workflow's fleet row on every put/update (the same write-observation
      *  point as the notify journal). Optional — undefined ⇒ no fleet publish. */
     fleetBus?: FleetEventBus | undefined, 
-    /** S-185 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
+    /** [ref] 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
     agentSessionIndex?: WorkflowAgentSessionIndex | undefined);
@@ -328,4 +351,5 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
         keep?: number;
     }): Promise<number>;
 }
+export {};
 //# sourceMappingURL=workflow-notify-journal.d.ts.map

package/dist/orchestration/workflow-notify-journal.js

@@ -5,6 +5,21 @@ import { isTerminalWorkflowRowStatus, seedTerminalWorkflowRow } from "../fleet/f
 import { buildParkSessionRows } from "./workflow-agent-session-index.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
+export const WORKFLOW_NOTIFY_KEY_DISPOSITION = {
+    runId: "carry",
+    status: "carry",
+    summary: "carry",
+    sourceTaskId: "carry",
+    principal: "carry",
+    originatingSessionId: "carry",
+    completionId: "carry",
+    task_id: "drop",
+    task_type: "drop",
+    toolUseId: "drop",
+    result: "drop",
+    usage: "drop",
+    diagnostics: "drop",
+};
 const SUMMARY_MAX = 500;
 export function recoverySummary(status, error) {
     if (status === "completed")
@@ -65,6 +80,7 @@ export class WorkflowNotifyGate {
                     ...(input.sourceTaskId ? { sourceTaskId: input.sourceTaskId } : {}),
                     ...(input.principal ? { principal: input.principal } : {}),
                     ...(input.originatingSessionId ? { originatingSessionId: input.originatingSessionId } : {}),
+                    ...(input.completionId ? { completionId: input.completionId } : {}),
                 }, input.scope ?? input.principal ?? "default");
             },
         };
@@ -151,6 +167,7 @@ export class WorkflowNotifyGate {
                     ...(sourceTaskId ? { sourceTaskId } : {}),
                     ...(principal ? { principal } : {}),
                     ...(originatingSessionId ? { originatingSessionId } : {}),
+                    ...(run.completionId ? { completionId: run.completionId } : {}),
                 }, entry.scope);
                 const after = await this.journal.get(entry.runId);
                 if (after?.acked)