@sema-agent/server 7.133.0 → 7.135.0

package/dist/trace/exit-seat.js

@@ -1,3 +1,5 @@
+import { stripControlAndBidi } from "@sema-agent/settings-schema";
+import { CALLER_TEXT_CUT_MARK } from "../caller-text-echo.js";
 import { errorKindOf } from "../observability/err-text.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { OVERSIZED_REDACTION_PLACEHOLDER } from "../observability/run-terminal.js";
@@ -5,12 +7,23 @@ import { proposeRedactionSpans, REDACTION_TOKEN_RE_SRC } from "./redact.js";
 const EXIT_SEATS = {
     "trace-frame-text": { scope: "free-text" },
     "trace-frame-line": { scope: "free-text", maxChars: 300 },
+    "operator-log-text": { scope: "free-text", maxChars: 200, emit: "log-line" },
+    "operator-log-arg": { scope: "free-text", maxChars: 120, emit: "log-line" },
+    "operator-log-error": { scope: "free-text", maxChars: 300, emit: "log-line" },
+    "operator-log-message": { scope: "free-text", maxChars: 500, emit: "log-line" },
+    "session-title": { scope: "free-text", maxChars: 80, emit: "title-line" },
 };
+export function seatMaxChars(seat) {
+    return EXIT_SEATS[seat].maxChars;
+}
 const SEAT_ROWS = new Map(Object.entries(EXIT_SEATS));
 for (const [name, row] of SEAT_ROWS) {
     if (row.maxChars !== undefined && row.maxChars < OVERSIZED_REDACTION_PLACEHOLDER.length) {
         throw new Error(`exit seat "${name}": maxChars ${row.maxChars} cannot hold the failure placeholder (${OVERSIZED_REDACTION_PLACEHOLDER.length} code units)`);
     }
+    if (row.emit !== undefined && row.maxChars === undefined) {
+        throw new Error(`exit seat "${name}": a row with an emission form must declare maxChars (the cut mark counts inside the bound)`);
+    }
 }
 function mergeSpans(spans) {
     const order = spans.map((s, i) => ({ s, i })).sort((a, b) => a.s.start - b.s.start || b.s.end - a.s.end || a.i - b.i);
@@ -39,33 +52,52 @@ function cutPlain(gap, room) {
     }
     return gap.slice(0, cut);
 }
-function renderOnce(text, groups, maxChars) {
+function renderOnce(text, groups) {
     const parts = [];
-    let len = 0;
     let at = 0;
     for (const g of groups) {
-        const gap = text.slice(at, g.start);
-        if (maxChars !== undefined && len + gap.length > maxChars)
-            return parts.join("") + cutPlain(gap, maxChars - len);
-        parts.push(gap);
-        len += gap.length;
-        if (maxChars !== undefined && len + g.repl.length > maxChars)
-            return parts.join("");
-        parts.push(g.repl);
-        len += g.repl.length;
+        parts.push(text.slice(at, g.start), g.repl);
         at = g.end;
     }
-    const tail = text.slice(at);
-    parts.push(maxChars === undefined || len + tail.length <= maxChars ? tail : cutPlain(tail, maxChars - len));
+    parts.push(text.slice(at));
     return parts.join("");
 }
+function emitAs(form, text) {
+    switch (form) {
+        case "log-line":
+            return stripControlAndBidi(text);
+        case "title-line":
+            return stripControlAndBidi(text.replace(/[\r\n]+/g, " "))
+                .trim()
+                .replace(/^["'「『]+/, "")
+                .replace(/["'」』]+$/, "")
+                .trim();
+        default: {
+            const unhandled = form;
+            throw new Error(`exit seat: unhandled emission form ${String(unhandled)}`);
+        }
+    }
+}
+const layoutOf = (row) => (row.emit === undefined ? "multi-line" : "single-line");
+function boundRow(out, row) {
+    if (row.maxChars === undefined || out.length <= row.maxChars)
+        return out;
+    if (row.emit === undefined)
+        return cutPlain(out, row.maxChars);
+    return cutPlain(out, row.maxChars - CALLER_TEXT_CUT_MARK.length) + CALLER_TEXT_CUT_MARK;
+}
 export function seatText(seat, text) {
     const row = SEAT_ROWS.get(seat);
     if (row === undefined)
         throw new Error(`exit seat: ${JSON.stringify(seat)} is not a row of the seat table`);
     let out;
     try {
-        out = renderOnce(text, mergeSpans(proposeRedactionSpans(text, row.scope)), row.maxChars);
+        if (row.emit !== undefined && emitAs(row.emit, text) === "")
+            out = "";
+        else {
+            const rendered = renderOnce(text, mergeSpans(proposeRedactionSpans(text, row.scope, layoutOf(row))));
+            out = boundRow(row.emit === undefined ? rendered : emitAs(row.emit, rendered), row);
+        }
     }
     catch (err) {
         recordFailOpen("server.run-terminal.redact-threw", `seat=${seat} len=${typeof text === "string" ? text.length : -1} err=${errorKindOf(err)}`);

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

@@ -32,9 +32,9 @@
  *  · **腿自己的带外行**:park/终局/失败/建议/用量/装配自证(不来自流事件)。
  */
 export type LedgerEventType = "reasoning" | "text" | "tool_start" | "tool_end" | "status" | "context_usage" | "compacted" | "diagnostics" | "steering_injected" | "compaction_outcome"
-/** S-1732(core 7.53.0 #2008):压缩 pass 的开始帧(`{ trigger, pass, startedAt }`;结束帧带同一个 `pass`)。原样落账,两条 durable 腿同源。 */
+/** [ref](core 7.53.0 [ref]):压缩 pass 的开始帧(`{ trigger, pass, startedAt }`;结束帧带同一个 `pass`)。原样落账,两条 durable 腿同源。 */
  | "compaction_started" | "workspace_changed" | "wiring_manifest"
-/** S-212(7.71.0):运行期名册变更(core 7.8.0 [ref] ⑪)。**快照语义**——`delta.roster` 是整只
+/** [ref](7.71.0):运行期名册变更(core 7.8.0 [ref] ⑪)。**快照语义**——`delta.roster` 是整只
  *  变更后名册,消费端收到即整只替换,所以回放不需要任何合并;它的耐久面因此不是 `wiring_manifest.tools`
  *  的重复,而是那份开腿快照**之后**的每一次改动(修前两条 durable 腿零 case ⇒ 回放只见开头一版)。 */
  | "tool_roster_delta"
@@ -52,7 +52,9 @@ export type LedgerEventType = "reasoning" | "text" | "tool_start" | "tool_end" |
  | "task_started" | "task_progress" | "task_notification" | "turn_end"
 /** park 行名**两个**(`appendParked(kind)` 逐字取自 `result.status`)—— 运行期闭集见
  *  {@link PARK_LEDGER_EVENT_TYPES}(本联合是它的类型面,两者由下方的双向断言锁步)。 */
- | "suspended" | "needs_review" | "done" | "failed" | "suggestions" | "model_usage" | "prompt_assembled" | "config_assembled" | "file_link"
+ | "suspended" | "needs_review" | "done" | "failed" | "suggestions" | "model_usage" | "prompt_assembled" | "config_assembled"
+/** core 7.54.0 [ref] O9b S1:`permission.cross_boundary_taint` 帧的耐久行(伴随记录,与 `config_assembled` 同一只队列、同一批 drain 点;只在执行于目标设备的树上有)。 */
+ | "cross_boundary_taint" | "file_link"
 /** 人在环三族的 open/close 帧对(投递面 = 本腿的 durable events tail)。 */
  | "elicitation" | "elicitation_complete" | "question" | "question_complete" | "tool_approval" | "tool_approval_complete"
 /** [ref] §4.3 呈卡族的开卡帧与单卡消卡帧(与上面两只 tool_approval 帧同一条投递面;一条腿只发其中一族,
@@ -93,7 +95,7 @@ export type LedgerEventType = "reasoning" | "text" | "tool_start" | "tool_end" |
 export declare const PARK_LEDGER_EVENT_TYPES: readonly ["suspended", "needs_review"];
 export type ParkLedgerEventType = (typeof PARK_LEDGER_EVENT_TYPES)[number];
 /**
- * 🔴 **模型自由文本行名的运行时闭集**(B-106 / S-268)—— 与 {@link PARK_LEDGER_EVENT_TYPES} 同一条理由、
+ * 🔴 **模型自由文本行名的运行时闭集**([ref] / [ref])—— 与 {@link PARK_LEDGER_EVENT_TYPES} 同一条理由、
  * 同一种锁步形。
  *
  * 这两行(`text` = 模型写给用户的文本,`reasoning` = 同一支笔的 CoT)是账本上**唯二**逐字携带模型散文的型,

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

@@ -152,7 +152,7 @@ export declare function createLedgerSink(opts: {
      *  各传自己看得见的那个词(位①=流事件 `ev.type`,位②=账本行 `type`);拿不到类型的打点方
      *  (core 的 onActivity 第五席、resume 腿手动打点)省参,`kind` 诚实缺席(见 turn-activity.ts)。 */
     onActivity?: (kind?: string, statusData?: Record<string, unknown>) => void;
-    /** S-961:这条腿的 `wiring_manifest.instructions` 段(腿的 `InstructionSelectionLeg.segment`)。**必填**:账本行与 live 帧是
+    /** [ref]:这条腿的 `wiring_manifest.instructions` 段(腿的 `InstructionSelectionLeg.segment`)。**必填**:账本行与 live 帧是
      *  同一条腿的两个载体,段必须来自同一只腿;在投帧那一刻读(core 推帧之前已 await 过 loader)。返回 `undefined` ⇒ 段缺席。 */
     instructionsSegment: () => InstructionsSegment | undefined;
 }): LedgerSink;

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

@@ -7,7 +7,7 @@ import { type SegmentEndFields } from "./project.js";
  */
 export declare function isModelSegmentBoundary(type: string): boolean;
 /** live 面的段末帧(`type` 即事件名;其余键由 `reasoningEndEventData` 白名单铸出)。
- *  形是**声明**出来的、不是 `Record<string, unknown>`(S-334 门①):`eventId` 是本帧的续流游标,
+ *  形是**声明**出来的、不是 `Record<string, unknown>`([ref] 门①):`eventId` 是本帧的续流游标,
  *  型必须说得出口 —— live 腿的 `id:` 行取的正是它。 */
 export type ReasoningEndFrame = SegmentEndFields & {
     type: "reasoning_end";
@@ -54,7 +54,7 @@ export interface ReasoningSegments {
 /**
  * 一段推理的**段末事件 id** —— 唯一铸点,live 段末帧与账本 `reasoning` 行共用这一只。
  *
- * 🔴 **为什么段末帧不能沿用任何一块 delta 的 `eventId`**(S-334):SSE 的 `id:` 行是**续流游标**,
+ * 🔴 **为什么段末帧不能沿用任何一块 delta 的 `eventId`**([ref]):SSE 的 `id:` 行是**续流游标**,
  * 「每帧唯一」就是它的定义(消费端据它做**整帧幂等**:见过的 id 整帧丢);而本仓 live 腿的 `id:` 行
  * 恰恰取自载荷的 `eventId`(`http/routes/tasks.ts` 的 `sseData`)。沿用段内某一块的锚 ⇒ 段末帧与那一块
  * delta 顶着同一枚游标,消费端把**权威段**当重放帧丢弃 —— 本帧存在的唯一理由(整段脱敏后的权威副本)
@@ -74,7 +74,7 @@ export interface ReasoningSegments {
 export declare function reasoningSegmentEventId(anchor: unknown): string | undefined;
 /** 一块 `reasoning_delta` 对段的**贡献字节** —— 非空串才算。账本腿与三条 live 腿共用这一只:空/坏形
  *  增量一个字节都不贡献,既不开段也不参与闩锚 ⇒ 两面结构上不可能把锚闩在不同的帧上(`reasoning_end`
- *  与账本 `reasoning` 行的正文早就逐字节相等,身份面随 S-334 收进同一条规则)。 */
+ *  与账本 `reasoning` 行的正文早就逐字节相等,身份面随 [ref] 收进同一条规则)。 */
 export declare function reasoningDeltaBytes(ev: {
     delta?: unknown;
 }): string | undefined;

package/dist/trace/project.d.ts

@@ -12,7 +12,7 @@
  * old session-join `toolOutput` hook is gone, there's a real source now); `eventId`/`parentToolCallId` (§E2) ride
  * each content event, additive / tolerate-absent.
  *
- * 🔴 **本族 `*EventData` 构造器的入参型不是白名单**(S-545 起,别再照旧读法维护它)。
+ * 🔴 **本族 `*EventData` 构造器的入参型不是白名单**([ref] 起,别再照旧读法维护它)。
  * 每只构造器的形参型是**这条投影的本地入参形**,故意比 core 的分支型松:三条腿里有两条(durable 账本 /
  * resume 回放)手里只有磁盘上的 `Record<string, unknown>`,窄值型在那里结构上不成立,所以 `unknown` +
  * 内部逐层窄化是**有意**的,不是欠账;核过的 core 键在场性由投影体自己的条件展开臂决定。
@@ -26,6 +26,7 @@
 import type { GateOutcome, McpDelivered, TaskResult, SystemInjectionPriority } from "@sema-agent/core";
 import type { RunEvent, RunRecord } from "../plugins/store-contracts.js";
 import type { ModelUsageDelta, ModelUsageTracker, PromptManifestRecord } from "../budget.js";
+import type { RunCompanionRecord } from "../observability/prompt-manifest.js";
 import { type SafeText } from "./exit-seat.js";
 import { type SemaProvenanceInput } from "./sema-provenance.js";
 import type { LedgerEventType } from "./ledger-events.js";
@@ -51,7 +52,7 @@ export declare function appendModelUsageDelta(append: AppendFn, modelUsage: Mode
  *  (one Map.get), so callers fire it liberally. */
 export declare function appendPromptManifest(append: AppendFn, tracker: {
     drain(taskId: string): PromptManifestRecord[] | undefined;
-    drainConfig?(taskId: string): Array<Record<string, unknown>> | undefined;
+    drainCompanions?(taskId: string): RunCompanionRecord[] | undefined;
 } | undefined, taskId: string): Promise<void>;
 /** E8: at a TERMINAL done — flush the final delta, then SUM all `model_usage` events (every process leg) into the
  *  result's `stats.modelUsage` echo. Returns the result unchanged when no usage was tracked (shell soft-degrades). */
@@ -124,7 +125,7 @@ export type TraceBlock = {
     readonly [member: string]: unknown;
 };
 /**
- * 🔴 **模型自由文本账本行(`text` / `reasoning`)的唯一载荷铸点**(B-106 / S-268,7.75.1)。
+ * 🔴 **模型自由文本账本行(`text` / `reasoning`)的唯一载荷铸点**([ref] / [ref],7.75.1)。
  *
  * ## 为什么是一只函数,而不是两处各写一句
  * 这两行的载荷此前由**两条腿各自手拼**:`trace/ledger-sink.ts` 的 turn flush 与 `http/server.ts` 的
@@ -159,11 +160,11 @@ export declare function toolStartEventData(ev: {
     parentToolCallId?: string;
 }): Record<string, unknown>;
 /**
- * 🔴 **筛子是一只总函数**(S-239,codex 对抗复审 r1 [medium] 亲核复现后修)—— 上面纪律②许诺的
+ * 🔴 **筛子是一只总函数**([ref],codex 对抗复审 r1 [medium] 亲核复现后修)—— 上面纪律②许诺的
  * 「坏形 ⇒ report + withhold,**不抛**」此前是靠**逐条枚举**坏形兑现的,枚举不到的那些照样抛:
  * `projectSettlement` 对 `note` / `who.approver` 先 `redactSecrets` 再截断,而 `redactSecrets` 会在
- * 病态输入上爆回溯栈(`RangeError`:≥2^23 单段那一形已由 S-219 的 `atLeast` 铸点闭掉,JSON 秘密字段臂的转义对循环与
- * PEM 栅栏臂的标签交替循环由 S-265 换成手写扫描器闭掉 —— 已知形全部闭掉,本段写的是「当时为什么要总函数化」),
+ * 病态输入上爆回溯栈(`RangeError`:≥2^23 单段那一形已由 [ref] 的 `atLeast` 铸点闭掉,JSON 秘密字段臂的转义对循环与
+ * PEM 栅栏臂的标签交替循环由 [ref] 换成手写扫描器闭掉 —— 已知形全部闭掉,本段写的是「当时为什么要总函数化」),
  * 两条叶各能抛一次。总函数化照留:它兑现的是「坏字节一律 withhold」这条**结构**,不依赖脱敏器今天抛不抛。
  *
  * 抛出去的代价按腿算,而且一条比一条重:写腿落账那处的 `.catch` 看不到**同步**投影期的异常;读腿上它
@@ -178,7 +179,7 @@ export declare function toolStartEventData(ev: {
  */
 export declare function screenedGate(v: unknown): GateOutcome | undefined;
 /**
- * 🔴 **账本裸回放面的读腿一步**(S-239)—— `GET /v1/runs/:id/events`(`http/routes/runs.ts` 的
+ * 🔴 **账本裸回放面的读腿一步**([ref])—— `GET /v1/runs/:id/events`(`http/routes/runs.ts` 的
  * `formatEvent`)对每一行走这一口,把行上的 `GateOutcome` 交给**同一只** {@link screenedGate}。
  *
  * ## 它补的是哪一格
@@ -196,7 +197,7 @@ export declare function screenedGate(v: unknown): GateOutcome | undefined;
  * ## 读腿与写腿现在是**同一只**筛(零双读)
  * 7.72.0–7.73.0 期间读腿多一步「认本服务上一版写下的退役词旧拼法」(`unresolvable` → `ancestor_marked`),
  * 那是一条**长期双读臂**:同一份字节在写腿与读腿上有两种理解,而且没有到期日。7.74.0 把它换成**一次性
- * 迁移**(启动期把存量字节原地改名;窗关后已删码)。S-1542(core 7.51.0 #1731)起这只筛是 core `screenGateOutcome(g)` 缺省的**档案读法**
+ * 迁移**(启动期把存量字节原地改名;窗关后已删码)。[ref](core 7.51.0 [ref])起这只筛是 core `screenGateOutcome(g)` 缺省的**档案读法**
  * (每个闭集 = 今日成员 ∪ core `RETIRED_MEMBERS`),读腿与写腿同走它:残留旧拼法的字节(local 车道引擎 File 店里不可改写的已决行)
  * **整条读回、原词上帧、计数 0**(档案词是当年合法铸下的事实,不是缺陷,不改写成今天的词);整条 withhold + 计数的只有真缺陷
  * (集外且不在退役表的词、破不变量、形坏)。读法只有一种。
@@ -210,12 +211,12 @@ export declare function screenedGate(v: unknown): GateOutcome | undefined;
 export declare function screenedStoredEventData(type: string, data: unknown): unknown;
 /** `text_end` 段末帧的**唯一**铸点(三腿共用:top stream / 转发子代腿 / 子代 tail 面)。content = 段权威全文 ⇒ 与
  *  durable 面(`result` / 账本 `text` 行)同一只 {@link redactModelText}(认出才改写、抛则占位、不设上限)。
- *  此前三处各自逐字透传 —— 同一份文本毫秒后在 `done.result.result` 上已脱,live 面却在凭据生成瞬间明文(B-114)。
- *  `text_delta` 仍逐字:跨 chunk 的凭据无法就地判;clay [ref] ②(2026-09-18)裁定**维持逐字成文**(S-270 U-3 关票),
+ *  此前三处各自逐字透传 —— 同一份文本毫秒后在 `done.result.result` 上已脱,live 面却在凭据生成瞬间明文([ref])。
+ *  `text_delta` 仍逐字:跨 chunk 的凭据无法就地判;clay [ref] ②(2026-09-18)裁定**维持逐字成文**([ref] U-3 关票),
  *  权威段 `text_end.content` 已脱敏、消费端段末整段替换即得脱敏读法。
  *  坏形(content 非串/空串)⇒ null(丢帧,不铸「权威空段」:core 契约明言空段不发本帧,消费端收到空段会清掉已攒 delta)。
  *  身份**四键**随行(live 现状带全四键,消费端可能已依赖);值经 {@link identityKey} —— 非空 string 才上 wire
- *  (S-334 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
+ *  ([ref] 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
 export declare function textEndEventData(ev: Record<string, unknown>): SegmentEndFields | null;
 /**
  * live 面的**身份四键**(core `TaskEventIdentity` 全集)—— 一个属主,两处共用({@link segmentEndFields}
@@ -223,7 +224,7 @@ export declare function textEndEventData(ev: Record<string, unknown>): SegmentEn
  * **只剩键集**:那边两键(durable builder 对另两键的既定排除),这边四键(live 现状,消费端已依赖);
  * **值判据是同一条** —— 两只都问 {@link identityKey}(非空 `string` 才上 wire,绝不强转)。
  *
- * 🔴 **型必须说得出口**(S-334):`eventId` 是 live 腿 SSE `id:` 行的**唯一**来源,而 `id:` 行是续流游标
+ * 🔴 **型必须说得出口**([ref]):`eventId` 是 live 腿 SSE `id:` 行的**唯一**来源,而 `id:` 行是续流游标
  * ——一个连值的型都说不出的键不许铸成游标。非串/空串 ⇒ 键缺席(与「无锚不发 `id:` 行」同一条纪律:
  * 不可锚的位置绝不伪装成可锚)。转发子代腿的帧是 UNTRUSTED RAW(§E1),这一道同时是它的形判门。
  *
@@ -308,12 +309,12 @@ export declare function toolEndEventData(ev: {
  * 真源是 `tool_end`(core 明写 `elapsedTimeSeconds` **不等于** `tool_end` 的 duration)。
  *
  * ## 信任划线
- *  · `toolCallId` / `toolName` —— 调用 id(🔴 S-283 订正:出身是**服务商**在 tool_use / tool_calls 里给的,引擎缺席时自铸兜底、越界时折叠 ——
+ *  · `toolCallId` / `toolName` —— 调用 id(🔴 [ref] 订正:出身是**服务商**在 tool_use / tool_calls 里给的,引擎缺席时自铸兜底、越界时折叠 ——
  *    此前写「引擎铸」不实)与名册里的工具名(与 `tool_start` 逐字同源)⇒ verbatim。调用 id 这一族的形状在**全部面的共同入口**一次施加 ——
- *    core 7.36.0(#1207)brain 建调用那一行的准入(在形原样 / 越界单射折叠,原字节只在转录 `ToolCall.wireId`),一方 brain 新铸的调用在逐帧面上
- *    恒是在形的引擎 id(残余两条 S-921:≤7.106.0 写下的存量行 resume 出来的帧是服务商原串逐字;宿主 Brain 不准入 KL-1207-a —— 详见
+ *    core 7.36.0([ref])brain 建调用那一行的准入(在形原样 / 越界单射折叠,原字节只在转录 `ToolCall.wireId`),一方 brain 新铸的调用在逐帧面上
+ *    恒是在形的引擎 id(残余两条 [ref]:≤7.106.0 写下的存量行 resume 出来的帧是服务商原串逐字;宿主 Brain 不准入 KL-1207-a —— 详见
  *    run-terminal `admitProviderEcho` 顶注);
- *    本仓不设第二道闸(见 run-terminal `admitProviderEcho` 顶注;S-890 关)。
+ *    本仓不设第二道闸(见 run-terminal `admitProviderEcho` 顶注;[ref] 关)。
  *  · `elapsedTimeSeconds` —— 引擎铸的整秒,单调、一 call 一个原点 ⇒ 有限数才铸键。
  *  · `output` —— 🔴 **UNTRUSTED RAW**,core 逐字「exactly as `tool_end.output`: process output that may
  *    carry secrets, paths or PII; core bounds only its SIZE, and a consumer MUST redact before persisting
@@ -489,7 +490,7 @@ export declare function taskNotificationEventData(ev: {
          *  `kind` 过闭集(`trace/sema-provenance.ts` 单点,park 半场同一判据);`agentType` 本 mount 恒缺席(工具无
          *  agent-type 席),在场即透传(fleet spawn 帧按 taskId 可 join 时上游给)。 */
         _sema_provenance?: SemaProvenanceInput;
-        /** core 7.30.0 [ref] S1 / #1034 / #1036(S-616):委派终态帧三枚 facet + 重供两键 —— 判据单点在
+        /** core 7.30.0 [ref] S1 / [ref] / [ref]([ref]):委派终态帧三枚 facet + 重供两键 —— 判据单点在
          *  `trace/task-notification-facets.ts`(与 park 半场同一只;入参按 `unknown` 收、判过形才成 typed)。 */
         spawnName?: string;
         handback?: string;
@@ -593,7 +594,7 @@ export declare function compactionOutcomeEventData(ev: {
     reason?: SafeText;
 }>;
 /**
- * `compaction_started`(S-1732,core 7.53.0 #2008)—— 一次压缩 pass 在提交点(触发闸过了、切点在、`preCompact` 没拦)宣告开始,先于摘要调用:
+ * `compaction_started`([ref],core 7.53.0 [ref])—— 一次压缩 pass 在提交点(触发闸过了、切点在、`preCompact` 没拦)宣告开始,先于摘要调用:
  * 一次在供应方重试表里等很久的摘要(core 实测 503 × 11、173 s)从此在流上不是静默的。**原样投影**:`{ trigger, pass, startedAt }` + 身份两键,
  * 不自铸相位、不铸 run / session id(那是流的,不是帧的键)。三键都是引擎铸的闭形值:`trigger` 闭集词(`auto` / `manual` / `forced`,与结束帧同一张词表)、
  * `pass` 不透明 id(结束这次 pass 的那一帧 —— `compacted` 或 `compaction_outcome` —— 带同一个 `pass`)、`startedAt` 引擎时钟 epoch 毫秒 ⇒ 不脱敏、逐字;
@@ -693,7 +694,7 @@ export declare function workspaceChangedEventData(ev: {
  *       两词:core 只看合成后的 caps deny 位,本仓分得出这个 false 是 center 下发的还是本地 env 写的)。
  *       ⚠️ **`settings_denied` 不折进 `denied`,它折进 `no_intent`**(codex 车BO r1 [medium] 验真后纠):
  *       settings 层的 kill-switch 折的是**模式**(`effectivePermissionMode`:auto → default),于是 resolve-spec
- *       阶段④ 写的 `TaskSpec.permissionMode` 是 `"default"`(S-877 前是「不写意图座 `autoModeRequested`」)⇒ core 的武装谓词第一项就落空;
+ *       阶段④ 写的 `TaskSpec.permissionMode` 是 `"default"`([ref] 前是「不写意图座 `autoModeRequested`」)⇒ core 的武装谓词第一项就落空;
  *       而本地 env 腿折的是 **caps**(`applyLocalAutoModeDeny`),模式照写 `"auto"` ⇒ core 才报 `denied`(并按 `operator_deny` 折 default、发
  *       `config.permission_mode_unavailable`)。两条腿在 manifest 上
  *       **分不开**,要分辨得读 `/v1/capabilities`。对照表与保鲜钉在 `test/wiring-manifest-projection.test.ts`
@@ -705,7 +706,7 @@ export declare function workspaceChangedEventData(ev: {
  *       抛)。账本回放/第三方 producer 送来的矛盾对若原样上 wire,按 `armed` 读与按 `reason` 读的消费端会得到
  *       **相反**的答案 —— 这条轴上(@cli `sema doctor permissions` 正读它)两个答案比没答案更坏 ⇒ 整段不铸。
  *       这不是改语义:它与本函数「畸形值一律按缺席」是同一条规则,而这条不变量是 core 自己写的段内契约。
- *  · `mcp[]`(`WiringManifestMcpEntry[]`;core 7.5.0 [ref],S-124 提货件)—— **裁:租户可见,逐条目挑键,
+ *  · `mcp[]`(`WiringManifestMcpEntry[]`;core 7.5.0 [ref],[ref] 提货件)—— **裁:租户可见,逐条目挑键,
  *    `error` 一格不投**。
  *    ① **同主体同受众**:它是 per-leg 的读面「我这条腿申报的每台 MCP 服务器,连上了没有、挂了是哪一类、
  *       挂上来几个工具」。同一主体(调用方自己的 run)、同一条轴上,本仓早已把**更粗**的同类事实投给
@@ -729,7 +730,7 @@ export declare function workspaceChangedEventData(ev: {
  *       (「connection state is a fact about this leg's attempt, not about the assembly」)。
  *    ⚠️ 空数组 ≠ 缺席:core 顶注逐字「an empty array is "this leg declared no servers", absence is an older
  *       mint or an external derivation」⇒ 空数组照铸,别折成缺席。
- *    🔴 **⑤ `liveness`(core 7.24.3 [ref] / S-402 提货件)—— 裁:租户可见,整条记录投,逐键挑**。
+ *    🔴 **⑤ `liveness`(core 7.24.3 [ref] / [ref] 提货件)—— 裁:租户可见,整条记录投,逐键挑**。
  *       `{state, observedAt, errorCode?}` = 引擎**最后一次观察**到的「这台还够得着吗」。受众判据与同行
  *       其余键**同一条**(同主体同受众、引擎派生的闭形值、非 governance 侧信道 —— 它同样不进
  *       `configFingerprint`),所以这一格不需要新的裁定,只需要新的**读法**。
@@ -746,17 +747,17 @@ export declare function workspaceChangedEventData(ev: {
  *       而经过本投影后**判形没过也落缺席**(词出闭集 / `observedAt` 非有限数 / 整只不是对象)。
  *       ⇒ 对消费端,缺席只能读成「**没有可用的观察记录**」,**不许**据它反推这条腿拨没拨过号。
  *  · `writeProtection`(`{ targetView: "spelling-only" | "target" }`;core 7.20.1 [ref] / clay [ref] 丙,
- *    S-361 提货件)—— **裁:租户可见,逐字透传**。它是 per-leg 的读面:「这条腿的写保护判官,拿到的是
+ *    [ref] 提货件)—— **裁:租户可见,逐字透传**。它是 per-leg 的读面:「这条腿的写保护判官,拿到的是
  *    哪一种目标读法」——`"target"` = 判官握着执行环境,拼法没命中时会在**解析后的真目标**上再判一次;
  *    `"spelling-only"` = 没有环境,拼法就是全部判决,只经别名/软链够到受保护行的写被清掉。
  *    ① **同主体同受众**:同一条腿、调用方自己的 run。而且这件事对该调用方**本就行为可观测** —— 在无手
- *       车道上用一只声明了 `pathTarget` 写面的 MCP 工具对别名写一次就看得见(S-361 亲核可达)。剥掉它
+ *       车道上用一只声明了 `pathTarget` 写面的 MCP 工具对别名写一次就看得见([ref] 亲核可达)。剥掉它
  *       并不收走任何能力,只收走那句诚实的标签,等于把 [ref] 刚刚消灭的**静默**在租户半场原样重建。
  *    ② **值的形**:core 的**两词闭集**,判据走 core 导出的 `WRITE_PROTECTION_TARGET_VIEWS` 常量(不抄
  *       词表 —— 与 `delivered` 的 `MCP_DELIVERY_VERDICTS` 同一条);引擎派生、非用户内容 ⇒ 不脱敏、逐字。
  *    ③ 🔴 **最小披露仍然成立**:本键只答「判官有哪一种读法」,**从不**答「判官握着哪些路径」——
  *       名表逐行内容(`rows` / `source` / `droppedDefaultRows`)照旧只在 operator 面
- *       (`GET /v1/diagnostics/wiring` 的 `writeProtection` 键,S-138),租户面照旧只有
+ *       (`GET /v1/diagnostics/wiring` 的 `writeProtection` 键,[ref]),租户面照旧只有
  *       `/v1/capabilities.writeProtection.{armed, rows, replaced}` 三项计数。两者语义不同、同名不同物:
  *       诊断面那一格是**本 server 装配的名表**(boot 产物),本段是**core 判官的自报读法**(per-leg)。
  *    ④ **不是 governance 侧信道**:它是「这条腿接没接手」的函数,与 lockedConfig/compliance/
@@ -765,7 +766,7 @@ export declare function workspaceChangedEventData(ev: {
  *    ⚠️ **缺席 = 第三态**:core 的段是 **present-iff 编译出了判官**,`writeProtectedPaths: []` 的部署
  *       整段缺席。缺席**绝不**折成 `"spelling-only"`(那是「判官在、但只认拼法」,完全不同的一件事),
  *       也不铸 `writeProtection: {}`。词出闭集同样**不**折进缺席,走 `dropProjectedFace` 留痕(见那里)。
- *  · `autoConsolidation`(`{ onRecommendation: true }`;core 7.21.0 [ref],S-362 提货件)—— **裁:operator
+ *  · `autoConsolidation`(`{ onRecommendation: true }`;core 7.21.0 [ref],[ref] 提货件)—— **裁:operator
  *    受众,租户面剥**,所以它**不在本构造器里**,在 {@link wiringManifestOperatorEventData}。四条判据逐字在
  *    `core-keyset-guard.ts` ⑥b 的 `WiringSectionExcluded` 那一行(与 `governance` / `configFingerprint`
  *    同表同处,免得同一条裁定有两个写者)。一句话:它是**出口事实**(武装 = 每个建议任务之后整库记忆自动
@@ -773,15 +774,15 @@ export declare function workspaceChangedEventData(ev: {
  *    并且它对调用方**本就不可观测**(整理跑在终端 harvest 之后、fire-and-forget、宿主侧),剥掉它不收走
  *    任何能力 —— 这正是 `writeProtection` 判据①**不成立**的那一格。
  *    ⚠️ **缺席 = 未武装**(core present-iff),不折 `false`、不读「未知」。
- *    🔴 **S-403(7.85.0)起本条要连着 `core-keyset-guard.ts` ⑥b 判据②的补句读**:同一个事实在会话面
+ *    🔴 **[ref](7.85.0)起本条要连着 `core-keyset-guard.ts` ⑥b 判据②的补句读**:同一个事实在会话面
  *    (`GET /v1/sessions/:id/memory-status` 的 `autoConsolidationArmed`)是可读的,而这一段仍然剥 ——
  *    「一个事实一张脸」,两处同源、唯一读点。裁定正文在那一处,这里不抄第二份。
- *  · `readDeny`(`{ builtinTiers: readonly string[] }`;core 7.22.0 [ref],S-417 提货件)—— **裁:operator
+ *  · `readDeny`(`{ builtinTiers: readonly string[] }`;core 7.22.0 [ref],[ref] 提货件)—— **裁:operator
  *    受众,租户面剥**,所以它**不在本构造器里**,在 {@link wiringManifestOperatorEventData}。四条判据逐字在
  *    `core-keyset-guard.ts` ⑥b 的 `WiringSectionExcluded` 那一行(与 `governance` / `configFingerprint` /
  *    `autoConsolidation` 同表同处,免得同一条裁定有两个写者)。一句话:它答的是**这台部署选了哪几档内置
  *    敏感路径 deny 表**——一条部署治理面的**选择**,与 `writeProtection` 那种「这条腿手里有什么设施」的
- *    自述不同族;而且它是本仓 env `READ_DENY_BUILTIN_TIERS` 的生效读出口,名表面归 operator(S-138)。
+ *    自述不同族;而且它是本仓 env `READ_DENY_BUILTIN_TIERS` 的生效读出口,名表面归 operator([ref])。
  *    ⚠️ **缺席 = 没有内置行判这条腿**(core present-iff:实质激活至少一行才铸),**不是**「没有读被 deny
  *    判」—— 部署自己的 `readDenyPatterns` 刻意不上报(模式文本是部署材料,不是枚举)。**空数组永不发出**
  *    (「关」与「开到什么都不判」是同一个事实)⇒ 收到空数组按**坏 producer** 处置并留痕,见那里。
@@ -792,10 +793,10 @@ export declare function workspaceChangedEventData(ev: {
  * `core-keyset-guard.ts` ⑥b —— 那才是「core 加了段/加了成员」的可靠红点,两道并用缺一不可。
  */
 /**
- * 🔴 **`wiring_manifest.mcp[]` 一行上 wire 的形 —— 全仓唯一属主**(S-481 从 {@link wiringManifestEventData}
+ * 🔴 **`wiring_manifest.mcp[]` 一行上 wire 的形 —— 全仓唯一属主**([ref] 从 {@link wiringManifestEventData}
  * 的内联 IIFE **逐字**提出来,零行为变化;既有钉在 `test/wiring-manifest-projection.test.ts`)。
  *
- * 为什么必须是一只具名函数:S-481 又开了两条读面(`GET /v1/capabilities/mcp` /
+ * 为什么必须是一只具名函数:[ref] 又开了两条读面(`GET /v1/capabilities/mcp` /
  * `POST /v1/capabilities/mcp/probe`),它们发的是**同一种**行。留在内联里,那两条面只能各自再挑一遍键
  * —— 而契约 §G.7 第 3 条(`error` 远端原话**有意不投**,理由是「再脱一遍就是同一语义面的第二个写者」)
  * 这种**裁定**一旦有两个实现,下一个人只会改到其中一个。
@@ -821,7 +822,7 @@ export declare function projectWiringManifestMcpRows(mcpIn: unknown): Array<Reco
  * `tool_end` 之前),`delta.fromDigest` = 消费端手上那份名册的 digest。7.66.0 写下的「前瞻接线」披露随本版
  * 退役:本臂现在会真的触发,消费端可以依赖它了。
  *
- * 🔴 **三腿共用本构造器(S-212,7.71.0)**:live 腿(`routes/tasks.ts`)+ 两条 durable 腿
+ * 🔴 **三腿共用本构造器([ref],7.71.0)**:live 腿(`routes/tasks.ts`)+ 两条 durable 腿
  * (`trace/ledger-sink.ts` 的 `onEvent` / `http/server.ts` 的 resume switch)。返回 `undefined` 的那一格在
  * 三腿上是同一件事 ——**整帧不发 / 整帧不落账**,绝不半张名册上 wire 或落库。落账的正当性(旧裁定
  * 「不落账」为何在 7.71.0 撤销)逐字记在 `core-keyset-guard.ts` ⑪ 段。
@@ -832,12 +833,14 @@ export declare function toolRosterDeltaEventData(ev: {
     parentToolCallId?: unknown;
 }): Record<string, unknown> | undefined;
 /**
- * 🔴 S-961(7.111.0)**第二参 `instructions` 必传**(值可以是 `undefined`):`wiring_manifest` 上唯一一段**本仓自铸**的段
- * —— 这条腿的 project-memory loader 选中的指令文件链成员,`{ selected: string[] }`。它不在 core 的 manifest 里(core 不持有
- * 选择规则),所以不从 `ev` 读:每条投帧的腿把**自己那只** `InstructionSelectionLeg.segment()` 递进来。必传而不是可选 ——
- * 漏递的腿当场 tsc 红,而不是静默投出一个「缺席」(缺席在 wire 上是一句话:「这条腿没有关于指令文件的陈述」)。
- * `undefined` ⇒ 段缺席;`{ selected: [] }` ⇒ 显式空(走了链、没选中)。登记:`wire-projection-faces.ts` 租户行 `minted`。
+ * `wiring_manifest.sessionRules` 段的**处置表**(core 7.55.0 [ref];[ref] 起新面写表 —— 门 `core-keyset-guard.ts` ⑥b 读 `TableCoreKeys`,core 给段加成员 ⇒ tsc 红,
+ * 先判受众再写进表)。唯一一位 `childrenReadLive` 是布尔才出门(读法拒 ⇒ 表的丢弃口计一次)。裁定 = 两个出口都投(理由在 ⑥b 段注)。
  */
+export declare const WIRING_SESSION_RULES_DISPOSITIONS: {
+    readonly childrenReadLive: {
+        readonly forward: (raw: unknown) => raw is boolean;
+    };
+};
 export declare function wiringManifestEventData(ev: {
     manifest?: unknown;
     eventId?: unknown;
@@ -864,7 +867,7 @@ export declare function wiringManifestEventData(ev: {
  * governance **逐键挑**(禁 `{...governance}`):core 往这个段里加第五键时必须由人显式处置,而不是顺着
  * spread 裸上线 —— 这个段的每一键都是部署治理面,新键的默认待遇必须是「不发」。
  *
- * `autoConsolidation`(core 7.21.0 [ref],S-362)与 governance 同规:租户面剥、本面发(裁定四条判据在
+ * `autoConsolidation`(core 7.21.0 [ref],[ref])与 governance 同规:租户面剥、本面发(裁定四条判据在
  * `core-keyset-guard.ts` ⑥b `WiringSectionExcluded`)。**present-iff 武装**:
  *  · 整段缺席 ⇒ **未武装**,不铸键、不计数(正面事实,不是「未知」,更不是 `{onRecommendation:false}`);
  *  · 在场且 `onRecommendation === true` ⇒ 逐字铸出(core 的在场形只有这一个,构造期门已拒掉「武装但跑不起来」);
@@ -880,7 +883,7 @@ export declare function wiringManifestOperatorEventData(ev: {
     parentToolCallId?: unknown;
 }, instructions: InstructionsSegment | undefined): Record<string, unknown>;
 /**
- * `wiring_manifest` 的**唯一分叉点**(S-528)—— 两条知道调用方身份的 live 消费腿共用它:
+ * `wiring_manifest` 的**唯一分叉点**([ref])—— 两条知道调用方身份的 live 消费腿共用它:
  * `/v1/tasks/stream` 的 SSE 帧,与 `POST /v1/tasks`(非流式)200 体里的 `wiringManifest` 起手回执。
  *
  * 🔴 **为什么是一只函数,而不是两处 `cond ? operator : tenant`**:那个三元判的是「这份产物给谁看」——
@@ -996,7 +999,7 @@ export declare function compactedEventData(ev: {
      *  的数、post 恒是结构和 + 固定提示词开销,两者的差混坐标,实测在普通 run 上是负数)。本仓的处置因此
      *  是**三条都逐字透传、一条都不合成**:谁要画上下文表就读 `freedTokens`,读不到就渲染 unknown。 */
     freedTokens?: number;
-    /** core 7.30.0 #1036(S-616):这一次压缩**摘要掉**了几条之前已交给模型的跨会话消息(在场 iff ≥1)。 */
+    /** core 7.30.0 [ref]([ref]):这一次压缩**摘要掉**了几条之前已交给模型的跨会话消息(在场 iff ≥1)。 */
     summarizedCrossSessionMessages?: number;
     durationMs?: number;
     phaseDurations?: {
@@ -1005,7 +1008,7 @@ export declare function compactedEventData(ev: {
         persistMs?: number;
         ptlRetries?: number;
     };
-    /** S-1732(core 7.53.0 #2008):这次落地的压缩 pass 的 id —— 与它的 `compaction_started` 帧同一个值(引擎在每次落地上都设;型上可选)。逐字。 */
+    /** [ref](core 7.53.0 [ref]):这次落地的压缩 pass 的 id —— 与它的 `compaction_started` 帧同一个值(引擎在每次落地上都设;型上可选)。逐字。 */
     pass?: string;
 }): FrameData<{
     attachedFiles?: Array<{
@@ -1026,7 +1029,7 @@ export interface TraceTurn {
      *  cache-MISS 分量(命名取自 core `uncachedInputTokensOf`),只在能确认自己踩在新契约帧上时才发
      *  (见 {@link toContractTokens})。
      *
-     *  🔴 **S-213⑥:五个子键**全部按同族 OMIT 契约走 —— 引擎那一侧报了才铸,没报就**缺席**,恒不折 `0`。
+     *  🔴 **[ref]⑥:五个子键**全部按同族 OMIT 契约走 —— 引擎那一侧报了才铸,没报就**缺席**,恒不折 `0`。
      *  `in`/`out` 此前是必填座、缺一键时写 `?? 0`:读端拿到的 `in:0` 与「这一轮真的零输入」逐字节同形,
      *  于是一次 usage 半缺(某些 provider 只回 output 侧)在面板上显示成一个可核对的真数字。
      *  0 是一个数,未知不是 —— 两者同形正是本仓 `boundCallId`/`gateKind`/`approvalCard` 一族一直在防的事。
@@ -1076,13 +1079,29 @@ export declare function contextUsageEventData(ev: {
  * (`ledger-sink.ts`)、resume 腿(`resume-legs.ts`)。live 臂此前是一份**手抄**的键集,于是 core 7.29.0 加的
  * `responseModel` 在 durable 面由这里补上以后,live 面仍会被那份手抄静默剥掉 —— 同一帧两条腿两套键集。
  *
- * `responseModel`(core 7.29.0 #1029):**供应商自己**报的、回答这一 turn 的模型名,**只在**它 ≠ 请求所带 id
+ * `responseModel`(core 7.29.0 [ref]):**供应商自己**报的、回答这一 turn 的模型名,**只在**它 ≠ 请求所带 id
  * 时在场。缺席 = 「报了同名」或「没报」,**一个读法**(请求 id 读 `TaskResult.model`)。值是供应商铸的名字
- * (与 `apiFailure.requestId` 同类:不是模型写的自由文本)⇒ 🔴 **S-283 起过 provider 回声的形状闸**
- * ({@link admitProviderEcho}:长度 1–128 的可见 ASCII 原样,越界 ⇒ 不铸键 + 计数,与 core #1204 源头闸同一条;不过脱敏器),
+ * (与 `apiFailure.requestId` 同类:不是模型写的自由文本)⇒ 🔴 **[ref] 起过 provider 回声的形状闸**
+ * ({@link admitProviderEcho}:长度 1–128 的可见 ASCII 原样,越界 ⇒ 不铸键 + 计数,与 core [ref] 源头闸同一条;不过脱敏器),
  * 与结果面的孪生 `TaskResult.responseModel` 同一只闸 —— 同一个名字在两张脸上不许两种待遇。非串 / 空串同样不铸键(空串在
  * 那条谓词的长度下界之外;core 的读律 `providerReportedModel` 对空串也答「没报」)。
  */
+/**
+ * 🔴 core 7.54.0 [ref] O9b S1 —— 设备车道发射闸的 `permission.cross_boundary_taint` 帧 → 耐久行 `cross_boundary_taint`(`GET /v1/runs/:id/events` 账本回放同名交出;
+ * trace SSE `GET /v1/tasks/:id/stream` 上是 `cross-boundary-taint` 帧,按存下的行原样交出)。帧只在**执行于目标设备的树**上发(武装腿 prepare / 续跑腿 resume 各一帧,离目标读第一次放进树时 observed 一帧),
+ * 宿主车道零帧 ⇒ 本行在宿主车道上永不出现。纯元数据(core 逐字「Metadata only」):树的污染位(`taint`,core `CROSS_BOUNDARY_TAINT_BITS` 的子集)、
+ * 树是否受治理(`governed`)、阶段(`phase`)、腿的 `runId`,observed 时那一只调用(`toolName` / `toolCallId`)。
+ * 信封(`kind` / `version` / `taskId` / `ts`)不上行:行自带 seq / ts,run 就是 taskId(与清单行同一条律;登记表 `cross_boundary_taint` 行)。
+ * 值:`taint` 交一份数组副本(只收串);`toolName` / `toolCallId` 在场才铸。词按开集串过境(属主是引擎的闭集;本仓不判词表)。
+ */
+export declare function crossBoundaryTaintEventData(ev: {
+    runId?: unknown;
+    phase?: unknown;
+    taint?: unknown;
+    governed?: unknown;
+    toolName?: unknown;
+    toolCallId?: unknown;
+}): Record<string, unknown>;
 export declare function turnEndEventData(ev: {
     usage?: unknown;
     usageMissing?: true;
@@ -1101,7 +1120,7 @@ export declare function turnEndEventData(ev: {
  *  `in` 落回旧值,读端零伤)。`uncachedIn` 只在**能确认自己踩在新契约帧上**(`totalInputTokens` 在场)时
  *  才发——旧帧的 `inputTokens` 是族依赖的旧语义,标成「uncachedIn(cache-MISS)」会是谎言。
  *
- *  🔴 S-213⑥:**一条规则管五个子键** —— 源侧在场就铸、缺席就不铸,没有 `?? 0`。此前 `in`/`out` 两座
+ *  🔴 [ref]⑥:**一条规则管五个子键** —— 源侧在场就铸、缺席就不铸,没有 `?? 0`。此前 `in`/`out` 两座
  *  各带一个默认 0,于是 usage 半缺(provider 只回 output 侧)被投影成 `in:0` = 一个看起来可核对的真
  *  数字;`uncachedIn`/`cacheRead`/`cacheWrite` 三键从第一天起就是缺席制,`in`/`out` 只是漏进了默认值。
  *  早退分支语义不变:输入两键(择一)与 `outputTokens` 全缺 ⇒ 整只 `tokens` 缺席(不铸空对象)。
@@ -1109,7 +1128,7 @@ export declare function turnEndEventData(ev: {
  *  🔴 **7.74.0 / core 7.17.0([ref]):`usageMissing` 是本投影的输入,不只是事件面的一枚标。**引擎自该版起
  *  在「这一轮 provider 没回 usage 帧」时也**恒发** `turn_end.usage` —— 内容是六个 0 的占位对象,旁边挂
  *  `usageMissing: true`。只看 usage 会把「未测量」投成一只全 0 对象,与「真的零用量」在
- *  `GET /v1/tasks/:id/turns` 与 trace SSE 的 `turn` 事件上逐字节同形 —— 正是 S-213⑥「0 是一个数,未知不是」
+ *  `GET /v1/tasks/:id/turns` 与 trace SSE 的 `turn` 事件上逐字节同形 —— 正是 [ref]⑥「0 是一个数,未知不是」
  *  要消灭的那一形。契约里「未知 = `tokens` 整只缺席」早就是唯一读法 ⇒ 标在场就**不铸**(与 7.73.1 及以前的
  *  wire 读数逐字节相同),不按「六个 0」的值形猜、也不给 `TraceTurn.tokens` 加第二枚「未知」座(同一事实两种
  *  拼法)。标的域是 core 的 `true | 缺席`(永不 `false`)⇒ 严判 `=== true`,别的值不是标。 */

package/dist/trace/project.js

@@ -10,6 +10,7 @@ import { injectionTierOrAbsent } from "./injection-tier.js";
 import { semaProvenanceOrAbsent } from "./sema-provenance.js";
 import { resupplyFields, terminalFrameFacetFields } from "./task-notification-facets.js";
 import { dropProjectedFace } from "./projection-drop.js";
+import { projectByTable } from "./projection-table.js";
 export async function appendModelUsageDelta(append, modelUsage, taskId) {
     const delta = modelUsage?.drain(taskId);
     if (delta) {
@@ -24,10 +25,10 @@ export async function appendPromptManifest(append, tracker, taskId) {
     if (records)
         for (const m of records)
             await append("prompt_assembled", m);
-    const cfgs = tracker?.drainConfig?.(taskId);
-    if (cfgs)
-        for (const cfg of cfgs)
-            await append("config_assembled", cfg);
+    const companions = tracker?.drainCompanions?.(taskId);
+    if (companions)
+        for (const c of companions)
+            await append(c.type, c.data);
 }
 export async function attachModelUsage(result, ctx) {
     if (!ctx.modelUsage)
@@ -145,6 +146,15 @@ function screenedGateOrThrow(v) {
             ...(rel.mandate === undefined ? {} : { mandate: rel.mandate }),
             ...(rel.reason === undefined ? {} : { reason: rel.reason }),
         };
+    const clr = d.kind === "allowed" ? d.clearedBy : undefined;
+    const clearedBy = clr === undefined
+        ? undefined
+        : {
+            member: clr.member,
+            entries: clr.entries.map((e) => seatText("trace-frame-text", e)),
+            ...(clr.omitted === undefined ? {} : { omitted: clr.omitted }),
+            ...(clr.positions === undefined ? {} : { positions: [...clr.positions] }),
+        };
     return {
         disposition: d.kind === "denied"
             ? {
@@ -156,7 +166,7 @@ function screenedGateOrThrow(v) {
                 ...(d.askClass === undefined ? {} : { askClass: d.askClass }),
                 ...(d.classes === undefined ? {} : { classes: [...d.classes] }),
             }
-            : { kind: "allowed", ...(classifier === undefined ? {} : { classifier }), ...(released === undefined ? {} : { released }) },
+            : { kind: "allowed", ...(classifier === undefined ? {} : { classifier }), ...(released === undefined ? {} : { released }), ...(clearedBy === undefined ? {} : { clearedBy }) },
         ...(settlement === undefined ? {} : { settlement }),
         ...(g.origin === undefined ? {} : { origin: g.origin }),
     };
@@ -447,6 +457,9 @@ export function toolRosterDeltaEventData(ev) {
     }
     return { delta: ev.delta, ...identityFields(ev) };
 }
+export const WIRING_SESSION_RULES_DISPOSITIONS = {
+    childrenReadLive: { forward: (raw) => typeof raw === "boolean" },
+};
 export function wiringManifestEventData(ev, instructions) {
     const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
     const bool = (v) => (typeof v === "boolean" ? v : undefined);
@@ -641,12 +654,31 @@ export function wiringManifestEventData(ev, instructions) {
             return dropProjectedFace("wiring_manifest.permissionMode is not a receipt shape (effective a non-empty string, requested / foldedBy absent or non-empty strings)");
         return { ...(requested !== undefined ? { requested } : {}), effective, ...(foldedBy !== undefined ? { foldedBy } : {}) };
     })();
+    const sessionRules = (() => {
+        if (m.sessionRules === undefined)
+            return undefined;
+        const seg = sec(m.sessionRules);
+        if (seg === undefined || seg.childrenReadLive === undefined)
+            return dropProjectedFace("wiring_manifest.sessionRules is not { childrenReadLive: boolean }");
+        const out = projectByTable("wiring_manifest.sessionRules", WIRING_SESSION_RULES_DISPOSITIONS, seg, undefined);
+        return out.childrenReadLive === undefined ? undefined : out;
+    })();
+    const projectMemory = (() => {
+        if (m.projectMemory === undefined)
+            return undefined;
+        const word = str(m.projectMemory);
+        if (word === undefined)
+            return dropProjectedFace("wiring_manifest.projectMemory is not a non-empty string");
+        return word;
+    })();
     return {
         ...(num(m.schemaVersion) !== undefined ? { schemaVersion: m.schemaVersion } : {}),
         ...(str(legIn.kind) !== undefined ? { leg: { kind: legIn.kind } } : {}),
         ...(teamRole !== undefined ? { teamRole } : {}),
         ...(fileHistory !== undefined ? { fileHistory } : {}),
         ...(permissionMode !== undefined ? { permissionMode } : {}),
+        ...(sessionRules !== undefined ? { sessionRules } : {}),
+        ...(projectMemory !== undefined ? { projectMemory } : {}),
         ...(ask !== undefined ? { ask } : {}),
         ...(question !== undefined ? { question } : {}),
         ...(str(interactionIn.posture) !== undefined ? { interaction: { posture: interactionIn.posture } } : {}),
@@ -846,6 +878,16 @@ function contextUsageSectionsField(sections) {
     }
     return out.length > 0 ? { sections: out } : {};
 }
+export function crossBoundaryTaintEventData(ev) {
+    return {
+        ...(typeof ev.runId === "string" ? { runId: ev.runId } : {}),
+        ...(typeof ev.phase === "string" ? { phase: ev.phase } : {}),
+        ...(Array.isArray(ev.taint) ? { taint: ev.taint.filter((b) => typeof b === "string") } : {}),
+        ...(typeof ev.governed === "boolean" ? { governed: ev.governed } : {}),
+        ...(typeof ev.toolName === "string" ? { toolName: ev.toolName } : {}),
+        ...(typeof ev.toolCallId === "string" ? { toolCallId: ev.toolCallId } : {}),
+    };
+}
 export function turnEndEventData(ev) {
     return {
         ...(ev.usage ? { usage: ev.usage } : {}),
@@ -1004,6 +1046,8 @@ function mapTraceEventInner(type, seq, data) {
         }
         case "prompt_assembled":
             return { event: "prompt-assembled", data: { seq, ...data } };
+        case "cross_boundary_taint":
+            return { event: "cross-boundary-taint", data: { seq, ...data } };
         case "done":
             return { event: "done", data: { seq } };
         case "suspended":