@sema-agent/server 7.146.0 → 7.148.0

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

@@ -1,4 +1,4 @@
-import { type LiveEventIdentity, type SegmentEndFields } from "./project.js";
+import { type EventIdentity, type SegmentEndFields } from "./project.js";
 /**
  * 本帧是不是模型文本的段界。**四条消费腿共用这一只**:账本投影 switch(`trace/ledger-sink.ts`)、
  * 顶层 live 流与转发子代腿(`http/routes/tasks.ts`)、子代 tail 面(`fleet/subagent-tail-bus.ts`)。
@@ -14,7 +14,7 @@ export type ReasoningEndFrame = SegmentEndFields & {
 };
 /** 登记册**读到的全部字段**,逐个写出来(不是 `Record<string, unknown>`):`TaskEvent` 与转发腿的原始帧
  *  都结构性满足它,于是调用点一个宽断言都不必写;将来有人想读第八个键,得先在这里加一行。
- *  `type` 而不是 `interface`(与 `LiveEventIdentity` 同一条理由):`text_end` 的铸点收 `Record<string, unknown>`,别名才进得去。 */
+ *  `type` 而不是 `interface`(与 `EventIdentity` 同一条理由):`text_end` 的铸点收 `Record<string, unknown>`,别名才进得去。 */
 export type ModelStreamEvent = {
     type?: string;
     delta?: unknown;
@@ -32,7 +32,7 @@ export interface ModelStreamIdent {
     bgAgentId?: string;
 }
 /** live 面模型文本的帧(本登记册铸的全部四种):两族的逐块帧与各自的段末帧。 */
-export type LiveModelTextFrame = (LiveEventIdentity & {
+export type LiveModelTextFrame = (EventIdentity & {
     type: "text_delta" | "reasoning_delta";
     delta: string;
 }) | (SegmentEndFields & {
@@ -63,8 +63,8 @@ export type LiveModelTextFrame = (LiveEventIdentity & {
  * ## 帧数与身份(消费端看得见的三件事)
  *  · 引擎的每一块 delta 仍恰好一帧、同一枚 `eventId`、原序(`delta` 可以是 `""`:那一块的字节还在窗里)—— 续流游标与 E18 的首块句柄不动;
  *  · 段末还在窗里的字节在段末帧**之前**一帧放出(同一族的逐块帧,带流身份三键、**不带** `eventId` ⇒ 不发 `id:` 行:它不是引擎的内容帧);
- *  · 延迟:一个字节在同一条流又到了脱敏器的未决尾上界(`PENDING_TAIL_UNITS` 个读法单元,由脱敏器的臂表算出)之后的下一次重扫时出门(重扫节律在流式口里);
- *    盖住它的跨度还在判定(未收尾的栅栏 / 引号 / JSON 串值 …)⇒ 判定或段末。
+ *  · 延迟:一个字节在盖住它的判定都不再读到文本末尾之后的下一次重扫时出门(脱敏器的读口闭集定交出点;重扫节律在流式口里)—— 没有开着的判定 ⇒ 到的那一块就出;
+ *    盖住它的跨度还在判定(未收尾的栅栏 / 引号 / JSON 串值 …)、凭据词头写在末尾附近 ⇒ 判定或段末。
  *
  * ## 段界(与账本腿同一只谓词)
  * 两族都只在本流的段界词({@link isModelSegmentBoundary})与腿终局 / 子代终态({@link LiveModelText.cut})收段;引擎的 `text_end` 是块的交付点(上一节),不收段。

package/dist/trace/model-segment.js

@@ -1,7 +1,7 @@
 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 { OVERSIZED_REDACTION_PLACEHOLDER } from "./exit-seat.js";
+import { identityFields, reasoningEndEventData, textEndEventData } from "./project.js";
 import { dropProjectedFace } from "./projection-drop.js";
 import { createRedactionStream } from "./redact.js";
 const BOUNDARY = new Set([
@@ -93,7 +93,7 @@ export function createLiveModelText() {
         const out = [];
         const rest = remainderOf(family, s);
         if (rest !== "")
-            out.push({ type: deltaType(family), delta: rest, ...liveIdentityFields(s.ident) });
+            out.push({ type: deltaType(family), delta: rest, ...identityFields(s.ident) });
         if (family === "reasoning") {
             const data = reasoningEndEventData({ ...s.ident, eventId: s.segmentEventId, content: s.text.fed });
             if (data !== null)
@@ -127,7 +127,7 @@ export function createLiveModelText() {
         }
         if (!deliver)
             return [];
-        return [{ type: deltaType(family), delta: s === undefined ? "" : release(s), ...liveIdentityFields(ev) }];
+        return [{ type: deltaType(family), delta: s === undefined ? "" : release(s), ...identityFields(ev) }];
     };
     return {
         onEvent: (ev, deliver = true) => {
@@ -157,7 +157,7 @@ export function createLiveModelText() {
                     if (deliver) {
                         const rest = deliverBlock(s);
                         if (rest !== "" && endOnly === undefined)
-                            out.push({ type: "text_delta", delta: rest, ...liveIdentityFields(s.ident) });
+                            out.push({ type: "text_delta", delta: rest, ...identityFields(s.ident) });
                     }
                     closeBlock(s);
                 }

package/dist/trace/project.d.ts

@@ -24,11 +24,12 @@
  * 新加一只构造器 ⇒ 同批往登记表加一行,否则普查格红。
  */
 import type { GateOutcome, McpDelivered, TaskResult, SystemInjectionPriority } from "@sema-agent/core";
+import { type InputAuthor, type RunOrigin } 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 { ModelUsageDelta, ModelUsageTracker, PromptManifestTracker } from "../budget.js";
 import { type SafeText } from "./exit-seat.js";
-import { type SemaProvenanceInput } from "./sema-provenance.js";
+import { type SemaProvenanceWire } from "./sema-provenance.js";
+import { type CrossSessionMessageWire, type CrossSessionNoticeWire } from "./task-notification-facets.js";
 import { type ExtensionRequesterFace, type ToolInputRewriteFace } from "./extension-call-face.js";
 import type { LedgerEventType, ParkLedgerEventType } from "./ledger-events.js";
 import type { InstructionsSegment } from "../instruction-selection.js";
@@ -47,15 +48,23 @@ type GetEventsFn = (taskId: string, afterSeq: number) => Promise<RunEvent[]>;
  *  apart rows written under the current component semantics from older rows (pre-dating this label) when it
  *  sums across a run's whole event log. */
 export declare function appendModelUsageDelta(append: AppendFn, modelUsage: ModelUsageTracker | undefined, taskId: string): Promise<void>;
-/** [ref]② drain the pending prompt-manifest records (whitelisted at RECORD time, budget.ts — ids/digests/
- *  counts only, no prompt bodies by core's manifest contract) into durable `prompt_assembled` events, one per
- *  prepare IN EMISSION ORDER (a cascade/verify leg re-prepares under one taskId — every rung's manifest
- *  persists; release-review finding). Shared by both durable-write legs; a no-op when nothing is pending
- *  (one Map.get), so callers fire it liberally. */
-export declare function appendPromptManifest(append: AppendFn, tracker: {
-    drain(taskId: string): PromptManifestRecord[] | undefined;
-    drainCompanions?(taskId: string): RunCompanionRecord[] | undefined;
-} | undefined, taskId: string): Promise<void>;
+/** 一条腿在 run 级清单 / 伴随记录队列上的那一席(产物带方法 ⇒ `create*`)。 */
+export interface PromptManifestSeat {
+    /** 把这条腿已排队的清单行与伴随记录(按发射序)落进**这条腿的**账本写口;无待落 ⇒ 零 I/O(一次 Map 读),所以腿可以在每一帧之前调。 */
+    drain(append: AppendFn): Promise<void>;
+    /** 收摊:只在本席仍持租约时注销并丢弃未排空的记录(B-3 窗:一条快的兄弟续跑腿可能已经以同一 taskId 重新登记,那一席归它)。幂等。 */
+    release(): void;
+}
+/**
+ * **写账本的腿登记 run 级清单 / 伴随记录队列的唯一一只登记器**(`prompt_assembled` / `config_assembled` / `cross_boundary_taint` 三种行同一只队列)。
+ *
+ * 一条律:**有账本的腿就有这一席** —— bg 首跑(`runs.ts`)、续跑两径(`http/resume-legs.ts`)、同步流腿(`http/routes/tasks.ts`,有 durable run 行即有账本)
+ * 都经这一只:建席 = 登记(tracer 的 `record` / `recordCompanion` 只收已登记的顶层 run,子代永不登记)、`drain` = 落本腿账本、`release` = 带租约收摊。
+ * 腿只决定**在哪几拍排空**(每一帧之前 / 终局行之前),不再各写一份「登记 → 排空 → 租约清」—— 7.147.0 之前同步流腿漏了这一席,
+ * 它的账本因此一行清单 / 伴随记录都没有。非流式 `POST /v1/tasks` 结构上没有账本(契约 KL),没有这一席。
+ * `tracker` 缺席(部署没接)⇒ 席是空操作。
+ */
+export declare function createPromptManifestSeat(tracker: PromptManifestTracker | undefined, taskId: string): PromptManifestSeat;
 /** 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). */
 export declare function attachModelUsage<T extends TaskResult>(result: T, ctx: {
@@ -96,7 +105,7 @@ export declare function aggregateModelUsage(events: RunEvent[]): Record<string,
 export type TraceBlock = {
     type: "thinking";
     text: string;
-} | {
+} | ({
     type: "tool-call";
     id: string;
     name: string;
@@ -104,12 +113,10 @@ export type TraceBlock = {
     input: unknown;
     recovered?: true;
     requestedBy?: ExtensionRequesterFace;
-    eventId?: string;
-    parentToolCallId?: string;
-} | {
+} & EventIdentity) | {
     type: "content";
     text: string;
-} | {
+} | ({
     type: "tool-result";
     callId: string;
     label?: string;
@@ -127,12 +134,40 @@ export type TraceBlock = {
     answeredBy?: string;
     requestedBy?: ExtensionRequesterFace;
     rewrite?: ToolInputRewriteFace;
-    eventId?: string;
-    parentToolCallId?: string;
-} | {
+} & EventIdentity) | {
     type: "prompt-assembled";
     readonly [member: string]: unknown;
 };
+/**
+ * 内容帧的**身份**(core `TaskEventIdentity` 全集,四键)—— 引擎盖在每只内容帧上的那组键,本仓只有**这一只**投影:每只共享构造器都经它,
+ * live 帧、durable 账本行、trace 读投影(turns 面 / trace SSE 面)于是是同一组键,引擎盖了哪几枚就上哪几枚。
+ *  · `eventId` —— 引擎逐帧铸的 uuidv7(去重句柄 / 回卷锚;live 腿 SSE `id:` 行的唯一来源);
+ *  · `parentToolCallId` —— 委派子代的帧才有(这段属于哪一次委派调用);
+ *  · `sourceTaskId` —— 作为子代跑的任务的内容帧才有(起跑那只任务的 id,消费方按它把子代的帧归到子代);
+ *  · `bgAgentId` —— 后台子代经宿主转发道上来的帧才有(`a*` 句柄;嵌套时是最外层那一只)。
+ * 值判据一条({@link identityKey}:非空 `string` 才上 wire,绝不强转)。
+ *
+ * 🔴 **型必须说得出口**([ref]):`eventId` 是续流游标的来源 —— 一个连值的型都说不出的键不许铸成游标。非串 / 空串 ⇒ 键缺席(与「无锚不发 `id:` 行」
+ * 同一条纪律:不可锚的位置绝不伪装成可锚)。转发子代腿的帧是 UNTRUSTED RAW(§E1),这一道同时是它的形判门。
+ * [ref] 门①:条件展开的臂逐条是直写字面量(键名对扫描器可见)。
+ */
+export declare function identityFields(src: {
+    eventId?: unknown;
+    parentToolCallId?: unknown;
+    sourceTaskId?: unknown;
+    bgAgentId?: unknown;
+}): EventIdentity;
+/**
+ * {@link identityFields} 的形。🔴 **`type` 而不是 `interface`**(它与 {@link SegmentEndFields} 两处都是,别改回去):TS 只给**类型别名**
+ * 隐式索引签名,interface 没有 ⇒ 写成 interface 的话,每一个把本形交给 `Record<string, unknown>` 形参(tail 总线帧、live 帧写口)的调用点
+ * 都得手抄一次 `{ ...frame }` 展开。别名让「声明出来的形」原样流经既有写口,零调用点噪声。
+ */
+export type EventIdentity = {
+    eventId?: string;
+    parentToolCallId?: string;
+    sourceTaskId?: string;
+    bgAgentId?: string;
+};
 /**
  * 🔴 **模型自由文本账本行(`text` / `reasoning`)的唯一载荷铸点**([ref] / [ref],7.75.1)。
  *
@@ -227,42 +262,13 @@ export declare function screenedStoredEventData(type: string, data: unknown): un
  *  逐块的 `text_delta` 由 `trace/model-segment.ts` 的登记册铸(7.143.0 起经同一只脱敏器的放行窗,一段的逐块拼接 = 本帧 content);
  *  本函数由登记册在段末调,三腿不再各自调。
  *  坏形(content 非串/空串)⇒ null(丢帧,不铸「权威空段」:core 契约明言空段不发本帧,消费端收到空段会清掉已攒 delta)。
- *  身份**四键**随行(live 现状带全四键,消费端可能已依赖);值经 {@link identityKey} —— 非空 string 才上 wire
- *  ([ref] 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
+ *  身份经 {@link identityFields}(与每只共享构造器同一只;[ref] 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
 export declare function textEndEventData(ev: Record<string, unknown>, before?: string): SegmentEndFields | null;
-/**
- * live 面的**身份四键**(core `TaskEventIdentity` 全集)—— 一个属主,两处共用({@link segmentEndFields}
- * 与 sync 腿白名单 catch-all 的 `ident`;此前是两份手抄)。与 durable 面的 {@link identityFields} 的差别
- * **只剩键集**:那边两键(durable builder 对另两键的既定排除),这边四键(live 现状,消费端已依赖);
- * **值判据是同一条** —— 两只都问 {@link identityKey}(非空 `string` 才上 wire,绝不强转)。
- *
- * 🔴 **型必须说得出口**([ref]):`eventId` 是 live 腿 SSE `id:` 行的**唯一**来源,而 `id:` 行是续流游标
- * ——一个连值的型都说不出的键不许铸成游标。非串/空串 ⇒ 键缺席(与「无锚不发 `id:` 行」同一条纪律:
- * 不可锚的位置绝不伪装成可锚)。转发子代腿的帧是 UNTRUSTED RAW(§E1),这一道同时是它的形判门。
- *
- * 🔴 **`type` 而不是 `interface`**(它与 {@link SegmentEndFields} 两处都是,别改回去):TS 只给**类型别名**
- * 隐式索引签名,interface 没有 ⇒ 写成 interface 的话,每一个把本形交给 `Record<string, unknown>` 形参
- * (tail 总线帧、live 帧写口)的调用点都得手抄一次 `{ ...frame }` 展开。别名让「声明出来的形」原样流经
- * 既有写口,零调用点噪声。
- */
-export type LiveEventIdentity = {
-    eventId?: string;
-    parentToolCallId?: string;
-    sourceTaskId?: string;
-    bgAgentId?: string;
-};
 /** 段末帧(`text_end` / `reasoning_end`)的载荷**形**(两只帧一个字节不差 —— 一个 wire 概念一份形,
  *  消费端的读法只学一次;差别只有各自铸点的空段判据)。 */
-export type SegmentEndFields = LiveEventIdentity & {
+export type SegmentEndFields = EventIdentity & {
     content: string;
 };
-/** {@link LiveEventIdentity} 的铸点。[ref] 门①:条件展开的臂逐条是直写字面量(键名对扫描器可见)。 */
-export declare function liveIdentityFields(ev: {
-    eventId?: unknown;
-    parentToolCallId?: unknown;
-    sourceTaskId?: unknown;
-    bgAgentId?: unknown;
-}): LiveEventIdentity;
 /**
  * `reasoning_end` 段末帧的**唯一**铸点(三条 live 腿共用:top stream / 转发子代腿 / 子代 tail 面)——
  * `text_end` 的推理面孪生({@link textEndEventData}),形逐字同(共用 {@link segmentEndFields})。
@@ -456,7 +462,7 @@ export declare function appendParkRow(append: AppendFn, usage: ModelUsageSeat |
  *    不是模型自由文本);`startedAt` 是有限数才上 wire;
  *  · `name` / `workflowAgentLabel` —— UNTRUSTED 展示文本 ⇒ `redactSecrets`(同 `task_progress.name` / `.workflowAgentLabel`);
  *  · `spawnName` —— 出生点校验过的队友**身份键** ⇒ verbatim(理由全文在 {@link taskProgressEventData} 的同名键注);
- *  · 身份两键经 `identityFields`(信封上的 `sourceTaskId` / `bgAgentId` 不由本族构造器投,见 `FRAME_ENVELOPE_KEYS`)。
+ *  · 身份经 `identityFields`(四键,引擎盖了哪枚上哪枚 —— 与每只共享构造器同一只)。
  * 缺席即缺席:可选键缺席不铸键(`taskType` 缺席 = 前台子代,禁读作某个默认种类;`seq` 缺席 = 无 `a*` 行,禁读作 cycle 1)。
  */
 export declare function taskStartedEventData(ev: {
@@ -538,9 +544,12 @@ export declare function taskNotificationEventData(ev: {
             body: string;
         };
         /** 同批:typed 归因侧记(wire 键;core 契约「a host projects it, the model never sees it」)。成员逐个挑取,
-         *  `kind` 过闭集(`trace/sema-provenance.ts` 单点,park 半场同一判据);`agentType` 本 mount 恒缺席(工具无
-         *  agent-type 席),在场即透传(fleet spawn 帧按 taskId 可 join 时上游给)。 */
-        _sema_provenance?: SemaProvenanceInput;
+         *  `kind` 过闭集、`peerMeta` 逐成员(`trace/sema-provenance.ts` 单点,park 半场同一判据;入参按 `unknown` 收、判过形才成 typed)。 */
+        _sema_provenance?: unknown;
+        /** [ref]:会话箱车道的三只载体 —— 判据单点在 `trace/task-notification-facets.ts`(与 park 半场同一只;入参按 `unknown` 收)。 */
+        crossSessionMessage?: unknown;
+        crossSessionNotice?: unknown;
+        inboxNotice?: unknown;
         /** core 7.30.0 [ref] S1 / [ref] / [ref]([ref]):委派终态帧三枚 facet + 重供两键 —— 判据单点在
          *  `trace/task-notification-facets.ts`(与 park 半场同一只;入参按 `unknown` 收、判过形才成 typed)。 */
         spawnName?: string;
@@ -580,6 +589,9 @@ export declare function taskNotificationEventData(ev: {
         from: string;
         body: SafeText;
     };
+    _sema_provenance?: SemaProvenanceWire;
+    crossSessionMessage?: CrossSessionMessageWire;
+    crossSessionNotice?: CrossSessionNoticeWire;
 }>;
 /** The `compacted` payload — EXPLICIT WHITELIST shared by all three legs (bg runs.ts + resume append + the sync
  *  live SSE frame; the 1.72 task_progress lesson: never `{...ev}`). trigger/tokensBefore (MF-18) verbatim;
@@ -647,7 +659,7 @@ export declare function compactionOutcomeEventData(ev: {
 }>;
 /**
  * `compaction_started`([ref],core 7.53.0 [ref])—— 一次压缩 pass 在提交点(触发闸过了、切点在、`preCompact` 没拦)宣告开始,先于摘要调用:
- * 一次在供应方重试表里等很久的摘要(core 实测 503 × 11、173 s)从此在流上不是静默的。**原样投影**:`{ trigger, pass, startedAt }` + 身份两键,
+ * 一次在供应方重试表里等很久的摘要(core 实测 503 × 11、173 s)从此在流上不是静默的。**原样投影**:`{ trigger, pass, startedAt }` + 身份(`identityFields`),
  * 不自铸相位、不铸 run / session id(那是流的,不是帧的键)。三键都是引擎铸的闭形值:`trigger` 闭集词(`auto` / `manual` / `forced`,与结束帧同一张词表)、
  * `pass` 不透明 id(结束这次 pass 的那一帧 —— `compacted` 或 `compaction_outcome` —— 带同一个 `pass`)、`startedAt` 引擎时钟 epoch 毫秒 ⇒ 不脱敏、逐字;
  * 形不合即缺席(与 {@link compactionOutcomeEventData} 同款守卫,不编值)。三条消费腿(live 帧、两条 durable 腿)共用这一只。
@@ -990,6 +1002,14 @@ export declare function wiringManifestFaceEventData(ev: {
  *  · `rewrittenBy[]`(core 7.62.0 [ref],只在腿的 prompt 屏 `prompt.submit` 改写过这条输入时在场)—— 改写它的扩展注册名,按改写序 ⇒ verbatim:
  *    名字的形由引擎在注册入口判(`MOD_REGISTRATION_NAME`,能引号 / 括号 / 折句的名在入口拒),与会话行上同名位(`audit.ts` 的 `rewrittenBy: "verbatim"`)
  *    同一读法。非数组不投、非串 / 空串成员丢、丢完为空不铸键(缺席 = 原样送达,不是空数组)。
+ *  · `author` / `extension`(core 7.66.0 [ref]:**谁写的这条输入**,不是本人时才在场 —— `"extension"` = 扩展经 `$.prompt.submit` 交的提示,`"observer"` = 观察者的
+ *    报告;缺席 = 本人(或替本人转述的宿主),公共动词的每条输入)—— `author` 是 core 闭集 `INPUT_AUTHORS` 的词(`isInputAuthor` 判,`"operator"` 不在帧上)⇒ verbatim;
+ *    `extension` = 发起它的注册名(引擎只在 `author: "extension"` 旁铸)⇒ 过 {@link sanitizeWireText}(与 `tool_start.requestedBy.name` 同一只注册名出口纪律)。
+ *    不投它们 = 扩展 / 观察者的输入在 wire 上读成无署名的本人输入(core 的话:never render a non-operator input as the person's)。形不对 ⇒ 丢那一位、计一次
+ *    `server.trace.projection-input-malformed`(纯归因位的丢弃律,见 `extension-call-face.ts`);两键的配对是引擎的不变式,本仓不复判。
+ *  · `attachments[].declinedBy`(core 7.66.0 [ref]:拒了这只附件的 `prompt.mention` 扩展,`ExtensionRequester` 形)⇒ 与 `requestedBy` 同一只读法 {@link extensionRequesterOf}。
+ *  · `runOrigin`(core 7.58.0 [ref] / [ref]:这条输入由部署的调度器交来,闭集 `RUN_ORIGINS`;缺席 = 宿主什么也没说,**从不**读成「有人发的」)⇒ 引擎词、归因位、无自由文本 ⇒ 逐字,
+ *    读法 {@link runOriginOnFrame}(与 `wiring_manifest.leg.runOrigin` 的 {@link runOriginOnLeg} 同一只 core 谓词 `isRunOrigin`、各一处丢弃口;四面一条规则见 `test/run-origin-faces.test.ts` 头注)。不投 = 渲染方把调度者的输入当成人敲的(core 点名的病)。
  *
  * `actor` 逐键挑(禁 spread):core 已声明 `ActorAssertion` 是冻结三键形,但白名单的意义正是「core 加第
  * 四键时由人处置」——身份对象上多出来的键裸上线是本文件反复登记的病族。
@@ -1007,6 +1027,9 @@ export declare function humanInputEventData(ev: {
     entryId?: unknown;
     attachments?: unknown;
     rewrittenBy?: unknown;
+    author?: unknown;
+    extension?: unknown;
+    runOrigin?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
 }): FrameData<{
@@ -1017,7 +1040,11 @@ export declare function humanInputEventData(ev: {
     }>;
     attachments?: Array<FrameData<{
         label?: SafeText;
+        declinedBy?: ExtensionRequesterFace;
     }>>;
+    author?: Exclude<InputAuthor, "operator">;
+    extension?: string;
+    runOrigin?: RunOrigin;
 }>;
 /** S4 (SILENT-FALLBACK P0-a): the durable `brain_status` observation row, shared by the bg + resume append
  *  sites. core marks the live `status` frame EPHEMERAL (never replayed by core on resume) — this row is the
@@ -1150,7 +1177,7 @@ export declare function contextUsageEventData(ev: {
  * (白名单没跟上 core 新增字段)。补 builder 的同时也就把它纳入了 `wire-whitelist-exhaustiveness` 的编译期差集门。
  *
  * 🔴 **本构造器是 `turn_end` 帧载荷的唯一铸点**(core 7.29.0 提货批,车LY):三条腿同调 —— live SSE
- * (`http/routes/tasks.ts` 的 `/v1/tasks/stream` 臂,身份键另由 `liveIdentityFields` 补四键)、durable 账本
+ * (`http/routes/tasks.ts` 的 `/v1/tasks/stream` 臂)、durable 账本
  * (`ledger-sink.ts`)、resume 腿(`resume-legs.ts`)。live 臂此前是一份**手抄**的键集,于是 core 7.29.0 加的
  * `responseModel` 在 durable 面由这里补上以后,live 面仍会被那份手抄静默剥掉 —— 同一帧两条腿两套键集。
  *
@@ -1166,7 +1193,10 @@ export declare function contextUsageEventData(ev: {
  * 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` 行)。
+ * 信封(`kind` / `version` / `taskId` / `ts`)不上行:账本行自带 seq / ts(`RunEvent`),行种类由账本行名说;`taskId` 不上行,是因为落进来的帧都是已登记的顶层 run 发的 ——
+ * 落账处 `PromptManifestTracker.recordCompanion` 只收已登记的 `taskId`(与清单行同一只登记门;`createPromptManifestSeat` 建席即登记,子代永不登记),行落进的就是这条 `taskId` 自己的账本,
+ * 所以根腿发的帧它就是 run;委派子代腿发的帧 `taskId` 是**子代腿自己的 id**(不是根 run)、未登记 ⇒ 落账处不收,这类帧今天落不进根 run 的账本
+ * (契约 §4a-cbt「读法」的限定;根归属候引擎给帧加根地址键)。登记表 `cross_boundary_taint` 行(`trace/wire-projection-faces.ts`)是同一句读法。
  * 值:`taint` 交一份数组副本(只收串);`toolName` / `toolCallId` 在场才铸。词按开集串过境(属主是引擎的闭集;本仓不判词表)。
  */
 export declare function crossBoundaryTaintEventData(ev: {

package/dist/trace/project.js

@@ -1,5 +1,5 @@
 import { admitProviderEcho, redactErrorMessage, redactModelText } from "../observability/run-terminal.js";
-import { MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROLES, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
+import { isInputAuthor, isRunOrigin, MCP_DELIVERY_VERDICTS, MCP_LIVENESS_STATES, screenGateOutcome, TEAM_ROLES, ToolRoster, ToolRosterDelta, WRITE_PROTECTION_TARGET_VIEWS } from "@sema-agent/core";
 import { Value } from "typebox/value";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets, redactDeep } from "./redact.js";
@@ -7,8 +7,8 @@ import { seatText } from "./exit-seat.js";
 import { sanitizeWireText } from "./engine-notice-wire.js";
 import { projectToolOutput, projectToolStructured } from "./tool-output-media.js";
 import { injectionTierOrAbsent } from "./injection-tier.js";
-import { semaProvenanceOrAbsent } from "./sema-provenance.js";
-import { resupplyFields, terminalFrameFacetFields } from "./task-notification-facets.js";
+import { semaProvenanceFields } from "./sema-provenance.js";
+import { resupplyFields, sessionBoxCarrierFields, terminalFrameFacetFields } from "./task-notification-facets.js";
 import { dropProjectedFace } from "./projection-drop.js";
 import { extensionAnswererOf, extensionRequesterOf, toolInputRewriteOf } from "./extension-call-face.js";
 import { projectByTable } from "./projection-table.js";
@@ -23,7 +23,7 @@ export async function appendModelUsageDelta(append, modelUsage, taskId) {
         await append("model_usage", { usage: tagged });
     }
 }
-export async function appendPromptManifest(append, tracker, taskId) {
+async function appendPromptManifest(append, tracker, taskId) {
     const records = tracker?.drain(taskId);
     if (records)
         for (const m of records)
@@ -33,6 +33,13 @@ export async function appendPromptManifest(append, tracker, taskId) {
         for (const c of companions)
             await append(c.type, c.data);
 }
+export function createPromptManifestSeat(tracker, taskId) {
+    const lease = tracker?.register(taskId) ?? 0;
+    return {
+        drain: (append) => appendPromptManifest(append, tracker, taskId),
+        release: () => tracker?.clear(taskId, lease),
+    };
+}
 export async function attachModelUsage(result, ctx) {
     if (!ctx.modelUsage)
         return result;
@@ -85,10 +92,12 @@ export function aggregateModelUsage(events) {
             total[model].usageBasis = basis;
     return any ? total : undefined;
 }
-function identityFields(src) {
+export function identityFields(src) {
     return {
         ...(identityKey(src.eventId) !== undefined ? { eventId: identityKey(src.eventId) } : {}),
         ...(identityKey(src.parentToolCallId) !== undefined ? { parentToolCallId: identityKey(src.parentToolCallId) } : {}),
+        ...(identityKey(src.sourceTaskId) !== undefined ? { sourceTaskId: identityKey(src.sourceTaskId) } : {}),
+        ...(identityKey(src.bgAgentId) !== undefined ? { bgAgentId: identityKey(src.bgAgentId) } : {}),
     };
 }
 function identityKey(v) {
@@ -224,16 +233,8 @@ export function textEndEventData(ev, before = "") {
         return null;
     return segmentEndFields(ev.content, ev, before);
 }
-export function liveIdentityFields(ev) {
-    return {
-        ...(identityKey(ev.eventId) !== undefined ? { eventId: identityKey(ev.eventId) } : {}),
-        ...(identityKey(ev.parentToolCallId) !== undefined ? { parentToolCallId: identityKey(ev.parentToolCallId) } : {}),
-        ...(identityKey(ev.sourceTaskId) !== undefined ? { sourceTaskId: identityKey(ev.sourceTaskId) } : {}),
-        ...(identityKey(ev.bgAgentId) !== undefined ? { bgAgentId: identityKey(ev.bgAgentId) } : {}),
-    };
-}
 function segmentEndFields(content, ev, before = "") {
-    return { content: redactModelText(content, before), ...liveIdentityFields(ev) };
+    return { content: redactModelText(content, before), ...identityFields(ev) };
 }
 export function reasoningEndEventData(ev) {
     if (typeof ev.content !== "string" || ev.content.trim().length === 0)
@@ -387,7 +388,7 @@ export function taskNotificationEventData(ev) {
         ...(n.source !== undefined ? { source: seatText("trace-frame-text", n.source) } : {}),
         ...(n.exitCode !== undefined ? { exitCode: n.exitCode } : {}),
         ...(n.partial !== undefined ? { partial: n.partial } : {}),
-        ...(n.diagnostics !== undefined ? { diagnostics: seatText("trace-frame-text", n.diagnostics) } : {}),
+        ...(n.diagnostics !== undefined ? { diagnostics: seatText("completion-diagnostics-text", n.diagnostics) } : {}),
         ...(n.recentSteps !== undefined
             ? { recentSteps: n.recentSteps.map((s) => ({ tool: s.tool, target: seatText("trace-frame-text", s.target), outcome: seatText("trace-frame-text", s.outcome) })) }
             : {}),
@@ -398,14 +399,10 @@ export function taskNotificationEventData(ev) {
         ...(n.output_file !== undefined ? { output_file: seatText("trace-frame-text", n.output_file) } : {}),
         ...(n.usage !== undefined ? { usage: n.usage } : {}),
         ...(n.agentMessage !== undefined ? { agentMessage: { from: n.agentMessage.from, body: seatText("trace-frame-text", n.agentMessage.body) } } : {}),
-        ...(() => {
-            if (n._sema_provenance === undefined)
-                return {};
-            const p = semaProvenanceOrAbsent(n._sema_provenance);
-            return p !== undefined ? { _sema_provenance: p } : {};
-        })(),
+        ...semaProvenanceFields(n, "trace-frame-text"),
         ...terminalFrameFacetFields(n),
         ...resupplyFields(n),
+        ...sessionBoxCarrierFields(n, "trace-frame-text"),
         ...(() => {
             const tier = injectionTierOrAbsent(ev.priority);
             return tier !== undefined ? { priority: tier } : {};
@@ -530,6 +527,7 @@ export function wiringManifestEventData(ev, minted) {
     const sessionIn = sec(m.session) ?? {};
     const fleetIn = sec(m.fleet) ?? {};
     const legIn = sec(m.leg) ?? {};
+    const legRunOrigin = runOriginOnLeg(legIn.runOrigin);
     const interactionIn = sec(m.interaction) ?? {};
     const rulesIn = sec(m.permissionRules) ?? {};
     const ask = nonEmpty({
@@ -730,7 +728,7 @@ export function wiringManifestEventData(ev, minted) {
     })();
     return {
         ...(num(m.schemaVersion) !== undefined ? { schemaVersion: m.schemaVersion } : {}),
-        ...(str(legIn.kind) !== undefined ? { leg: { kind: legIn.kind } } : {}),
+        ...(str(legIn.kind) !== undefined ? { leg: { kind: legIn.kind, ...(legRunOrigin !== undefined ? { runOrigin: legRunOrigin } : {}) } } : {}),
         ...(teamRole !== undefined ? { teamRole } : {}),
         ...(fileHistory !== undefined ? { fileHistory } : {}),
         ...(permissionMode !== undefined ? { permissionMode } : {}),
@@ -813,14 +811,21 @@ export function humanInputEventData(ev) {
     const attachments = Array.isArray(ev.attachments)
         ? ev.attachments
             .filter((m) => typeof m === "object" && m !== null && !Array.isArray(m))
-            .map((m) => ({
-            ...(typeof m.ordinal === "number" && Number.isFinite(m.ordinal) ? { ordinal: m.ordinal } : {}),
-            ...(str(m.kind) !== undefined ? { kind: m.kind } : {}),
-            ...(str(m.outcome) !== undefined ? { outcome: m.outcome } : {}),
-            ...(str(m.label) !== undefined ? { label: seatText("trace-frame-text", String(m.label)) } : {}),
-        }))
+            .map((m) => {
+            const declinedBy = extensionRequesterOf(m.declinedBy, "human_input.attachments", "declinedBy");
+            return {
+                ...(typeof m.ordinal === "number" && Number.isFinite(m.ordinal) ? { ordinal: m.ordinal } : {}),
+                ...(str(m.kind) !== undefined ? { kind: m.kind } : {}),
+                ...(str(m.outcome) !== undefined ? { outcome: m.outcome } : {}),
+                ...(str(m.label) !== undefined ? { label: seatText("trace-frame-text", String(m.label)) } : {}),
+                ...(declinedBy !== undefined ? { declinedBy } : {}),
+            };
+        })
         : undefined;
     const rewrittenBy = Array.isArray(ev.rewrittenBy) ? ev.rewrittenBy.filter((n) => str(n) !== undefined) : [];
+    const author = inputAuthorOnFrame(ev.author);
+    const extension = inputExtensionOnFrame(ev.extension);
+    const runOrigin = runOriginOnFrame(ev.runOrigin);
     const actor = {
         ...(str(a.id) !== undefined ? { id: seatText("trace-frame-text", String(a.id)) } : {}),
         ...(typeof a.hostAsserted === "boolean" ? { hostAsserted: a.hostAsserted } : {}),
@@ -837,9 +842,40 @@ export function humanInputEventData(ev) {
         ...(str(ev.entryId) !== undefined ? { entryId: ev.entryId } : {}),
         ...(attachments !== undefined ? { attachments } : {}),
         ...(rewrittenBy.length > 0 ? { rewrittenBy } : {}),
+        ...(author !== undefined ? { author } : {}),
+        ...(extension !== undefined ? { extension } : {}),
+        ...(runOrigin !== undefined ? { runOrigin } : {}),
         ...identityFields(ev),
     };
 }
+function runOriginOnFrame(v) {
+    if (v === undefined)
+        return undefined;
+    if (isRunOrigin(v))
+        return v;
+    return dropProjectedFace("human_input.runOrigin is not a member of the engine's RUN_ORIGINS");
+}
+function runOriginOnLeg(v) {
+    if (v === undefined)
+        return undefined;
+    if (isRunOrigin(v))
+        return v;
+    return dropProjectedFace("wiring_manifest.leg.runOrigin is not a member of the engine's RUN_ORIGINS");
+}
+function inputAuthorOnFrame(v) {
+    if (v === undefined)
+        return undefined;
+    if (isInputAuthor(v) && v !== "operator")
+        return v;
+    return dropProjectedFace("human_input.author is not a non-operator word of the engine's INPUT_AUTHORS");
+}
+function inputExtensionOnFrame(v) {
+    if (v === undefined)
+        return undefined;
+    if (typeof v === "string" && v !== "")
+        return sanitizeWireText(v);
+    return dropProjectedFace("human_input.extension is not a non-empty registration name");
+}
 export function brainStatusEventData(ev) {
     const num = (v) => typeof v === "number" && Number.isFinite(v);
     return {