@sema-agent/server 7.147.0 → 7.149.0

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

@@ -21,7 +21,7 @@ import { type LedgerEventType, type ParkLedgerEventType } from "./ledger-events.
  * persisted tree; it is never a ledger row).
  */
 export interface LedgerSink {
-    /** Seq-stamped raw append — for a leg's out-of-band rows (elicitation/question frames, model_usage deltas,
+    /** Seq-stamped raw append — for a leg's out-of-band rows (the HITL transport's ledger sink, model_usage deltas,
      *  suggestions, `failed`) that must share this run's single seq counter. Redaction is the CALLER's duty on
      *  this raw door (every existing site already redacts); the typed doors below redact internally. */
     append(type: LedgerEventType, data: unknown): Promise<void>;
@@ -69,7 +69,9 @@ export interface LedgerSink {
      *  The redaction owner is NOT this writer: it is `redactLedgerEventData` — the one confluence every ledger row
      *  crosses at the three store twins' `appendEvent` AND again on the read face (idempotent). Redacting here too
      *  would put two writers on one semantic surface; the other park writers (`http/server.ts`'s two resume legs)
-     *  would still need it, and a per-writer arm is exactly the shape that drifts. */
+     *  would still need it, and a per-writer arm is exactly the shape that drifts.
+     *  Never rejects: the park is already committed by the engine (its card is in the checkpoint store) and only the run row's park write
+     *  decides the run (`park-row-commit.ts`); an unwritable park / usage row is a loud log gap (`appendParkRow`), not a verdict. */
     appendParked(kind: ParkLedgerEventType, result: unknown): Promise<void>;
     /** Terminal `done` event. `result` must already be checkpoint-token-stripped (and, on the bg leg,
      *  model-usage-attached) by the caller. */
@@ -104,35 +106,6 @@ export declare function createSerialLedgerAppend(appendEvent: (seq: number, type
  * 返回 `.catch` 用的处理器(产物是函数 ⇒ `create*`)。
  */
 export declare function createForwardAppendFailedNote(type: string): (err: unknown) => void;
-/**
- * 人在环帧(`question` / `question_complete`、`elicitation` / `elicitation_complete`)的**账本孪生投递口**。
- *
- * 一条律:**凡进 run 流的 HITL 帧都有账本孪生;腿只决定「还要不要同时直写 socket」**。后台腿没有 live 面,
- * 它的投递口就是账本追加本身(`runs.ts`);同步流腿有 live SSE,走本函数 —— 同一只帧对象先落账、再按需直写,
- * 于是两条腿对同一只帧的落法只差「直写要不要」,不差「账本有没有」。
- *
- * 顺序与失败语义(与后台腿同一条):
- *  · **先账本后直写**。账本落不下 ⇒ 本次投递**失败**(抛),帧不上 socket —— 一只没有孪生的帧不许单独露面
- *    (否则壳看见一张重载就丢的卡)。调用方(协调器)按「开帧投递失败」处理:这一问结算 `unavailable`、记一次既有的
- *    P-DEBT 留痕;消卡帧则落「面包屑丢失」的 F 类留痕。
- *  · **seq 不自造**:孪生走 `sink.append` —— 本腿账本唯一的那条串行链(与 text / tool / done 行同一个计数器)。
- *  · **直写口已不可达**(客户端离开,而 run 因 detach 继续)⇒ 账本孪生即送达,不再触碰那条已死的连接
- *    (不抛、也不记「丢帧」—— 帧没丢,在账本里)。
- *  · **本腿没有账本**(无 durable run 行的部署:`sink` 缺席)⇒ 直写就是全部投递,死流姿态由 `writeLive` 自己带
- *    (question 抛、elicitation 静默记账),字节逐字同孪生落地之前。
- *
- * 命名(CLAUDE.md 工厂命名律):`create*` —— 返回的是捕获了两个口的闭包,不是纯数据。
- */
-export declare function createLedgerTwinEmit<F extends {
-    type: LedgerEventType;
-}>(opts: {
-    /** 本腿的账本(sync 腿 = 有 durable run 行才有;缺席 ⇒ 无孪生可落)。只用 `append`:seq 由它那条链铸。 */
-    sink: Pick<LedgerSink, "append"> | undefined;
-    /** 本腿的直写口(sync 腿 = 一个具名 SSE 事件)。 */
-    writeLive: (frame: F) => void;
-    /** 直写面此刻可达吗 —— 与协调器问「这条腿还够得着人吗」的是**同一只**谓词(`QuestionRunContext.deliverable`)。 */
-    liveReachable: () => boolean;
-}): (frame: F) => Promise<void>;
 export declare function createLedgerSink(opts: {
     /** The seq-stamped durable append — typically `(seq, type, data) => runStore.appendEvent(taskId, seq, type, data)`. */
     appendEvent: (seq: number, type: LedgerEventType, data: unknown) => Promise<void>;

package/dist/trace/ledger-sink.js

@@ -17,17 +17,6 @@ export function createSerialLedgerAppend(appendEvent, startSeq) {
 export function createForwardAppendFailedNote(type) {
     return (err) => recordFailOpen("server.ledger.forward-append-failed", `type=${type} err=${err instanceof Error ? err.message : String(err)}`);
 }
-export function createLedgerTwinEmit(opts) {
-    return async (frame) => {
-        if (opts.sink !== undefined) {
-            const { type, ...data } = frame;
-            await opts.sink.append(type, data);
-            if (!opts.liveReachable())
-                return;
-        }
-        opts.writeLive(frame);
-    };
-}
 export function createLedgerSink(opts) {
     const keys = opts.notifiedKeys ?? new NotifiedKeys();
     let seq = 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,6 +24,7 @@
  * 新加一只构造器 ⇒ 同批往登记表加一行,否则普查格红。
  */
 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, PromptManifestTracker } from "../budget.js";
 import { type SafeText } from "./exit-seat.js";
@@ -104,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;
@@ -112,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;
@@ -135,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)。
  *
@@ -235,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})。
@@ -442,8 +440,10 @@ export interface ModelUsageSeat {
  * 终局由 {@link attachModelUsage} 先结清最后一拍再落 `done`,停驻由本函数先 drain 再落停驻行。顺序属于写口、不属于调用点:
  * 只回结果的 verify 腿没有逐 turn 落账的流(无 `turn_end` 帧),挂起前的用量只有停驻这一拍才落账;若各调用点各自记得「先结清」,
  * 这条腿的账本尾帧就会是 `model_usage`,与不带 `verify` 的停驻(用量在 `turn_end` 就结清了)两形不同序(`GET /v1/runs/:id/events` 的尾帧)。
- * 用量行落不下 ⇒ 停驻行**照落**,然后把用量行的失败抛给调用方(失败语义与此前逐字同:账本里有停驻帧、调用方按「停驻没落定」收场 —— bg 腿以 `failed` 收、手里的卡作废;
- * 尽力而为的调用点(detach 腿的兜底停驻、续跑腿的重开臂)照旧吞掉它,停驻帧不因为一笔用量行的失败而缺席)。顺序变了,谁来写、写不下谁抛没有变。
+ *
+ * **不抛**:这两行是一次**已提交**停驻的投影(卡在引擎交回之前已落 checkpoint 店;停驻成立与否只由 run 行的停驻写回答,`park-row-commit.ts`)。
+ * 写不下 ⇒ 响亮留痕(`server.runs.terminal-ledger-write-failed`,`arm=park-usage` / `arm=park-row`,与终局帧写不下同一只 tag:run 行是 durable truth,
+ * 读面与收割器容忍账本尾巴缺席),调用方照常往下提交行 —— 账本写不下从不改这条 run 的判词。用量行落不下 ⇒ 停驻行照落(两笔各自留痕)。
  */
 export declare function appendParkRow(append: AppendFn, usage: ModelUsageSeat | undefined, word: ParkLedgerEventType, result: unknown, reopened?: string | null): Promise<void>;
 /**
@@ -464,7 +464,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: {
@@ -661,7 +661,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 腿)共用这一只。
@@ -1004,6 +1004,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 加第
  * 四键时由人处置」——身份对象上多出来的键裸上线是本文件反复登记的病族。
@@ -1021,6 +1029,9 @@ export declare function humanInputEventData(ev: {
     entryId?: unknown;
     attachments?: unknown;
     rewrittenBy?: unknown;
+    author?: unknown;
+    extension?: unknown;
+    runOrigin?: unknown;
     eventId?: unknown;
     parentToolCallId?: unknown;
 }): FrameData<{
@@ -1031,7 +1042,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
@@ -1164,7 +1179,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 面仍会被那份手抄静默剥掉 —— 同一帧两条腿两套键集。
  *

package/dist/trace/project.js

@@ -1,7 +1,8 @@
 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 { errorText } from "../observability/err-text.js";
 import { redactSecrets, redactDeep } from "./redact.js";
 import { seatText } from "./exit-seat.js";
 import { sanitizeWireText } from "./engine-notice-wire.js";
@@ -92,10 +93,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) {
@@ -231,16 +234,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)
@@ -334,20 +329,20 @@ export function parkEventData(result, reopened) {
     };
 }
 export async function appendParkRow(append, usage, word, result, reopened) {
-    let drainFailed = false;
-    let drainFailure;
     if (usage !== undefined) {
         try {
             await appendModelUsageDelta(append, usage.modelUsage, usage.taskId);
         }
         catch (e) {
-            drainFailed = true;
-            drainFailure = e;
+            recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=park-usage ${errorText(e)}`);
         }
     }
-    await append(word, parkEventData(result, reopened));
-    if (drainFailed)
-        throw drainFailure;
+    try {
+        await append(word, parkEventData(result, reopened));
+    }
+    catch (e) {
+        recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=park-row ${errorText(e)}`);
+    }
 }
 export function taskStartedEventData(ev) {
     return {
@@ -394,7 +389,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) })) }
             : {}),
@@ -533,6 +528,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({
@@ -733,7 +729,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 } : {}),
@@ -816,14 +812,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 } : {}),
@@ -840,9 +843,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 {