@sema-agent/server 7.125.1 → 7.127.0

package/dist/trace/project.d.ts

@@ -150,6 +150,7 @@ export declare function toolStartEventData(ev: {
     toolName: string;
     label?: string;
     args: unknown;
+    recovered?: true;
     eventId?: string;
     parentToolCallId?: string;
 }): Record<string, unknown>;
@@ -190,8 +191,8 @@ export declare function screenedGate(v: unknown): GateOutcome | undefined;
  * ## 读腿与写腿现在是**同一只**筛(7.74.0 起,零双读)
  * 7.72.0–7.73.0 期间读腿多一步「认本服务上一版写下的退役词旧拼法」(`unresolvable` → `ancestor_marked`),
  * 那是一条**长期双读臂**:同一份字节在写腿与读腿上有两种理解,而且没有到期日。7.74.0 把它换成**一次性
- * 迁移**(启动期把存量字节原地改名,`plugins/one-time-migrations.ts` 的 M3;窗口见 `plugins/one-time-migrations.ts` 登记表)⇒ 读腿退回写腿那只
- * 严格筛子,集外词一律整条 withhold + 计数,不再有第二种读法。
+ * 迁移**(启动期把存量字节原地改名;窗关后已删码)⇒ 读腿退回写腿那只严格筛子,集外词一律整条 withhold + 计数,
+ * 不再有第二种读法 —— 残留旧拼法的字节(local 车道引擎 File 店里不可改写的已决行)同走这一只筛,响亮不静默。
  *
  * ## 与写腿脱敏汇点的关系(别再走回头路)
  * 写腿的对偶是 `redactLedgerEventData`(三孪生 store 的 `appendEvent` 落库前),它管的是脱敏、不是判形;
@@ -281,20 +282,21 @@ export declare function toolEndEventData(ev: {
     delivered?: McpDelivered;
     gate?: GateOutcome;
     gatedCallId?: string;
+    wireName?: string;
+    notExecuted?: true;
     eventId?: string;
     parentToolCallId?: string;
 }): Record<string, unknown>;
 /**
  * `tool_progress` 的白名单投影(core 7.18.0 [ref])—— 一只**仍在跑**的工具调用的存活 tick。
  *
- * ## 这一帧只上 live,不落账(判据是 core 的契约,不是本仓的偏好)
+ * ## 这一帧只上 live,不落账(判据是回放面有没有第二来源,不是「core 标了 LIVE ONLY」)
  * core `@contract tool_progress.ephemeral` 逐字:「LIVE ONLY, like `task_progress`/`status`: core never
- * persists this frame (no session-tree entry, no checkpoint state, no resume replay)」。本仓对
- * `task_progress` / `status` 正是同一处置(两条 durable 腿零 case),本帧照抄。
- * 另一条 core 契约把「不落账」从偏好抬成正确性:`@contract tool_progress.cadence` 逐字「A call that
- * finishes inside one interval emits NO frame at all」⇒ **帧的缺席从来不是证据**;落账会让回放面凭空
- * 多出一份「这只调用跑了多久」的账,而那件事的真源是 `tool_end`(core 明写 `elapsedTimeSeconds`
- * **不等于** `tool_end` 的 duration)。
+ * persists this frame (no session-tree entry, no checkpoint state, no resume replay)」—— 那是**引擎**的义务;
+ * 本仓的律是「EPHEMERAL 帧带着回放面没有第二来源的事实 ⇒ 落账」(`status` / `task_progress` / `task_started` 都落)。
+ * 本帧的事实**有**第二来源:`@contract tool_progress.cadence` 逐字「A call that finishes inside one interval emits
+ * NO frame at all」⇒ **帧的缺席从来不是证据**;落账会让回放面凭空多出一份「这只调用跑了多久」的账,而那件事的
+ * 真源是 `tool_end`(core 明写 `elapsedTimeSeconds` **不等于** `tool_end` 的 duration)。
  *
  * ## 信任划线
  *  · `toolCallId` / `toolName` —— 调用 id(🔴 S-283 订正:出身是**服务商**在 tool_use / tool_calls 里给的,引擎缺席时自铸兜底、越界时折叠 ——
@@ -306,7 +308,8 @@ export declare function toolEndEventData(ev: {
  *  · `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
- *    or displaying it」⇒ 与 `tool_end.output` **同一只** `redactDeep`,一个字节的例外都不开。
+ *    or displaying it」⇒ 与 `tool_end.output` **同一只**投影 `projectToolOutput`(串形与文本块整只过 `redactDeep`;本帧只有串形,
+ *    媒体块那一臂在这里够不着),一个字节的例外都不开。
  *  · `totalLines` / `totalBytes` —— 引擎计数;core 的缺席律逐字:三者**同进同退**(在场=「观察到了输出」,
  *    缺席=「一个字节都没观察到」,**从不是**「与上一帧相比没变」)。所以本投影按 `output` 的在场判三者:
  *    `output` 读不出 ⇒ 三键一起缺席,不单独留下两个计数(那会把「没输出」谎报成「有输出但读不出」)。
@@ -370,6 +373,47 @@ export declare function taskProgressEventData(ev: {
     seq?: number;
     model?: string;
 }): Record<string, unknown>;
+/**
+ * The `task_started` payload(core 7.50.0):一只委派子代**起跑**的那一帧 —— 每周期一只(首派 / 复活;耐久续跑腿不铸),
+ * 序在子代的 `wiring_manifest` 之后、它的首个 `task_progress` 与首次模型请求之前。
+ *
+ * **活面投、账本落**(与 `task_progress` / `status` 同一条律)。core 契约逐字「Live and ephemeral like `task_progress`:
+ * never persisted, never replayed on resume, absent from checkpoints」—— 那是**引擎**的义务(不进会话树、检查点、续跑重放)。
+ * 本服务的账本是异步车道的活流(`POST /v1/runs` 的观看者读的就是 `GET /v1/runs/:id/events` 的账本 tail)与断线重连面,
+ * 律是「**EPHEMERAL 帧带着回放面没有第二来源的事实 ⇒ 落账**」:`agentType` / `rootSessionId` / `parentSessionId` / `startedAt`
+ * 只骑这一帧,`task_progress` 上没有。(`tool_progress` 不落是同一条律的反面:它的事实由同一只调用的 `tool_end` 推出。)
+ * 调用点:三条 live 腿(sync 主流、sync forward 道、子代 tail 总线)+ 两条 durable 腿(账本汇、resume 腿)各自的主流臂与
+ * forward 道 —— 即 `task_progress` 的全部投影点,同一只构造器。
+ *
+ * 键的信任判与 `task_progress` 孪生**逐键同**(core 原话「every member is a value the run already speaks
+ * elsewhere — this frame introduces no new reading of any of them」⇒ 本仓也不铸第二种读法):
+ *  · run / 会话 id、`seq`、`taskType`、`model`、`workflowRunId`、`agentType` —— 引擎值 verbatim(`agentType` 是解析过的子代类型名,
+ *    不是模型自由文本);`startedAt` 是有限数才上 wire;
+ *  · `name` / `workflowAgentLabel` —— UNTRUSTED 展示文本 ⇒ `redactSecrets`(同 `task_progress.name` / `.workflowAgentLabel`);
+ *  · `spawnName` —— 出生点校验过的队友**身份键** ⇒ verbatim(理由全文在 {@link taskProgressEventData} 的同名键注);
+ *  · 身份两键经 `identityFields`(信封上的 `sourceTaskId` / `bgAgentId` 不由本族构造器投,见 `FRAME_ENVELOPE_KEYS`)。
+ * 缺席即缺席:可选键缺席不铸键(`taskType` 缺席 = 前台子代,禁读作某个默认种类;`seq` 缺席 = 无 `a*` 行,禁读作 cycle 1)。
+ */
+export declare function taskStartedEventData(ev: {
+    /** 判别位(入参就是那一帧;本构造器不投它 —— 帧名由调用点的 `type` 键 / 账本行名给)。 */
+    type?: "task_started";
+    taskId: string;
+    sessionId: string;
+    taskType?: string;
+    seq?: number;
+    workflowRunId?: string;
+    workflowAgentLabel?: string;
+    parentTaskId?: string;
+    parentSessionId?: string;
+    rootSessionId?: string;
+    name?: string;
+    spawnName?: string;
+    agentType?: string;
+    model: string;
+    startedAt: number;
+    eventId?: string;
+    parentToolCallId?: string;
+}): Record<string, unknown>;
 /** The `task_notification` payload (core 1.202 [ref] P2: a background task finished — this event is the
  *  LEDGER/display projection of the OBSERVED terminal state, emitted the moment core observes it. It does NOT
  *  attest that the `<task-notification>` XML has entered the model context: core's steer targets the NEXT TURN
@@ -837,6 +881,8 @@ export declare function brainStatusEventData(ev: {
     errorStatus?: number;
     elapsedMs?: number;
     timeoutMs?: number;
+    providerCondition?: string;
+    providerConditionSource?: string;
     eventId?: string;
     parentToolCallId?: string;
 }): Record<string, unknown>;
@@ -891,7 +937,7 @@ export interface TraceTurn {
      *  🔴 **S-213⑥:五个子键**全部按同族 OMIT 契约走 —— 引擎那一侧报了才铸,没报就**缺席**,恒不折 `0`。
      *  `in`/`out` 此前是必填座、缺一键时写 `?? 0`:读端拿到的 `in:0` 与「这一轮真的零输入」逐字节同形,
      *  于是一次 usage 半缺(某些 provider 只回 output 侧)在面板上显示成一个可核对的真数字。
-     *  0 是一个数,未知不是 —— 两者同形正是本仓 `boundCallId`/`gateKind`/`contentKind` 一族一直在防的事。
+     *  0 是一个数,未知不是 —— 两者同形正是本仓 `boundCallId`/`gateKind`/`approvalCard` 一族一直在防的事。
      *  ⚠️ wire 面(`GET /v1/tasks/:id/turns` 与 trace SSE 的 `turn` 事件)因此可能给出**只有一侧**的
      *  `tokens`;做算术的消费端要按「键可能缺席」读(`tokens` 整只可缺席早就是契约的一部分)。
      *  🔴 **7.74.0 / core 7.17.0([ref])**:引擎自陈 `usageMissing` 的一轮(usage 是六个 0 的占位)⇒ 整只缺席 ——

package/dist/trace/project.js

@@ -3,6 +3,7 @@ import { isAskClass, isAskOrigin, isModeReleaseReason, isPermissionMode, isPersi
 import { Value } from "typebox/value";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets, redactDeep } from "./redact.js";
+import { projectToolOutput } 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";
@@ -91,7 +92,14 @@ export function modelTextEventData(ev) {
     return { text: ev.text, ...(ev.eventId ? { eventId: ev.eventId } : {}) };
 }
 export function toolStartEventData(ev) {
-    return { toolCallId: ev.toolCallId, toolName: ev.toolName, ...(ev.label !== undefined ? { label: ev.label } : {}), args: redactDeep(ev.args), ...identityFields(ev) };
+    return {
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        ...(ev.label !== undefined ? { label: ev.label } : {}),
+        args: redactDeep(ev.args),
+        ...(ev.recovered === true ? { recovered: true } : {}),
+        ...identityFields(ev),
+    };
 }
 const SETTLEMENT_NOTE_MAX = 500;
 export function screenedGate(v) {
@@ -126,22 +134,34 @@ function modeLedgerDefect(d) {
         return "disposition.released.origin is outside the closed set";
     if (o.mandate !== undefined && !isPersistedRuleMandate(o.mandate))
         return "disposition.released.mandate is outside the closed set";
-    if (o.reason !== undefined && !isModeReleaseReason(o.reason))
-        return "disposition.released.reason is outside the closed set";
     return false;
 }
+function withReleaseReasonTheEngineReads(g) {
+    const d = g.disposition;
+    if (d.kind !== "allowed" || d.released === undefined)
+        return g;
+    const r = d.released;
+    if (r === null || typeof r !== "object")
+        return g;
+    const reason = d.released.reason;
+    if (typeof reason !== "string" || isModeReleaseReason(reason))
+        return g;
+    const { reason: _unread, ...kept } = d.released;
+    return { ...g, disposition: { ...d, released: kept } };
+}
 function screenedGateOrThrow(v) {
     if (v === null || typeof v !== "object") {
         if (v !== undefined)
             recordFailOpen("server.trace.gate-outcome-defective", "gate is not an object");
         return undefined;
     }
-    const g = v;
-    const d = g.disposition;
-    if (d === null || typeof d !== "object" || (d.kind !== "allowed" && d.kind !== "denied")) {
+    const stored = v;
+    if (stored.disposition === null || typeof stored.disposition !== "object" || (stored.disposition.kind !== "allowed" && stored.disposition.kind !== "denied")) {
         recordFailOpen("server.trace.gate-outcome-defective", "disposition is not one of the two arms");
         return undefined;
     }
+    const g = withReleaseReasonTheEngineReads(stored);
+    const d = g.disposition;
     const classifierFallbackRaw = d.classifier !== null && typeof d.classifier === "object" ? d.classifier.fallback : undefined;
     const shapeDefect = (d.kind === "denied" && typeof d.deniedBy !== "string" && "disposition.deniedBy is not a string") ||
         (d.kind === "denied" && d.cause !== undefined && typeof d.cause !== "string" && "disposition.cause is not a string") ||
@@ -266,7 +286,7 @@ export function toolEndEventData(ev) {
         toolName: ev.toolName,
         ...(ev.label !== undefined ? { label: ev.label } : {}),
         isError: ev.isError,
-        ...(ev.output !== undefined ? { output: redactDeep(ev.output) } : {}),
+        ...(ev.output !== undefined ? { output: projectToolOutput(ev.output) } : {}),
         ...(ev.truncated ? { truncated: true } : {}),
         ...(Number.isFinite(ev.totalChars) ? { totalChars: ev.totalChars } : {}),
         ...(ev.structured !== undefined ? { structured: redactDeep(ev.structured) } : {}),
@@ -274,6 +294,8 @@ export function toolEndEventData(ev) {
         ...(typeof ev.delivered === "string" && MCP_DELIVERY_VERDICTS.includes(ev.delivered) ? { delivered: ev.delivered } : {}),
         ...(gate !== undefined ? { gate } : {}),
         ...(typeof ev.gatedCallId === "string" && ev.gatedCallId !== "" ? { gatedCallId: ev.gatedCallId } : {}),
+        ...(typeof ev.wireName === "string" && ev.wireName !== "" ? { wireName: ev.wireName } : {}),
+        ...(ev.notExecuted === true ? { notExecuted: true } : {}),
         ...identityFields(ev),
     };
 }
@@ -288,7 +310,7 @@ export function toolProgressEventData(ev) {
         toolCallId: id,
         toolName: name,
         ...(n(ev.elapsedTimeSeconds) !== undefined ? { elapsedTimeSeconds: n(ev.elapsedTimeSeconds) } : {}),
-        ...(hasOutput ? { output: redactDeep(ev.output) } : {}),
+        ...(hasOutput ? { output: projectToolOutput(ev.output) } : {}),
         ...(hasOutput && n(ev.totalLines) !== undefined ? { totalLines: n(ev.totalLines) } : {}),
         ...(hasOutput && n(ev.totalBytes) !== undefined ? { totalBytes: n(ev.totalBytes) } : {}),
         ...identityFields(ev),
@@ -327,6 +349,25 @@ export function taskProgressEventData(ev) {
         ...identityFields(ev),
     };
 }
+export function taskStartedEventData(ev) {
+    return {
+        taskId: ev.taskId,
+        sessionId: ev.sessionId,
+        ...(typeof ev.taskType === "string" && ev.taskType.length > 0 ? { taskType: ev.taskType } : {}),
+        ...(typeof ev.seq === "number" ? { seq: ev.seq } : {}),
+        ...(ev.workflowRunId ? { workflowRunId: ev.workflowRunId } : {}),
+        ...(ev.workflowAgentLabel ? { workflowAgentLabel: redactSecrets(ev.workflowAgentLabel) } : {}),
+        ...(ev.parentTaskId ? { parentTaskId: ev.parentTaskId } : {}),
+        ...(ev.parentSessionId ? { parentSessionId: ev.parentSessionId } : {}),
+        ...(ev.rootSessionId ? { rootSessionId: ev.rootSessionId } : {}),
+        ...(ev.name ? { name: redactSecrets(ev.name) } : {}),
+        ...(ev.spawnName ? { spawnName: ev.spawnName } : {}),
+        ...(ev.agentType ? { agentType: ev.agentType } : {}),
+        model: ev.model,
+        ...(typeof ev.startedAt === "number" && Number.isFinite(ev.startedAt) ? { startedAt: ev.startedAt } : {}),
+        ...identityFields(ev),
+    };
+}
 export function taskNotificationEventData(ev) {
     const n = ev.notification;
     return {
@@ -724,6 +765,8 @@ export function brainStatusEventData(ev) {
         ...(num(ev.timeoutMs) ? { timeoutMs: ev.timeoutMs } : {}),
         ...(num(ev.errorStatus) ? { errorStatus: ev.errorStatus } : {}),
         ...(typeof ev.errClass === "string" && ev.errClass.length > 0 ? { errClass: ev.errClass } : {}),
+        ...(typeof ev.providerCondition === "string" && ev.providerCondition.length > 0 ? { providerCondition: ev.providerCondition } : {}),
+        ...(typeof ev.providerConditionSource === "string" && ev.providerConditionSource.length > 0 ? { providerConditionSource: ev.providerConditionSource } : {}),
         ...identityFields(ev),
     };
 }
@@ -839,6 +882,7 @@ export function toolCallFieldsOf(d) {
         name: String(d.toolName ?? ""),
         ...(typeof d.label === "string" ? { label: d.label } : {}),
         input: d.args,
+        ...(d.recovered === true ? { recovered: true } : {}),
         ...identityFields(d),
     };
 }
@@ -854,6 +898,8 @@ export function toolResultFieldsOf(d) {
         ...(typeof d.delivered === "string" && MCP_DELIVERY_VERDICTS.includes(d.delivered) ? { delivered: d.delivered } : {}),
         ...(gate !== undefined ? { gate } : {}),
         ...(typeof d.gatedCallId === "string" && d.gatedCallId !== "" ? { gatedCallId: d.gatedCallId } : {}),
+        ...(typeof d.wireName === "string" && d.wireName !== "" ? { wireName: d.wireName } : {}),
+        ...(d.notExecuted === true ? { notExecuted: true } : {}),
         ...identityFields(d),
     };
 }

package/dist/trace/self-minted-wire.d.ts

@@ -365,8 +365,9 @@ export declare const SELF_MINTED_WIRE: {
         };
     };
     /**
-     * 提交幂等(契约 §0.7:幂等 = 资源行上的唯一键)本版新上 wire 的面:同步腿读行重放体的 `replay` 键、两只按键读的读口、
-     * `Idempotency-Key` 命中一条读不到 / 不是这次 taskId 所指的行时的 409。行为由 `test/submit-idempotency-one-ledger.test.ts` 钉。
+     * 提交幂等(契约 §0.7:幂等 = 资源行上的唯一键)上 wire 的面:同步腿读行重放体的 `replay` 键、两只按键读的读口、
+     * `Idempotency-Key` 命中一条读不到 / 不是这次 taskId 所指的行时的 409(7.125.0);同键异体(绑定那一行的请求体与这次不同)的 409(7.126.0)。
+     * 行为由 `test/submit-idempotency-one-ledger.test.ts` 钉。
      */
     readonly submitIdempotency: {
         readonly at: "提交幂等(<端点>#<面> → 应答状态)";
@@ -387,6 +388,78 @@ export declare const SELF_MINTED_WIRE: {
                 readonly attr: 409;
                 readonly since: "7.125.0";
             };
+            readonly "POST /v1/runs|/v1/tasks Idempotency-Key#conflict.idempotency_payload_mismatch": {
+                readonly attr: 409;
+                readonly since: "7.126.0";
+            };
+        };
+    };
+    /**
+     * 内建场景名(`GET /v1/capabilities.scenarios` 的内建成员,`GET /v1/capabilities/scenarios/:name` 的内建详情)。7.126.0 `discuss` 退出 wire
+     * (core 7.49.0 删团队讨论运行时;请求体再传它 = 400 `scenario_unknown`)。钉 test/team-orchestration-retired.test.ts。
+     */
+    readonly builtinScenario: {
+        readonly at: "GET /v1/capabilities#scenarios[] 内建成员";
+        readonly members: {
+            code: {
+                attr: string;
+                since: string;
+            };
+            default: {
+                attr: string;
+                since: string;
+            };
+            "code-review": {
+                attr: string;
+                since: string;
+            };
+            scan: {
+                attr: string;
+                since: string;
+            };
+        };
+    };
+    /**
+     * 提交体的场景透传键(受理门放行;`ScenarioRequest` 索引签名读)。7.126.0 只喂 discuss 场景与 code-review council 腿的四键退出 wire
+     * (受理门对它们答未知键 400;同批退出的具名键 `council` / `debate` 住在 `TaskRequestBody` 上,不在本集 —— 具名提交面键本清单今天看不见)。
+     */
+    readonly scenarioBodyKey: {
+        readonly at: "POST /v1/tasks|/v1/tasks/stream|/v1/runs 体的场景透传键";
+        readonly members: {
+            repo: {
+                attr: string;
+                since: string;
+            };
+        };
+    };
+    /**
+     * `GET /v1/models` 应答体的顶层键(闭集;`src/http/routes/capabilities.ts` 的 `sendJson(res, 200, {…})` 字面量)。属性 = 在场律:`always` 恒在场(零条也出键),`present-iff` 条件成立才出键
+     * (缺席不下「无」的结论——也可能是更早的 server)。`since` = 该键上 wire 的起始版本(`models` / `default` / `defaultModel` 在本仓首个 tag 就有)。
+     * 7.126.0:`candidateRejected`(S-1457,present-iff:当前生效的配置是因判官整拒了最近一份候选而回落的那一份;契约 §A.1d)。
+     */
+    readonly modelsResponseKey: {
+        readonly at: "GET /v1/models 应答体顶层键(<键> → 在场律)";
+        readonly members: {
+            readonly models: {
+                readonly attr: "always";
+                readonly since: "1.214.2";
+            };
+            readonly default: {
+                readonly attr: "always";
+                readonly since: "1.214.2";
+            };
+            readonly defaultModel: {
+                readonly attr: "always";
+                readonly since: "1.214.2";
+            };
+            readonly droppedEntries: {
+                readonly attr: "always";
+                readonly since: "7.123.0";
+            };
+            readonly candidateRejected: {
+                readonly attr: "present-iff";
+                readonly since: "7.126.0";
+            };
         };
     };
     /** 本仓在出口对 core 值做的变换(值变、键不变)。 */
@@ -417,6 +490,25 @@ export declare const SELF_MINTED_WIRE: {
                 readonly attr: "redactListEntry";
                 readonly since: "7.120.0";
             };
+            /**
+             * 7.127.0(引擎 7.50.0:`tool_end.output` 按块带已准入的图像 / 文档):媒体块(image / document 且 `data` 是串)的 `data` 是字节编码 ——
+             * 活面 SSE 逐字过境,不跑文本脱敏(`trace/tool-output-media.ts` `projectToolOutput`;钉 test/tool-end-media-durable.test.ts);
+             * 唯一例外 = 连接积压:本帧媒体 + 这条连接 / 订阅者未送出的字节 > 64 MiB ⇒ 本帧媒体降描述符(`liveToolEndForBacklog`;钉 test/live-media-backlog.test.ts)。
+             */
+            readonly "SSE tool_end#output[].data(\u5A92\u4F53\u5757)": {
+                readonly attr: "verbatim-bytes;backlog>64MiB⇒descriptor+totalChars";
+                readonly since: "7.127.0";
+            };
+            /**
+             * 7.127.0:同一媒体块在**持久面**(账本行与 `GET /v1/runs/:id/events` 回放)只存描述符 `{ type, mimeType?, bytes, truncated: true }`,
+             * 帧级 `truncated` 随之为真、帧级 `totalChars` 随之在场(core 不变量「Present iff truncated」:帧上已有 core 的值 ⇒ 原样保留,
+             * 没有 ⇒ 逐块真实大小求和;活面积压降级同一只函数)(账本汇点一处剥:`observability/run-terminal.ts` `redactLedgerEventData` →
+             * `toolEndMediaAsDescriptors`;钉同上)。
+             */
+            readonly "GET /v1/runs/:id/events#tool_end.output[](\u5A92\u4F53\u5757)": {
+                readonly attr: "durableMediaDescriptor+totalChars";
+                readonly since: "7.127.0";
+            };
         };
     };
 };

package/dist/trace/self-minted-wire.js

@@ -134,6 +134,32 @@ export const SELF_MINTED_WIRE = {
             "GET /v1/runs?idempotencyKey": { attr: 200, since: "7.125.0" },
             "GET /v1/leader?idempotencyKey": { attr: 200, since: "7.125.0" },
             "POST /v1/runs|/v1/tasks Idempotency-Key#conflict.run_exists": { attr: 409, since: "7.125.0" },
+            "POST /v1/runs|/v1/tasks Idempotency-Key#conflict.idempotency_payload_mismatch": { attr: 409, since: "7.126.0" },
+        },
+    },
+    builtinScenario: {
+        at: "GET /v1/capabilities#scenarios[] 内建成员",
+        members: {
+            code: { attr: "-", since: "1.214.2" },
+            default: { attr: "-", since: "1.214.2" },
+            "code-review": { attr: "-", since: "1.214.2" },
+            scan: { attr: "-", since: "1.214.2" },
+        },
+    },
+    scenarioBodyKey: {
+        at: "POST /v1/tasks|/v1/tasks/stream|/v1/runs 体的场景透传键",
+        members: {
+            repo: { attr: "-", since: "1.214.2" },
+        },
+    },
+    modelsResponseKey: {
+        at: "GET /v1/models 应答体顶层键(<键> → 在场律)",
+        members: {
+            models: { attr: "always", since: "1.214.2" },
+            default: { attr: "always", since: "1.214.2" },
+            defaultModel: { attr: "always", since: "1.214.2" },
+            droppedEntries: { attr: "always", since: "7.123.0" },
+            candidateRejected: { attr: "present-iff", since: "7.126.0" },
         },
     },
     wireValueRule: {
@@ -143,6 +169,8 @@ export const SELF_MINTED_WIRE = {
             "POST /v1/side-query#errorMessage": { attr: "redactErrorMessage", since: "7.108.0" },
             "engine_notice permission.allowed_tool_not_granted#detail.entries[].entry": { attr: "redactListEntry", since: "7.120.0" },
             "engine_notice permission.rule_row_dropped#detail.rows[].rule": { attr: "redactListEntry", since: "7.120.0" },
+            "SSE tool_end#output[].data(媒体块)": { attr: "verbatim-bytes;backlog>64MiB⇒descriptor+totalChars", since: "7.127.0" },
+            "GET /v1/runs/:id/events#tool_end.output[](媒体块)": { attr: "durableMediaDescriptor+totalChars", since: "7.127.0" },
         },
     },
 };

package/dist/trace/tool-output-media.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 两面共用的 `output` 投影:串 / 文本块 / 其它块整只过 `redactDeep`;媒体块逐成员过,`data` 逐字。
+ * 保键序(逐键映射),不改入参。
+ */
+export declare function projectToolOutput(output: unknown): unknown;
+/**
+ * `tool_end` 载荷的媒体降级(持久面恒用;活面只在连接积压时用):带 `data` 的媒体块换成描述符,有任何一块被换 ⇒ 帧级 `truncated: true`
+ * 且帧级 `totalChars` 在场 —— core 不变量「Present iff truncated」:被界之前那个值的真实大小。帧上已有 `totalChars`(core 已截断:
+ * 文本被切而媒体留着)⇒ **原样保留**(它说的是更早的原值,本仓手里的已是切过的值,重算只会低报);没有 ⇒ 按 {@link trueSizeOf}
+ * 逐块求和(core 没截,`output` 就是原值 —— 文本块是本服务脱敏后的字节,即本服务交付的内容)。
+ * 没有媒体块 ⇒ 原样返回同一引用(纯文本 / 串形 output 一个字节不变);已是描述符的块(无 `data`)原样 ⇒ 幂等。
+ */
+export declare function toolEndMediaAsDescriptors(data: Record<string, unknown>): Record<string, unknown>;
+/** 活面一条连接允许压住的待发字节上界(含本帧媒体)。一帧媒体最大约为部署媒体预算的 4/3(缺省约 40 MiB),
+ *  上界取它之上一点:空闲连接上一整帧最大的图照样整块过,第二帧起只在读者跟上之后才整块。 */
+export declare const LIVE_MEDIA_BACKLOG_BYTES: number;
+/** 一帧 `tool_end` 载荷里媒体块 `data` 的字节数(base64 串长;没有媒体 = 0)。 */
+export declare function liveMediaBytesOf(frame: Record<string, unknown>): number;
+/**
+ * 活面的积压判据(一只):`backlogBytes` = 这条连接 / 这个订阅者此刻还没送出去的字节。本帧媒体 + 积压 > 上界 ⇒ 媒体降描述符,
+ * 否则原样(同一引用)。非 `tool_end` 载荷由调用方不送进来;没有媒体的 `tool_end` 恒原样。
+ * 降级是 F 类兜底(观众少见一张图),每降一帧在**这里**记一次 `server.tool-end-media.live-backlog-degraded` —— 三处写口都经这一只函数,
+ * 留痕因此只有一处;帧上它与引擎的媒体预算降级同形,计数是运维看出「多少观众丢了图」的唯一位。
+ */
+export declare function liveToolEndForBacklog(frame: Record<string, unknown>, backlogBytes: number): Record<string, unknown>;
+//# sourceMappingURL=tool-output-media.d.ts.map

package/dist/trace/tool-output-media.js

@@ -0,0 +1,57 @@
+import { redactDeep } from "./redact.js";
+import { recordFailOpen } from "../observability/fail-open.js";
+function isMediaBlock(b) {
+    if (b === null || typeof b !== "object" || Array.isArray(b))
+        return false;
+    const block = b;
+    return (block.type === "image" || block.type === "document") && typeof block.data === "string";
+}
+const MIME_ECHO_MAX = 255;
+export function projectToolOutput(output) {
+    if (!Array.isArray(output))
+        return redactDeep(output);
+    return output.map((b) => (isMediaBlock(b) ? Object.fromEntries(Object.entries(b).map(([k, v]) => [k, k === "data" ? v : redactDeep(v)])) : redactDeep(b)));
+}
+function trueSizeOf(b) {
+    if (isMediaBlock(b))
+        return b.data.length;
+    if (b !== null && typeof b === "object" && !Array.isArray(b) && b.type === "text" && typeof b.text === "string") {
+        const { type: _type, text, ...rest } = b;
+        return text.length + Math.max(0, (JSON.stringify(rest)?.length ?? 2) - 2);
+    }
+    return JSON.stringify(b)?.length ?? 0;
+}
+export function toolEndMediaAsDescriptors(data) {
+    const output = data.output;
+    if (!Array.isArray(output) || !output.some(isMediaBlock))
+        return data;
+    const totalChars = typeof data.totalChars === "number" && Number.isFinite(data.totalChars) ? data.totalChars : output.reduce((n, b) => n + trueSizeOf(b), 0);
+    const stripped = output.map((b) => isMediaBlock(b)
+        ? {
+            type: b.type,
+            ...(typeof b.mimeType === "string" && b.mimeType.length <= MIME_ECHO_MAX ? { mimeType: b.mimeType } : {}),
+            bytes: Math.floor((b.data.length * 3) / 4),
+            truncated: true,
+        }
+        : b);
+    return { ...data, output: stripped, truncated: true, totalChars };
+}
+export const LIVE_MEDIA_BACKLOG_BYTES = 64 * 1024 * 1024;
+export function liveMediaBytesOf(frame) {
+    const output = frame.output;
+    if (!Array.isArray(output))
+        return 0;
+    let n = 0;
+    for (const b of output)
+        if (isMediaBlock(b))
+            n += b.data.length;
+    return n;
+}
+export function liveToolEndForBacklog(frame, backlogBytes) {
+    const media = liveMediaBytesOf(frame);
+    if (media === 0 || backlogBytes + media <= LIVE_MEDIA_BACKLOG_BYTES)
+        return frame;
+    recordFailOpen("server.tool-end-media.live-backlog-degraded", `backlog=${backlogBytes} media=${media}`);
+    return toolEndMediaAsDescriptors(frame);
+}
+//# sourceMappingURL=tool-output-media.js.map

package/dist/trace/wire-projection-faces.d.ts

@@ -74,6 +74,12 @@ export declare const WIRE_PROJECTION_FACES: {
         readonly excluded: readonly [];
         readonly minted: readonly [];
     };
+    readonly task_started: {
+        readonly projector: "taskStartedEventData";
+        readonly coreType: string;
+        readonly excluded: readonly [];
+        readonly minted: readonly [];
+    };
     readonly tool_start: {
         readonly projector: "toolStartEventData";
         readonly coreType: string;
@@ -155,7 +161,7 @@ export declare const WIRE_PROJECTION_FACES: {
     readonly human_input: {
         readonly projector: "humanInputEventData";
         readonly coreType: string;
-        readonly excluded: readonly ["principal"];
+        readonly excluded: readonly ["principal", "attachments"];
         readonly minted: readonly [];
     };
     readonly task_notification: {

package/dist/trace/wire-projection-faces.js

@@ -16,6 +16,7 @@ function withoutSections(all, drop) {
 }
 export const WIRE_PROJECTION_FACES = {
     task_progress: { projector: "taskProgressEventData", coreType: arm("task_progress"), excluded: [], minted: [] },
+    task_started: { projector: "taskStartedEventData", coreType: arm("task_started"), excluded: [], minted: [] },
     tool_start: { projector: "toolStartEventData", coreType: arm("tool_start"), excluded: [], minted: [] },
     tool_end: { projector: "toolEndEventData", coreType: arm("tool_end"), excluded: [], minted: [] },
     tool_progress: { projector: "toolProgressEventData", coreType: arm("tool_progress"), excluded: [], minted: [] },
@@ -29,7 +30,7 @@ export const WIRE_PROJECTION_FACES = {
     context_usage: { projector: "contextUsageEventData", coreType: arm("context_usage"), excluded: [], minted: [] },
     turn_end: { projector: "turnEndEventData", coreType: arm("turn_end"), excluded: [], minted: [] },
     compaction_outcome: { projector: "compactionOutcomeEventData", coreType: arm("compaction_outcome"), excluded: [], minted: [] },
-    human_input: { projector: "humanInputEventData", coreType: arm("human_input"), excluded: ["principal"], minted: [] },
+    human_input: { projector: "humanInputEventData", coreType: arm("human_input"), excluded: ["principal", "attachments"], minted: [] },
     task_notification: {
         projector: "taskNotificationEventData",
         coreType: `TaskNotificationPayload & ${arm("task_notification")}`,

package/dist/web-admin-client/apply-effective.d.ts

@@ -62,9 +62,9 @@ export declare function applyEffective(config: ServiceConfig, eff: EffectiveConf
 /**
  * 🔴 **模型面组由哪些 effective 域组成 —— 唯一定义**(7.101.0 验修轮 V1 / codex V-1;OA 验修轮 V2 的以点改面)。
  *
- * collab 在组里:模板带模型引用,新模板配旧目录(或旧模板配新目录)就是一次混代发布。此前「模型面」散在三处各写一份 ——
- * 世代账的键表只列 models 域的落点、stage 的 collab 闸按「模型面没被拒」ad hoc 门住、boot 按组回落 LKG 的合成只换
- * `models` 域 —— 最后那份漏了 collab,于是 boot 回落时 LKG 的目录配上了被拒候选的模板(与 refresh 腿同态不同答)。
+ * 组里今天只有 `models` 一个域(collab 域曾因模板带模型引用而同组;7.49.0 起本仓不执行 collab 模板,它出组 —— 见
+ * {@link collabTemplatesNotExecuted})。此前「模型面」散在三处各写一份(世代账键表 / stage 闸 / boot 按组回落 LKG 的合成),
+ * 收成本表一处定义;再有域入组只改这一行,下面的映射型逼着补落点。
  * 读者一律从这里派生,禁手抄:
  *  · stage:{@link stageModelPlane} 产出组内**每个**域的产物({@link ModelPlaneStages} 按本表映射),组被拒 ⇒ 一个域都没有;
  *  · 世代账:整组拒的 `keys` 与落地的 `applied` 都由 {@link MODEL_PLANE_SURFACES} 按本表派生({@link modelPlaneGroupReport});
@@ -72,14 +72,14 @@ export declare function applyEffective(config: ServiceConfig, eff: EffectiveConf
  * (与 `config.ts` 的配置组视图 `MODEL_PLANE_GROUP_KEYS` 不是一回事:那是 `ServiceConfig` 的分节视图;这里是「中心热应用的
  * 模型面这一组包含哪些 effective 域」。)
  */
-export declare const MODEL_PLANE_DOMAINS: readonly ["models", "collab"];
+export declare const MODEL_PLANE_DOMAINS: readonly ["models"];
 export type ModelPlaneDomain = (typeof MODEL_PLANE_DOMAINS)[number];
-/** 模型面组在 effective 上的那一切片(组内各域;`models` 必在、`collab` 可缺席 —— 与 `EffectiveConfig` 同形)。 */
+/** 模型面组在 effective 上的那一切片(组内各域,与 `EffectiveConfig` 同形)。 */
 export type ModelPlaneOf = Pick<EffectiveConfig, ModelPlaneDomain>;
 /**
  * `target` 换上 `source` 的**整个模型面**(组内每个域都取 `source` 的;`source` 缺席的域在结果里同样缺席,不留 `target` 的),
  * 其余域原样是 `target` 的。boot 按组回落 LKG 的合成文档(回落 apply 的入参)走这一只 —— 禁在调用点
- * 手写 `{ ...x, models, collab }`(漏一个域正是 V1 的病形)。纯数据:不改两个入参。
+ * 手写 `{ ...x, models }`(组再加域时漏一个正是 V1 的病形)。纯数据:不改两个入参。
  */
 export declare function withModelPlaneOf<E extends EffectiveConfig>(target: E, source: ModelPlaneOf): E;
 /**
@@ -104,6 +104,12 @@ export declare const PLANE_REFUSAL_INVARIANT_OF: {
     readonly "config.model_route_endpoint_missing": "model-route-endpoint";
     readonly "config.gateway_fallback_without_primary": "model-route-endpoint";
 };
+/**
+ * collab 域 = 中心的多成员讨论模板。**本仓不执行它们**:唯一的执行体是引擎的团队讨论脚本,core 7.49.0 已删(本仓不留第二份
+ * 团队编排)。这一只是本仓对该域的**唯一读法**:已发布且启用的模板 id(`enabled === false` 是运营态关闭,不算发布)——
+ * 真 apply 的 `web_admin_collab_not_executed` warn 与 dry-run 行的 `collab.notExecuted` 都读它。
+ */
+export declare function collabTemplatesNotExecuted(eff: Pick<EffectiveConfig, "collab">): string[];
 /**
  * DESIGN-278 §5 S2([ref])—— center 这份 effective **当前在管**哪些 `ServiceConfig` 键(配置目录端点
  * `GET /v1/config/catalog` 判 `effectiveLane` 的 center 半场)。
@@ -127,7 +133,7 @@ export declare function applyRuntimeHot(config: ServiceConfig, gov: EffectiveCon
 /**
  * Read-only comparison (`WEB_ADMIN_ENV.dryRun`): log what the web-admin config WOULD change vs the current
  * (env-derived) config, WITHOUT applying it. The safe-rollout step the web-admin recommends — verify
- * the center's models/roles/collab match (or intentionally differ from) the env baseline before going live.
+ * the center's models/roles match (or intentionally differ from) the env baseline before going live.
  */
 export declare function logEffectiveDiff(config: ServiceConfig, eff: EffectiveConfig, logger?: Logger): void;
 //# sourceMappingURL=apply-effective.d.ts.map