@sema-agent/server 7.142.0 → 7.144.0

package/dist/trace/exit-seat.d.ts

@@ -19,12 +19,15 @@ export type SafeText = string & {
  *    的 `reason` / `status.error` / `listingIncomplete.error`;引擎铸点已抹过请求回显与同主体词表(记号 `[redacted]`),这一行读同一个脱敏器(引擎记号 = 已抹的值,
  *    引擎放过的形照抹);界 200 码元,原样出门(JSON 串值,消费方自己渲染)。
  *  · `peer-declaration-sentence`:引擎判官对一份 MCP / A2A 对端声明说的句子(`toolAxes` / `toolFaces` / `sessionMetaKey` / 启动界的原因句,逐字带着声明方写的工具名、键名),
- *    进请求面 400 拒句、续跑重放的丢弃行与重读行、名册的跳过行 —— 读者是调用方与运维,句子已是一行;不设界(拒句要说全判官的话),原样出门。
+ *    进请求面 400 拒句、续跑重放的丢弃行与重读行、名册的跳过行,以及能力读面 `GET /v1/capabilities/mcp` 上引擎整集拒(两台撞同一工具命名空间前缀)的拒句 —— 读者是调用方与运维,句子已是一行;不设界(拒句要说全判官的话),原样出门。
  *  · `inbox-diagnostics-text`:`workflow_complete` 补投帧上的诊断教学文本(`diagnostics`)—— 引擎在 workflow 完成通知上铸的「读哪里 / 怎么续跑」文本,入会话收件时洗一次,
  *    店里(`payload` 列)只放出门安全的字节,drain 逐字带出。洗法与 live `task_notification.diagnostics` 同一个 scope(`free-text`);
  *    这一行比 `trace-frame-text` 多一条界(4000 码元,与同族条目的文本位同额),原样出门:`payload` 列是 TEXT,无界的文本一旦超过列宽,入箱写整条失败、补投连摘要一起丢(完成已被记作送达),所以先有界。
  *  · `boot-refusal-line`:起服拒启的一行拒句 —— 部署座装配的拒句(`mods-declaration.ts`:声明的席名、包名、读包者 / 引擎准入交回的话);它经进程级 fatal 出口原样多行进 stderr,
  *    所以必须在这里先压成一行(一句拒因里的换行会在运维的终端里伪造出第二条日志行);界 512 码元(含截断记号)。
+ *  · `peer-inbound-card-text`:运维审批队列 `peer_inbound` 行(`GET /v1/approvals` 的 `pending[]` 与 `/v1/approvals/stream` 的 `pending` 帧)上被扣跨会话来信的
+ *    存储正文(`content`,core 的规范存储形 `[summary] message`)与发信方显示名(`fromName`)—— 别的会话写的自由文本,读者是收信方本人;不设界(core 存的那一份就是
+ *    收信方要审的全文,截了就审不全),原样出门(JSON 串值,消费方自己渲染)。
  */
 declare const EXIT_SEATS: {
     readonly "trace-frame-text": {
@@ -75,6 +78,9 @@ declare const EXIT_SEATS: {
         readonly maxChars: 512;
         readonly emit: "log-line";
     };
+    readonly "peer-inbound-card-text": {
+        readonly scope: "free-text";
+    };
 };
 export type ExitSeat = keyof typeof EXIT_SEATS;
 /** 设了界的座名。 */

package/dist/trace/exit-seat.js

@@ -16,6 +16,7 @@ const EXIT_SEATS = {
     "peer-declaration-sentence": { scope: "free-text" },
     "inbox-diagnostics-text": { scope: "free-text", maxChars: 4000 },
     "boot-refusal-line": { scope: "free-text", maxChars: 512, emit: "log-line" },
+    "peer-inbound-card-text": { scope: "free-text" },
 };
 export function seatMaxChars(seat) {
     return EXIT_SEATS[seat].maxChars;

package/dist/trace/ledger-sink.d.ts

@@ -152,8 +152,8 @@ export declare function createLedgerSink(opts: {
      *  各传自己看得见的那个词(位①=流事件 `ev.type`,位②=账本行 `type`);拿不到类型的打点方
      *  (core 的 onActivity 第五席、resume 腿手动打点)省参,`kind` 诚实缺席(见 turn-activity.ts)。 */
     onActivity?: (kind?: string, statusData?: Record<string, unknown>) => void;
-    /** 这条腿的 `wiring_manifest` **本仓自铸段**(`LegWiringSections`:[ref] `instructions` 读腿的 `InstructionSelectionLeg.segment`、run 级 `skills` 读 spec 字段
-     *  `runSkillsOf`)。**必填**:账本行与 live 帧是同一条腿的两个载体,段必须来自同一只腿;在投帧那一刻读(core 推帧之前已 await 过 loader)。 */
+    /** 这条腿的 `wiring_manifest` **本仓自铸段**(`LegWiringSections`:[ref] `instructions` 读腿的 `InstructionSelectionLeg.segment`、run 级 `skills` 读这条腿的部署事实
+     *  `LegFacts.skills`,`leg-facts.ts`)。**必填**:账本行与 live 帧是同一条腿的两个载体,段必须来自同一只腿;在投帧那一刻读(core 推帧之前已 await 过 loader)。 */
     legSections: () => LegWiringSections;
     /** 这条腿的计量席(E8 累加器 + 归因键)。在场 ⇒ {@link LedgerSink.appendParked} 在停驻行之前先把未结清的用量差落成 `model_usage` 行(状态帧最后,见 `appendParkRow`);
      *  缺席 ⇒ 这条腿没接累加器,停驻行之前无账可结(夹具、不经 `appendParked` 停驻的腿)。 */

package/dist/trace/ledger-sink.js

@@ -4,7 +4,7 @@ import { recordFailOpen } from "../observability/fail-open.js";
 import { modelTextEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestEventData, toolRosterDeltaEventData, toolDisclosureEventData, humanInputEventData, turnEndEventData, contextUsageEventData, appendParkRow } from "./project.js";
 import { NotifiedKeys, taskNotificationStreamKeyOf } from "../orchestration/workflow-completion-inbox.js";
 import { isParkLedgerEventType } from "./ledger-events.js";
-import { isModelSegmentBoundary, reasoningDeltaBytes, reasoningSegmentEventId } from "./model-segment.js";
+import { blockText, isModelSegmentBoundary, reasoningDeltaBytes, reasoningSegmentEventId } from "./model-segment.js";
 export function createSerialLedgerAppend(appendEvent, startSeq) {
     let seq = startSeq;
     let chain = Promise.resolve();
@@ -33,6 +33,7 @@ export function createLedgerSink(opts) {
     let seq = 0;
     let chain = Promise.resolve();
     let text = "";
+    let block = "";
     let reasoning = "";
     let textEventId;
     let reasoningEventId;
@@ -55,9 +56,11 @@ export function createLedgerSink(opts) {
             reasoning = "";
             reasoningEventId = undefined;
         }
-        if (text) {
-            await append("text", modelTextEventData({ text, eventId: textEventId }));
+        const segment = text + blockText(block);
+        if (segment) {
+            await append("text", modelTextEventData({ text: segment, eventId: textEventId }));
             text = "";
+            block = "";
         }
     };
     const onEvent = async (ev) => {
@@ -67,10 +70,15 @@ export function createLedgerSink(opts) {
         switch (ev.type) {
             case "text_delta": {
                 const td = ev;
-                text += td.delta;
+                block += td.delta;
                 textEventId ??= td.eventId;
                 break;
             }
+            case "text_end": {
+                text += blockText(block, ev);
+                block = "";
+                break;
+            }
             case "reasoning_delta": {
                 const rd = ev;
                 const bytes = reasoningDeltaBytes(rd);

package/dist/trace/model-segment.d.ts

@@ -1,4 +1,4 @@
-import { type SegmentEndFields } from "./project.js";
+import { type LiveEventIdentity, type SegmentEndFields } from "./project.js";
 /**
  * 本帧是不是模型文本的段界。**四条消费腿共用这一只**:账本投影 switch(`trace/ledger-sink.ts`)、
  * 顶层 live 流与转发子代腿(`http/routes/tasks.ts`)、子代 tail 面(`fleet/subagent-tail-bus.ts`)。
@@ -13,43 +13,83 @@ export type ReasoningEndFrame = SegmentEndFields & {
     type: "reasoning_end";
 };
 /** 登记册**读到的全部字段**,逐个写出来(不是 `Record<string, unknown>`):`TaskEvent` 与转发腿的原始帧
- *  都结构性满足它,于是调用点一个宽断言都不必写;将来有人想读第七个键,得先在这里加一行。 */
-export interface ReasoningStreamEvent {
+ *  都结构性满足它,于是调用点一个宽断言都不必写;将来有人想读第八个键,得先在这里加一行。
+ *  `type` 而不是 `interface`(与 `LiveEventIdentity` 同一条理由):`text_end` 的铸点收 `Record<string, unknown>`,别名才进得去。 */
+export type ModelStreamEvent = {
     type?: string;
     delta?: unknown;
+    content?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
     sourceTaskId?: unknown;
     bgAgentId?: unknown;
-}
+};
 /** 一条**流**的身份(不含 `eventId`:core 给每个内容事件铸各自的 eventId,拿它当流身份会把每块 delta
  *  切成一段)。三键都缺席 = 宿主自己的流。 */
-export interface ReasoningStreamIdent {
+export interface ModelStreamIdent {
     parentToolCallId?: string;
     sourceTaskId?: string;
     bgAgentId?: string;
 }
+/** live 面模型文本的帧(本登记册铸的全部四种):两族的逐块帧与各自的段末帧。 */
+export type LiveModelTextFrame = (LiveEventIdentity & {
+    type: "text_delta" | "reasoning_delta";
+    delta: string;
+}) | (SegmentEndFields & {
+    type: "text_end";
+}) | ReasoningEndFrame;
 /**
- * 一条 live 腿上**按流身份分账**的 `reasoning` 段登记册。
+ * 🔴 **live 面模型文本的唯一铸点** —— 一条 live 腿上按**族 × 流身份**分账的段登记册(三条 live 腿共用:顶层流 / 转发子代腿 / 子代 tail 面)。
+ *
+ * ## 律(一条):凡出 wire 的模型文本经同一只脱敏器,不分帧
+ * 段末帧(`text_end.content` / `reasoning_end.content`)、`done.result`、账本 `text` / `reasoning` 行早就整段过 `redactModelText`;
+ * 逐块帧(`text_delta` / `reasoning_delta`)此前一个逐字、一个逐块脱敏 —— 跨块的凭据在两者上都留明文。现在逐块帧也只放**同一只脱敏器**判定过的字节:
+ * 每条流一只脱敏器的**流式口**(`trace/redact.ts` 的 `createRedactionStream`:喂入 / 取已判定前缀 / 收尾冲刷三口,同一只扫描器、同一张表):每块到达时喂入、
+ * 取出已判定的那一截放出(脱敏器自己的未决尾不出门,横跨切点的跨度整条不出);段末冲刷,余下的按整段读法放出,再发段末帧。
+ * ⇒ 一段的逐块帧依次拼接 = 该段段末帧的正文 —— 逐字节(凭据形换记号,不含凭据形的文本逐字节不变)。两族的段 = 账本 `text` / `reasoning` 行的单位(同一只段界谓词)。
+ *
+ * ## 文字块是段的切片(单位只有一个:段)
+ * 引擎的 `text_end` 关的是一个**文字块**,不是段:它是这一块的**交付点**,不收段 —— 段的状态(前文)跨块留着,账本 `text` 行按同一个段拼起来判。
+ * 一块的原文只有一个定义({@link blockText}:它的 delta 字节;一个 delta 字节都没有、只有 `text_end` 的块 = 它的正文),活流段流与两条账本腿同读 ——
+ * 只有 `text_end` 的块照样进本段的流,由段末帧交付(不另出逐块帧),也照样进账本 `text` 行。
+ * 交付点上:① 这一块还押在窗里的字节按整段读法、**文本到此为止**交出(流式口的 `takeAll`;一帧不带 `eventId` 的 `text_delta`,紧贴段末帧之前);
+ * ② `text_end.content` = 引擎这一块的正文,**接在本段已喂入的前文之后**判(`textEndEventData(ev, 前文)`:与账本行同一只 `redactModelText`;前文只作判定上下文);
+ * ③ 记下块界。⇒ 每块的逐块帧拼接 = 该块 `text_end.content`(引擎没修剪那一块时逐字节),各块依次拼接 = 账本 `text` 行(块界上到此为止的判定与整段判定不同时除外,见下)。
+ * 判定读不到交付点之后的字节,到此为止的判定可以与整段判定不同:一条凭据形恰横跨块界(交付那一截按到此为止判,读得出的半形出记号,后一块上横跨的那一条整枚换记号),
+ * 或交付时认作凭据、后文让它不再是(活流那一截是记号)—— 两种都是账本整段判,
+ * 段末核对对不上计一次 `server.live-text.hold-diverged` —— 这是交付点的定义,不是第二套规则(等后文 = 一段引子要扣到下一个结构帧,例如整份工具入参生成完)。
+ *
+ * ## 帧数与身份(消费端看得见的三件事)
+ *  · 引擎的每一块 delta 仍恰好一帧、同一枚 `eventId`、原序(`delta` 可以是 `""`:那一块的字节还在窗里)—— 续流游标与 E18 的首块句柄不动;
+ *  · 段末还在窗里的字节在段末帧**之前**一帧放出(同一族的逐块帧,带流身份三键、**不带** `eventId` ⇒ 不发 `id:` 行:它不是引擎的内容帧);
+ *  · 延迟:一个字节在同一条流又到了脱敏器的未决尾上界(`PENDING_TAIL_UNITS` 个读法单元,由脱敏器的臂表算出)之后的下一次重扫时出门(重扫节律在流式口里);
+ *    盖住它的跨度还在判定(未收尾的栅栏 / 引号 / JSON 串值 …)⇒ 判定或段末。
  *
- * 🔴 **为什么是登记册而不是一只累积器**(codex 对抗复审 R1 两根 [high],亲跑复现后按类修):一条腿上
- * 并发子代的 `reasoning_delta` 是**交错**到达的。一只累积器只有两种活法,两条都错:
- *  · 「换身份就收段」⇒ A 说一半、B 插一句、A 说另一半 ⇒ A 被切成两枚权威段,**跨块的凭据正好落在切口上**
- *    ——本帧存在的唯一理由当场失效(实测:两枚 `reasoning_end` 拼起来仍是明文密钥);
- *  · 「不换就不收」⇒ 两个子代的思考拼成一段,再盖上其中一个的身份键(串味 + 冤枉归属)。
- * 分账之后规则反而**更少**:一条流的段,只被**它自己**的段界或**它自己**的终态收走;别人说什么都与它无关。
+ * ## 段界(与账本腿同一只谓词)
+ * 两族都只在本流的段界词({@link isModelSegmentBoundary})与腿终局 / 子代终态({@link LiveModelText.cut})收段;引擎的 `text_end` 是块的交付点(上一节),不收段。
+ * 收段顺序:同一批里先散文、后推理。散文段收段时若最后一块之后还有字节(那一块没有 `text_end`:自定义 brain / 截断),余下的照样一帧放出,不铸 `text_end`(诚实缺席)。
  *
- * 状态的界:每条流的条目在它的首块 delta 上建、在收段时删;腿终局 {@link ReasoningSegments.cut} 不带
- * 匹配器 = 全收全删。子代终态那一次带匹配器的收段(转发腿的 `onTaskNotification`)是让**活着的子代数**
- * 而不是「这条 run 一共派过多少子代」成为上界的那一手。
+ * 🔴 **为什么分账**(codex 对抗复审 R1 两根 [high],亲跑复现后按类修):一条腿上并发子代的逐块帧是**交错**到达的。一只累积器只有两种活法,两条都错:
+ *  · 「换身份就收段」⇒ A 说一半、B 插一句、A 说另一半 ⇒ A 被切成两段,**跨块的凭据正好落在切口上**;
+ *  · 「不换就不收」⇒ 两个子代的文字拼成一段,再盖上其中一个的身份键(串味 + 冤枉归属)。
+ * 一条流的段,只被**它自己**的段界或**它自己**的终态收走;别人说什么都与它无关。
+ *
+ * ## 投递态(tail 面:有没有人在听)
+ * `onEvent(ev, deliver)`:`deliver = false` 时只攒原文、照常按段界收段,不扫描、不出帧(tail 面的免投影快门);一条流从不投递转为投递时,放行位跳到**此刻**的段尾
+ * —— 之前的字节没人收,之后的字节仍按**整段**的上下文判定(晚到的订阅者在 `password=` 之后才开始听,值照样认得出)。段末帧的正文恒是整段(`text_end` 恒是整块)。
+ * 没人在听时的块交付点只记块界(不扫描、不出帧)。
+ *
+ * 状态的界:每条流的条目在它的首块非空 delta 上建、在收段时删;腿终局 {@link LiveModelText.cut} 不带匹配器 = 全收全删。
+ * 子代终态那一次带匹配器的收段(转发腿的 `onTaskNotification`)让**活着的子代数**成为上界。
  */
-export interface ReasoningSegments {
-    /** 喂一帧 → 本帧收走的段末帧(0 或 1 枚,且**只可能是本帧自己那条流**的段)。返回数组只为让调用点
-     *  与 {@link cut} 同形(`for (const f of …) send(f)`),不是「一帧可能收多段」。 */
-    onEvent(ev: ReasoningStreamEvent): ReasoningEndFrame[];
-    /** 收段:`match` 缺省 = 本腿**全部**流(腿终局 / 句柄终态);给了就只收匹配的那几条(某个子代终态)。
+export interface LiveModelText {
+    /** 喂一帧 → 本帧要写的帧(按序):逐块帧 / 本流收段放出的余下字节 + 段末帧。`deliver` 缺省 = 投递。 */
+    onEvent(ev: ModelStreamEvent, deliver?: boolean): LiveModelTextFrame[];
+    /** 收段:`match` 缺省 = 本腿**全部**流(腿终局 / 句柄终态);给了就只收匹配的那几条(某个子代终态)。`deliver` 同 {@link onEvent}(缺省 = 投递)。
      *  与账本腿 `LedgerSink.onDone → flush()` 同位同义 —— 段界表里没有终局词,终局走这扇门。 */
-    cut(match?: (ident: ReasoningStreamIdent) => boolean): ReasoningEndFrame[];
+    cut(match?: (ident: ModelStreamIdent) => boolean, deliver?: boolean): LiveModelTextFrame[];
+    /** 没有开着的段(状态只有开着的段:空着的登记册与新建的一只等价,持有方可以删掉它、下一帧再建)。 */
+    isIdle(): boolean;
 }
 /**
  * 一段推理的**段末事件 id** —— 唯一铸点,live 段末帧与账本 `reasoning` 行共用这一只。
@@ -72,14 +112,23 @@ export interface ReasoningSegments {
  * 伪装成可锚)。
  */
 export declare function reasoningSegmentEventId(anchor: unknown): string | undefined;
+/**
+ * 🔴 **一个文字块的原文 —— 唯一定义**(三处同读,各自不另判:活流段流 {@link createLiveModelText}、账本写口 `trace/ledger-sink.ts`、续跑腿 `http/resume-legs.ts`):
+ * 这一块的 `text_delta` 字节;一个 delta 字节都没有的块(只有 `text_end`)= 它的 `text_end` 正文(非串 ⇒ 空)。
+ * `deltas` = 这一块(上一个块界之后)已到的 delta 字节;`end` = 这一块的 `text_end`(块还没收口 ⇒ 不传:原文就是已到的 delta)。
+ * 段文本 = 段内各块原文依次拼接 —— 账本 `text` 行与活流段流读的都是它。
+ */
+export declare function blockText(deltas: string, end?: {
+    content?: unknown;
+}): string;
 /** 一块 `reasoning_delta` 对段的**贡献字节** —— 非空串才算。账本腿与三条 live 腿共用这一只:空/坏形
  *  增量一个字节都不贡献,既不开段也不参与闩锚 ⇒ 两面结构上不可能把锚闩在不同的帧上(`reasoning_end`
  *  与账本 `reasoning` 行的正文早就逐字节相等,身份面随 [ref] 收进同一条规则)。 */
 export declare function reasoningDeltaBytes(ev: {
     delta?: unknown;
 }): string | undefined;
-/** 「这条流属于这些子代 id 之一」—— 子代终态收段的匹配器(`task_id` 与 `sessionId` 是同一个子代的两个
- *  id 域,取并集;`undefined` 成员自动忽略)。腿上共用这一只,免得各写一遍 id 域的并集。 */
-export declare function reasoningStreamOfTask(...ids: ReadonlyArray<string | undefined>): (ident: ReasoningStreamIdent) => boolean;
-export declare function createReasoningSegments(): ReasoningSegments;
+/** 「这条流属于这只后台子代」—— 子代终态收段的匹配器。一只后台子代一个 id(引擎 7.61.0:它的帧的 `sourceTaskId`、
+ *  转发帧的 `bgAgentId`、完成通知的 `task_id` 都是它的注册表行 id),按那一个 id 认流。 */
+export declare function modelStreamOfTask(taskId: string): (ident: ModelStreamIdent) => boolean;
+export declare function createLiveModelText(): LiveModelText;
 //# sourceMappingURL=model-segment.d.ts.map

package/dist/trace/model-segment.js

@@ -1,4 +1,9 @@
-import { reasoningEndEventData } from "./project.js";
+import { recordFailOpen } from "../observability/fail-open.js";
+import { errorKindOf } from "../observability/err-text.js";
+import { OVERSIZED_REDACTION_PLACEHOLDER } from "../observability/run-terminal.js";
+import { liveIdentityFields, reasoningEndEventData, textEndEventData } from "./project.js";
+import { dropProjectedFace } from "./projection-drop.js";
+import { createRedactionStream } from "./redact.js";
 const BOUNDARY = new Set([
     "tool_start", "tool_end", "status", "context_usage", "compacted", "diagnostics",
     "steering_injected", "compaction_outcome", "workspace_changed", "wiring_manifest",
@@ -11,12 +16,16 @@ const REASONING_SEGMENT_ID_MARK = "~reasoning_end";
 export function reasoningSegmentEventId(anchor) {
     return typeof anchor === "string" && anchor.length > 0 ? `${anchor}${REASONING_SEGMENT_ID_MARK}` : undefined;
 }
+export function blockText(deltas, end) {
+    if (deltas !== "" || end === undefined)
+        return deltas;
+    return typeof end.content === "string" ? end.content : "";
+}
 export function reasoningDeltaBytes(ev) {
     return typeof ev.delta === "string" && ev.delta !== "" ? ev.delta : undefined;
 }
-export function reasoningStreamOfTask(...ids) {
-    const set = new Set(ids.filter((v) => typeof v === "string" && v !== ""));
-    return (ident) => (ident.sourceTaskId !== undefined && set.has(ident.sourceTaskId)) || (ident.bgAgentId !== undefined && set.has(ident.bgAgentId));
+export function modelStreamOfTask(taskId) {
+    return (ident) => ident.sourceTaskId === taskId || ident.bgAgentId === taskId;
 }
 function streamKeyOf(ident) {
     return `${ident.parentToolCallId ?? ""}\u0000${ident.sourceTaskId ?? ""}\u0000${ident.bgAgentId ?? ""}`;
@@ -25,44 +34,144 @@ function identOf(ev) {
     const s = (v) => (typeof v === "string" ? v : undefined);
     return { parentToolCallId: s(ev.parentToolCallId), sourceTaskId: s(ev.sourceTaskId), bgAgentId: s(ev.bgAgentId) };
 }
-export function createReasoningSegments() {
-    const open = new Map();
-    const cutKey = (key) => {
-        const seg = open.get(key);
-        if (seg === undefined)
+function release(s) {
+    try {
+        return s.text.takeSettled();
+    }
+    catch (err) {
+        recordFailOpen("server.run-terminal.redact-threw", `live-hold len=${s.text.fed.length} err=${errorKindOf(err)}`);
+        return "";
+    }
+}
+function deliverBlock(s) {
+    try {
+        return s.text.takeAll();
+    }
+    catch (err) {
+        recordFailOpen("server.run-terminal.redact-threw", `live-hold len=${s.text.fed.length} err=${errorKindOf(err)}`);
+        s.text.skip();
+        return OVERSIZED_REDACTION_PLACEHOLDER;
+    }
+}
+function remainderOf(family, s) {
+    try {
+        const r = s.text.flush();
+        if (r.diverged)
+            recordFailOpen("server.live-text.hold-diverged", `family=${family} len=${s.text.fed.length}`);
+        return r.rest;
+    }
+    catch (err) {
+        recordFailOpen("server.run-terminal.redact-threw", `live-hold len=${s.text.fed.length} err=${errorKindOf(err)}`);
+        return OVERSIZED_REDACTION_PLACEHOLDER;
+    }
+}
+export function createLiveModelText() {
+    const open = { text: new Map(), reasoning: new Map() };
+    const deltaType = (family) => (family === "text" ? "text_delta" : "reasoning_delta");
+    const openSegment = (family, key, ident, deliver) => {
+        const s = { ident, text: createRedactionStream(), delivering: deliver, blockFrom: 0 };
+        open[family].set(key, s);
+        return s;
+    };
+    const close = (family, key, deliver) => {
+        const s = open[family].get(key);
+        if (s === undefined)
+            return [];
+        open[family].delete(key);
+        if (!deliver)
             return [];
-        open.delete(key);
-        const data = reasoningEndEventData({ ...seg.ident, eventId: seg.segmentEventId, content: seg.buf });
-        return data === null ? [] : [{ type: "reasoning_end", ...data }];
+        if (!s.delivering)
+            s.text.skip();
+        const out = [];
+        const rest = remainderOf(family, s);
+        if (rest !== "")
+            out.push({ type: deltaType(family), delta: rest, ...liveIdentityFields(s.ident) });
+        if (family === "reasoning") {
+            const data = reasoningEndEventData({ ...s.ident, eventId: s.segmentEventId, content: s.text.fed });
+            if (data !== null)
+                out.push({ type: "reasoning_end", ...data });
+        }
+        return out;
+    };
+    const feed = (family, ev, deliver) => {
+        if (typeof ev.delta !== "string") {
+            if (family === "text")
+                dropProjectedFace("text_delta.delta is not a string");
+            else
+                dropProjectedFace("reasoning_delta.delta is not a string");
+            return [];
+        }
+        const ident = identOf(ev);
+        const key = streamKeyOf(ident);
+        let s = open[family].get(key);
+        if (s === undefined && ev.delta !== "")
+            s = openSegment(family, key, ident, deliver);
+        if (s !== undefined) {
+            if (deliver && !s.delivering) {
+                s.delivering = true;
+                s.text.skip();
+            }
+            else if (!deliver)
+                s.delivering = false;
+            s.text.feed(ev.delta);
+            if (family === "reasoning" && reasoningDeltaBytes(ev) !== undefined)
+                s.segmentEventId ??= reasoningSegmentEventId(ev.eventId);
+        }
+        if (!deliver)
+            return [];
+        return [{ type: deltaType(family), delta: s === undefined ? "" : release(s), ...liveIdentityFields(ev) }];
     };
     return {
-        onEvent: (ev) => {
-            if (ev.type === "reasoning_delta") {
-                const bytes = reasoningDeltaBytes(ev);
-                if (bytes === undefined)
-                    return [];
-                const ident = identOf(ev);
-                const key = streamKeyOf(ident);
-                const seg = open.get(key);
-                if (seg === undefined)
-                    open.set(key, { ident, segmentEventId: reasoningSegmentEventId(ev.eventId), buf: bytes });
-                else {
-                    seg.buf += bytes;
-                    seg.segmentEventId ??= reasoningSegmentEventId(ev.eventId);
+        onEvent: (ev, deliver = true) => {
+            if (ev.type === "text_delta")
+                return feed("text", ev, deliver);
+            if (ev.type === "reasoning_delta")
+                return feed("reasoning", ev, deliver);
+            const key = streamKeyOf(identOf(ev));
+            if (ev.type === "text_end") {
+                let s = open.text.get(key);
+                const out = [];
+                const before = s === undefined ? "" : s.text.fed.slice(0, s.blockFrom);
+                const arrived = s === undefined ? "" : s.text.fed.slice(s.blockFrom);
+                const unfed = blockText(arrived, ev).slice(arrived.length);
+                const endOnly = unfed !== "" ? unfed : undefined;
+                if (s === undefined && endOnly !== undefined)
+                    s = openSegment("text", key, identOf(ev), deliver);
+                if (s !== undefined) {
+                    if (deliver && !s.delivering) {
+                        s.delivering = true;
+                        s.text.skip();
+                    }
+                    else if (!deliver)
+                        s.delivering = false;
+                    if (endOnly !== undefined)
+                        s.text.feed(endOnly);
+                    if (deliver) {
+                        const rest = deliverBlock(s);
+                        if (rest !== "" && endOnly === undefined)
+                            out.push({ type: "text_delta", delta: rest, ...liveIdentityFields(s.ident) });
+                    }
+                    s.blockFrom = s.text.fed.length;
                 }
-                return [];
+                const end = deliver ? textEndEventData(ev, before) : null;
+                if (end !== null)
+                    out.push({ type: "text_end", ...end });
+                return out;
             }
-            return isModelSegmentBoundary(ev.type ?? "") ? cutKey(streamKeyOf(identOf(ev))) : [];
+            return isModelSegmentBoundary(ev.type ?? "") ? [...close("text", key, deliver), ...close("reasoning", key, deliver)] : [];
         },
-        cut: (match) => {
+        cut: (match, deliver = true) => {
             const out = [];
-            for (const [key, seg] of [...open]) {
-                if (match !== undefined && !match(seg.ident))
-                    continue;
-                out.push(...cutKey(key));
+            for (const family of ["text", "reasoning"]) {
+                for (const [key, s] of [...open[family]]) {
+                    if (match !== undefined && !match(s.ident))
+                        continue;
+                    out.push(...close(family, key, deliver));
+                }
             }
             return out;
         },
+        isIdle: () => open.text.size === 0 && open.reasoning.size === 0,
     };
 }
 //# sourceMappingURL=model-segment.js.map

package/dist/trace/project.d.ts

@@ -219,15 +219,17 @@ export declare function screenedGate(v: unknown): GateOutcome | undefined;
  * 不改原对象(调用方与账本共享引用):有变更时换一只信封,原记录一个字节不动。
  */
 export declare function screenedStoredEventData(type: string, data: unknown): unknown;
-/** `text_end` 段末帧的**唯一**铸点(三腿共用:top stream / 转发子代腿 / 子代 tail 面)。content = 段权威全文 ⇒ 与
+/** `text_end` 段末帧的**唯一**铸点(三腿共用:top stream / 转发子代腿 / 子代 tail 面)。content = 引擎这一块的权威全文 ⇒ 与
  *  durable 面(`result` / 账本 `text` 行)同一只 {@link redactModelText}(认出才改写、抛则占位、不设上限)。
+ *  `before` = 本段在这一块之前已喂入的模型文本(引擎的文字块是段的切片,段 = 账本 `text` 行的单位):这一块**接在本段前文之后**判、只交这一块那一截
+ *  (锚在前一块、值在这一块 ⇒ 照样认得出);由登记册在块的交付点给出,缺省 = 这一块就是段首。
  *  此前三处各自逐字透传 —— 同一份文本毫秒后在 `done.result.result` 上已脱,live 面却在凭据生成瞬间明文([ref])。
- *  `text_delta` 仍逐字:跨 chunk 的凭据无法就地判;clay [ref] ②(2026-09-18)裁定**维持逐字成文**([ref] U-3 关票),
- *  权威段 `text_end.content` 已脱敏、消费端段末整段替换即得脱敏读法。
+ *  逐块的 `text_delta` 由 `trace/model-segment.ts` 的登记册铸(7.143.0 起经同一只脱敏器的放行窗,一段的逐块拼接 = 本帧 content);
+ *  本函数由登记册在段末调,三腿不再各自调。
  *  坏形(content 非串/空串)⇒ null(丢帧,不铸「权威空段」:core 契约明言空段不发本帧,消费端收到空段会清掉已攒 delta)。
  *  身份**四键**随行(live 现状带全四键,消费端可能已依赖);值经 {@link identityKey} —— 非空 string 才上 wire
  *  ([ref] 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
-export declare function textEndEventData(ev: Record<string, unknown>): SegmentEndFields | null;
+export declare function textEndEventData(ev: Record<string, unknown>, before?: string): SegmentEndFields | null;
 /**
  * live 面的**身份四键**(core `TaskEventIdentity` 全集)—— 一个属主,两处共用({@link segmentEndFields}
  * 与 sync 腿白名单 catch-all 的 `ident`;此前是两份手抄)。与 durable 面的 {@link identityFields} 的差别
@@ -637,6 +639,7 @@ export declare function compactionOutcomeEventData(ev: {
     trigger?: unknown;
     reason?: unknown;
     pass?: unknown;
+    requestedBy?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
 }): FrameData<{
@@ -887,8 +890,8 @@ export declare function toolRosterDeltaEventData(ev: {
  * (值可以是 `undefined`)—— 漏递的腿当场 tsc 红,而不是静默投出一个「缺席」(缺席在 wire 上是一句话:「这条腿对这件事没有陈述」)。
  *  · `instructions`([ref],7.111.0)—— 这条腿的 project-memory loader 选中的指令文件链成员 `{ selected: string[] }`;值来自腿的
  *    `InstructionSelectionLeg.segment()`。`undefined` ⇒ 段缺席;`{ selected: [] }` ⇒ 显式空(走了链、没选中)。
- *  · `skills`(7.137.0)—— 这条 run 交给引擎的技能名册(`{ name, description, source }[]`,与场景卡技能清单同一张形);值来自 spec 字段 `runSkillsOf(spec)`
- *    (唯一铸点 = resolveSpec 出口的 `buildRunSkills`)。**run 级** ⇒ 只投根腿 / 续跑腿的帧,委派子代的帧(`parentToolCallId` 在场)不投(子代的技能由它自己的定义决定);
+ *  · `skills`(7.137.0)—— 这条 run 交给引擎的技能名册(`{ name, description, source }[]`,与场景卡技能清单同一张形);值来自这条腿的部署事实 `LegFacts.skills`
+ *    (`leg-facts.ts`;名册由 `buildRunSkills` 合并、resolveSpec 出口登记,漏斗在复制之前读出)。**run 级** ⇒ 只投根腿 / 续跑腿的帧,委派子代的帧(`parentToolCallId` 在场)不投(子代的技能由它自己的定义决定);
  *    `[]` = 零技能(含 `disableSkills`);`undefined` ⇒ 段缺席(这条腿的 spec 不是本仓装配的)。`description` 过上 wire 的自由文本出口 {@link sanitizeWireText}。
  */
 export interface LegWiringSections {
@@ -984,6 +987,9 @@ export declare function wiringManifestFaceEventData(ev: {
  *    路径或名字(引擎原样回声,不是解析后的落点 —— 多租户沙箱车道上它是这次 run 自己工作区里的相对 / 绝对路径串,帧上不出现任何别的租户
  *    或宿主盘的信息),与已展示的工具实参 / `workspace_changed.cwd` 同一信任级(UNTRUSTED 的路径串)⇒ 过 `redactSecrets`。长度界由引擎定
  *    (`USER_ATTACHMENT_LABEL_MAX`),本仓不另截。非对象的成员丢、集外的成员键不投(同 `actor` 的白名单理由)。
+ *  · `rewrittenBy[]`(core 7.62.0 [ref],只在腿的 prompt 屏 `prompt.submit` 改写过这条输入时在场)—— 改写它的扩展注册名,按改写序 ⇒ verbatim:
+ *    名字的形由引擎在注册入口判(`MOD_REGISTRATION_NAME`,能引号 / 括号 / 折句的名在入口拒),与会话行上同名位(`audit.ts` 的 `rewrittenBy: "verbatim"`)
+ *    同一读法。非数组不投、非串 / 空串成员丢、丢完为空不铸键(缺席 = 原样送达,不是空数组)。
  *
  * `actor` 逐键挑(禁 spread):core 已声明 `ActorAssertion` 是冻结三键形,但白名单的意义正是「core 加第
  * 四键时由人处置」——身份对象上多出来的键裸上线是本文件反复登记的病族。
@@ -1000,6 +1006,7 @@ export declare function humanInputEventData(ev: {
     principal?: unknown;
     entryId?: unknown;
     attachments?: unknown;
+    rewrittenBy?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
 }): FrameData<{
@@ -1076,6 +1083,8 @@ export declare function compactedEventData(ev: {
     };
     /** [ref](core 7.53.0 [ref]):这次落地的压缩 pass 的 id —— 与它的 `compaction_started` 帧同一个值(引擎在每次落地上都设;型上可选)。逐字。 */
     pass?: string;
+    /** core 7.61.0:扩展经 `$.session.compact` 提的手动请求落地的那一 pass —— 谁要的(同 {@link compactionOutcomeEventData} 那一位)。 */
+    requestedBy?: unknown;
 }): FrameData<{
     attachedFiles?: Array<{
         path: SafeText;

package/dist/trace/project.js

@@ -210,10 +210,10 @@ function projectSettlement(st) {
         ...(typeof st.note === "string" ? { note: redactSecrets(st.note).slice(0, SETTLEMENT_NOTE_MAX) } : {}),
     };
 }
-export function textEndEventData(ev) {
+export function textEndEventData(ev, before = "") {
     if (typeof ev.content !== "string" || ev.content.length === 0)
         return null;
-    return segmentEndFields(ev.content, ev);
+    return segmentEndFields(ev.content, ev, before);
 }
 export function liveIdentityFields(ev) {
     return {
@@ -223,8 +223,8 @@ export function liveIdentityFields(ev) {
         ...(identityKey(ev.bgAgentId) !== undefined ? { bgAgentId: identityKey(ev.bgAgentId) } : {}),
     };
 }
-function segmentEndFields(content, ev) {
-    return { content: redactModelText(content), ...liveIdentityFields(ev) };
+function segmentEndFields(content, ev, before = "") {
+    return { content: redactModelText(content, before), ...liveIdentityFields(ev) };
 }
 export function reasoningEndEventData(ev) {
     if (typeof ev.content !== "string" || ev.content.trim().length === 0)
@@ -434,9 +434,14 @@ export function compactionOutcomeEventData(ev) {
         ...(s(ev.trigger) !== undefined ? { trigger: s(ev.trigger) } : {}),
         ...(ev.reason !== undefined ? { reason: seatText("trace-frame-text", String(ev.reason)) } : {}),
         ...(s(ev.pass) !== undefined ? { pass: s(ev.pass) } : {}),
+        ...requestedByField(ev.requestedBy, "compaction_outcome"),
         ...identityFields(ev),
     };
 }
+function requestedByField(v, where) {
+    const requester = extensionRequesterOf(v, where);
+    return requester !== undefined ? { requestedBy: requester } : {};
+}
 export function compactionStartedEventData(ev) {
     const s = (v) => (typeof v === "string" ? v : undefined);
     return {
@@ -806,6 +811,7 @@ export function humanInputEventData(ev) {
             ...(str(m.label) !== undefined ? { label: seatText("trace-frame-text", String(m.label)) } : {}),
         }))
         : undefined;
+    const rewrittenBy = Array.isArray(ev.rewrittenBy) ? ev.rewrittenBy.filter((n) => str(n) !== undefined) : [];
     const actor = {
         ...(str(a.id) !== undefined ? { id: seatText("trace-frame-text", String(a.id)) } : {}),
         ...(typeof a.hostAsserted === "boolean" ? { hostAsserted: a.hostAsserted } : {}),
@@ -821,6 +827,7 @@ export function humanInputEventData(ev) {
         ...(Object.keys(actor).length > 0 ? { actor } : {}),
         ...(str(ev.entryId) !== undefined ? { entryId: ev.entryId } : {}),
         ...(attachments !== undefined ? { attachments } : {}),
+        ...(rewrittenBy.length > 0 ? { rewrittenBy } : {}),
         ...identityFields(ev),
     };
 }
@@ -893,6 +900,7 @@ export function compactedEventData(ev) {
         ...(num(ev.durationMs) !== undefined ? { durationMs: num(ev.durationMs) } : {}),
         ...(phaseDurations !== undefined ? { phaseDurations } : {}),
         ...(typeof ev.pass === "string" ? { pass: ev.pass } : {}),
+        ...requestedByField(ev.requestedBy, "compacted"),
     };
 }
 export function contextUsageEventData(ev) {