@sema-agent/server 7.146.0 → 7.148.0

package/dist/trace/sema-provenance.js

@@ -1,14 +1,85 @@
-export const SEMA_PROVENANCE_KINDS = ["agent_message"];
-export const SEMA_PROVENANCE_KINDS_EXCLUDED = ["cross_session_message", "cross_session_notice", "inbox_notice"];
+import { MAILBOX_PEER_FROM_MODES, MAILBOX_PEER_RECORD_KINDS } from "@sema-agent/core";
+import { seatText } from "./exit-seat.js";
+import { dropProjectedFace } from "./projection-drop.js";
+import { isPlainObject, isString, memberOf, optional, settle } from "./task-notification-facets.js";
+export const SEMA_PROVENANCE_KINDS = ["agent_message", "cross_session_message", "cross_session_notice", "inbox_notice"];
 const _semaProvenanceExhaustive = true;
 void _semaProvenanceExhaustive;
-const _semaProvenanceNoDoubleBook = true;
-void _semaProvenanceNoDoubleBook;
-export function semaProvenanceOrAbsent(p) {
-    if (!SEMA_PROVENANCE_KINDS.includes(p.kind))
-        return undefined;
-    if (typeof p.from !== "string" || typeof p.taskId !== "string" || typeof p.seq !== "number")
-        return undefined;
-    return { kind: p.kind, from: p.from, taskId: p.taskId, seq: p.seq, ...(typeof p.agentType === "string" ? { agentType: p.agentType } : {}) };
+const isKind = memberOf(SEMA_PROVENANCE_KINDS);
+const optString = optional(isString);
+const optFromMode = optional(memberOf(MAILBOX_PEER_FROM_MODES));
+const optRecordKind = optional(memberOf(MAILBOX_PEER_RECORD_KINDS));
+const optBoolean = optional((v) => typeof v === "boolean");
+const optInstant = optional((v) => typeof v === "number" && Number.isFinite(v) && v >= 0);
+export function semaProvenanceFields(n, seat) {
+    if (n._sema_provenance === undefined)
+        return {};
+    const p = settle(provenanceOf(n._sema_provenance, seat), (why) => dropProjectedFace("task_notification._sema_provenance " + why));
+    return p !== undefined ? { _sema_provenance: p } : {};
+}
+function provenanceOf(raw, seat) {
+    if (!isPlainObject(raw))
+        return { why: "is not a plain-data record" };
+    const { kind, from, taskId, seq, agentType, peerMeta } = raw;
+    if (!isKind(kind))
+        return { why: "kind is outside the core lane vocabulary" };
+    if (!isString(from) || !isString(taskId) || typeof seq !== "number")
+        return { why: "is missing a string from / taskId or a number seq" };
+    if (!optString(agentType))
+        return { why: "agentType is present but not a string" };
+    const meta = peerMeta === undefined ? undefined : peerMetaOf(peerMeta, seat);
+    if (meta !== undefined && "why" in meta)
+        return { why: `peerMeta ${meta.why}` };
+    return { wire: { kind, from, taskId, seq, ...(agentType !== undefined ? { agentType } : {}), ...(meta !== undefined ? { peerMeta: meta.wire } : {}) } };
+}
+function peerMetaOf(raw, seat) {
+    if (!isPlainObject(raw))
+        return { why: "is not a plain-data record" };
+    const { fromSession, fromRoot, fromMode, kind, fromScope, notice, urgent } = raw;
+    if (!optString(fromSession) || !optString(fromRoot) || !optString(fromScope)) {
+        return { why: "has a present fromSession / fromRoot / fromScope that is not a string" };
+    }
+    if (!optFromMode(fromMode))
+        return { why: "fromMode is outside core MAILBOX_PEER_FROM_MODES" };
+    if (!optRecordKind(kind))
+        return { why: "kind is outside core MAILBOX_PEER_RECORD_KINDS" };
+    if (!optBoolean(urgent))
+        return { why: "urgent is present but not a boolean" };
+    const typed = notice === undefined ? undefined : noticeOf(notice, seat);
+    if (typed !== undefined && "why" in typed)
+        return { why: `notice ${typed.why}` };
+    return {
+        wire: {
+            ...(fromSession !== undefined ? { fromSession } : {}),
+            ...(fromRoot !== undefined ? { fromRoot } : {}),
+            ...(fromMode !== undefined ? { fromMode } : {}),
+            ...(kind !== undefined ? { kind } : {}),
+            ...(fromScope !== undefined ? { fromScope } : {}),
+            ...(typed !== undefined ? { notice: typed.wire } : {}),
+            ...(urgent !== undefined ? { urgent } : {}),
+        },
+    };
+}
+function noticeOf(raw, seat) {
+    if (!isPlainObject(raw))
+        return { why: "is not a plain-data record" };
+    const { state, refSeq, recipient, dropReason, finishedAt, detail, target } = raw;
+    if (!isString(state))
+        return { why: "is missing a string state" };
+    if (!optInstant(refSeq) || !optInstant(finishedAt))
+        return { why: "has a present refSeq / finishedAt that is not a non-negative finite number" };
+    if (!optString(recipient) || !optString(dropReason) || !optString(detail) || !optString(target))
+        return { why: "has a present recipient / dropReason / detail / target that is not a string" };
+    return {
+        wire: {
+            state,
+            ...(refSeq !== undefined ? { refSeq } : {}),
+            ...(recipient !== undefined ? { recipient: seatText(seat, recipient) } : {}),
+            ...(dropReason !== undefined ? { dropReason: seatText(seat, dropReason) } : {}),
+            ...(finishedAt !== undefined ? { finishedAt } : {}),
+            ...(detail !== undefined ? { detail: seatText(seat, detail) } : {}),
+            ...(target !== undefined ? { target: seatText(seat, target) } : {}),
+        },
+    };
 }
 //# sourceMappingURL=sema-provenance.js.map

package/dist/trace/task-notification-facets.d.ts

@@ -9,13 +9,16 @@
  *    `terminalFrameFacets` 统一铸:`spawnName` / `handback` / `compaction`;
  *  · {@link resupplyFields} —— 重供两键([ref]):`resupplied` / `attempt`。
  * 全部是引擎铸的闭形值(身份键 / 闭集词 / 计数 / 布尔),零模型自由文本 ⇒ 不过 `redactSecrets`;判不过形 ⇒ 那一键
- * 缺席(不折默认、不编值)。同一只会话箱车道的**载体** `inboxNotice` 不在这里 —— 它在 EXCLUDED 簿
- * (`core-keyset-guard.ts` ①,理由逐字在那里)。
+ * 缺席(不折默认、不编值)。
+ * [ref] 起第三组:会话箱车道的三只**载体** —— {@link sessionBoxCarrierFields}:`crossSessionMessage` / `crossSessionNotice` /
+ * `inboxNotice`(同一条律;载体带别处来的自由文本,经出口座 —— 座由腿给,见 {@link FrameTextSeat})。它们的侧记 `_sema_provenance`
+ * (含 typed 的 `peerMeta.notice`)是同帧另一只键,判据在 `sema-provenance.ts`(一只 wire 键一个判据文件,两腿共用)。
  * 🔴 NP-5(7.100.0 合并复审 [ref] 交叉表 #7):「在场但读不出」经 present-iff 投影脸族的唯一丢弃留痕 `dropProjectedFace`
  * (`./projection-drop.ts`,`server.trace.projection-input-malformed`)计一次再丢;**缺席从不计数**。此前这里静默丢,
  * 而同批 `wiring_manifest.teamRole` 走那只计数 —— 同一条规则两种处置。
  */
 import { type HandbackState, type TaskNotificationPayload } from "@sema-agent/core";
+import { type ExitSeat, type SafeText } from "./exit-seat.js";
 /**
  * 委派终态帧 `compaction` facet 的形 —— **从 core 载荷派生,不手写**(NP-7,7.100.0 合并复审 [ref] 交叉表 #9,opus A5)。
  * 修前是手写的 `{ passes; breakerOpen; kind? }`:core 给它加成员时 tsc 不红、逐挑处把新成员静默丢(变异探针实测:给 core 的
@@ -61,5 +64,70 @@ export declare function resupplyFields(n: TaskNotificationFacetInput): {
     resupplied?: true;
     attempt?: number;
 };
+/**
+ * 一只 `task_notification` 帧的自由文本从哪一行出口座出门 —— **座由腿给,判据不分腿**:
+ *  · live 三腿(sync SSE / bg·resume 账本行):`trace-frame-text`(不设界,与同帧 `summary` / `result` 同一行);
+ *  · park 腿(入会话收件、下一次开流 drain):`inbox-frame-text`(界 4000,与 park 条目既有的文本位同额 —— `payload` 列是 TEXT)。
+ * 两行同一个脱敏 scope,所以界内的文本两腿逐字节同;非文本成员两腿恒逐字节同。
+ */
+export type FrameTextSeat = Extract<ExitSeat, "trace-frame-text" | "inbox-frame-text">;
+type Faces = typeof import("./wire-projection-faces.js").WIRE_PROJECTION_FACES;
+/** 登记表嵌套面那一行的 `excluded`(「哪个成员不投」的单写者)读成联合型 —— 本文件与 `sema-provenance.ts` 的投影型 = core 型减它。 */
+export type FaceExcluded<F extends keyof Faces> = Faces[F]["excluded"][number];
+type CrossSessionMessage = NonNullable<TaskNotificationPayload["crossSessionMessage"]>;
+type CrossSessionNotice = NonNullable<TaskNotificationPayload["crossSessionNotice"]>;
+type InboxNotice = NonNullable<TaskNotificationPayload["inboxNotice"]>;
+/** 消息载体的 wire 形:core 型减登记表排除;`fromName`(发信方原始显示名)与 `body`(对端正文)是出口座铸的 {@link SafeText}。 */
+export type CrossSessionMessageWire = Omit<CrossSessionMessage, "fromName" | "body" | FaceExcluded<"task_notification_cross_session_message">> & {
+    fromName?: SafeText;
+    body: SafeText;
+};
+/** 通告载体的 wire 形:`kind` 闭二词 + `text`(drain 由 typed notice 渲的句子,句子里嵌着别的会话的标签与那一行 ⇒ 经座)。 */
+export type CrossSessionNoticeWire = Omit<CrossSessionNotice, "text" | FaceExcluded<"task_notification_cross_session_notice">> & {
+    text: SafeText;
+};
+/** 收件箱通告载体的 wire 形:四个计数(`box` 登记不投 —— 同帧已有)。 */
+export type InboxNoticeWire = Omit<InboxNotice, FaceExcluded<"task_notification_inbox_notice">>;
+/** 通告载体的 `kind` 闭集。core 只在型上写这两个词、没导出常量 ⇒ 本表 + 两向锚(`satisfies` 保表内无词表外的词;穷举保词表无表外的词 —— core 加 / 删词 ⇒ tsc 红)。 */
+export declare const CROSS_SESSION_NOTICE_KINDS: readonly ["delivery_notice", "idle_notice"];
+/** 一只嵌套键的判决:读得出 ⇒ 要上 wire 的形;读不出 ⇒ 理由(调用方整键丢并计一次)。 */
+export type Verdict<W> = {
+    readonly wire: W;
+} | {
+    readonly why: string;
+};
+/** 成员读法(本文件与 `sema-provenance.ts` 共用的一组;只判形,不改值)。 */
+/** 纯数据记录:原型是 `Object.prototype` 或 `null`(类实例 / `Date` / `Map` / 数组不算 —— 成员全可选的容器不判原型就会把它们读成 `{}`)。 */
+export declare const isPlainObject: (v: unknown) => v is Record<string, unknown>;
+export declare const isString: (v: unknown) => v is string;
+/** 闭集成员判定 —— 集是 core 导出的常量(不手抄,[ref]),或 core 只在型上写词时本仓经两向锚钉住的词表。 */
+export declare const memberOf: <T extends string>(set: readonly T[]) => (v: unknown) => v is T;
+/** 可选成员:缺席读得出(缺席即缺席,不计数),在场按 `guard` 判。 */
+export declare const optional: <T>(guard: (v: unknown) => v is T) => (v: unknown) => v is T | undefined;
+/** 两条腿入参的形(运行期载荷,先当 `unknown` 收、判过形才成 typed)。 */
+export interface SessionBoxCarrierInput {
+    crossSessionMessage?: unknown;
+    crossSessionNotice?: unknown;
+    inboxNotice?: unknown;
+}
+/**
+ * 会话箱车道的三只载体(core 的 session-box drain 唯一铸点;在场 = 渲染判别,core 优先序 agentMessage → crossSessionMessage →
+ * crossSessionNotice → inboxNotice,本服务不判跨键优先 —— 那是消费端的渲染律)。规则与本文件其余两组同一条:逐成员挑、在场才带、
+ * **在场却读不出 ⇒ 那一只载体整键丢并计一次**(半张卡比没有卡更坏:成员缺席在这些形上是一句正面陈述,读不出若只丢那个成员,
+ * 等于替 producer 说了一句它没说的话)、缺席不计。不跨键判(哪个 lane 词配哪只载体是产生者的律,core 在铸点守)。
+ *  · `crossSessionMessage` —— 对端会话的一条信:`from`(规范编码的发信地址,回信抄进 `to` 的那一串)/ `fromSession` / `fromScope` 身份逐字
+ *    (遮身份会把两个合法地址塌成一个值,与 `spawnName` 同律);`fromMode` 闭集取 core 的 `PERMISSION_MODE_CLASSES`;`fromName`(原始显示名,
+ *    core 只在建信封时规范化)与 `body`(对端正文,UNTRUSTED)经座。
+ *  · `crossSessionNotice` —— `kind` 闭二词({@link CROSS_SESSION_NOTICE_KINDS});`text` 经座。typed 位(`state` / `refSeq` / …)在侧记的
+ *    `peerMeta.notice`(core:「a host renders a card from there, never by parsing `text`」)—— 不平铺进这里(同一事实只一个读点)。
+ *  · `inboxNotice` —— `pending` / `delivered` 必需、`urgent` / `resupplied` 可选,全是计数(非负整数)逐字;`box` 不读不投(登记表排除)。
+ */
+export declare function sessionBoxCarrierFields(n: SessionBoxCarrierInput, seat: FrameTextSeat): {
+    crossSessionMessage?: CrossSessionMessageWire;
+    crossSessionNotice?: CrossSessionNoticeWire;
+    inboxNotice?: InboxNoticeWire;
+};
+/** 判决落定:读得出 ⇒ 形;读不出 ⇒ 交给调用点的丢弃口(字面面名留在调用点,普查门 GU-2 按它点名)。 */
+export declare const settle: <W>(v: Verdict<W>, drop: (why: string) => undefined) => W | undefined;
 export {};
 //# sourceMappingURL=task-notification-facets.d.ts.map

package/dist/trace/task-notification-facets.js

@@ -1,4 +1,5 @@
-import { COMPACTION_KINDS, HANDBACK_STATES } from "@sema-agent/core";
+import { COMPACTION_KINDS, HANDBACK_STATES, PERMISSION_MODE_CLASSES } from "@sema-agent/core";
+import { seatText } from "./exit-seat.js";
 import { dropProjectedFace } from "./projection-drop.js";
 export function terminalFrameFacetFields(n) {
     const spawnName = n.spawnName === undefined ? undefined : typeof n.spawnName === "string" ? n.spawnName : dropProjectedFace("task_notification.spawnName is not a string");
@@ -28,4 +29,73 @@ export function resupplyFields(n) {
         ...(attempt !== undefined ? { attempt } : {}),
     };
 }
+export const CROSS_SESSION_NOTICE_KINDS = ["delivery_notice", "idle_notice"];
+const _noticeKindsExhaustive = true;
+void _noticeKindsExhaustive;
+export const isPlainObject = (v) => {
+    if (typeof v !== "object" || v === null || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+};
+export const isString = (v) => typeof v === "string";
+const isCount = (v) => Number.isInteger(v) && v >= 0;
+export const memberOf = (set) => (v) => set.includes(v);
+export const optional = (guard) => (v) => v === undefined || guard(v);
+const optString = optional(isString);
+const optCount = optional(isCount);
+const optModeClass = optional(memberOf(PERMISSION_MODE_CLASSES));
+const isNoticeKind = memberOf(CROSS_SESSION_NOTICE_KINDS);
+export function sessionBoxCarrierFields(n, seat) {
+    const message = n.crossSessionMessage === undefined ? undefined : settle(crossSessionMessageOf(n.crossSessionMessage, seat), (why) => dropProjectedFace("task_notification.crossSessionMessage " + why));
+    const notice = n.crossSessionNotice === undefined ? undefined : settle(crossSessionNoticeOf(n.crossSessionNotice, seat), (why) => dropProjectedFace("task_notification.crossSessionNotice " + why));
+    const inbox = n.inboxNotice === undefined ? undefined : settle(inboxNoticeOf(n.inboxNotice), (why) => dropProjectedFace("task_notification.inboxNotice " + why));
+    return {
+        ...(message !== undefined ? { crossSessionMessage: message } : {}),
+        ...(notice !== undefined ? { crossSessionNotice: notice } : {}),
+        ...(inbox !== undefined ? { inboxNotice: inbox } : {}),
+    };
+}
+export const settle = (v, drop) => ("why" in v ? drop(v.why) : v.wire);
+function crossSessionMessageOf(raw, seat) {
+    if (!isPlainObject(raw))
+        return { why: "is not a plain-data record" };
+    const { from, fromSession, fromName, fromMode, fromScope, body } = raw;
+    if (!isString(from) || !isString(body))
+        return { why: "is missing a string from / body" };
+    if (!optString(fromSession) || !optString(fromName) || !optString(fromScope))
+        return { why: "has a present fromSession / fromName / fromScope that is not a string" };
+    if (!optModeClass(fromMode))
+        return { why: "fromMode is outside core PERMISSION_MODE_CLASSES" };
+    return {
+        wire: {
+            from,
+            ...(fromSession !== undefined ? { fromSession } : {}),
+            ...(fromName !== undefined ? { fromName: seatText(seat, fromName) } : {}),
+            ...(fromMode !== undefined ? { fromMode } : {}),
+            ...(fromScope !== undefined ? { fromScope } : {}),
+            body: seatText(seat, body),
+        },
+    };
+}
+function crossSessionNoticeOf(raw, seat) {
+    if (!isPlainObject(raw))
+        return { why: "is not a plain-data record" };
+    const { kind, text } = raw;
+    if (!isNoticeKind(kind))
+        return { why: "kind is outside delivery_notice / idle_notice" };
+    if (!isString(text))
+        return { why: "is missing a string text" };
+    return { wire: { kind, text: seatText(seat, text) } };
+}
+function inboxNoticeOf(raw) {
+    if (!isPlainObject(raw))
+        return { why: "is not a plain-data record" };
+    const { pending, delivered, urgent, resupplied } = raw;
+    if (!isCount(pending) || !isCount(delivered))
+        return { why: "is missing a non-negative integer pending / delivered" };
+    if (!optCount(urgent) || !optCount(resupplied))
+        return { why: "has a present urgent / resupplied that is not a non-negative integer" };
+    return { wire: { pending, delivered, ...(urgent !== undefined ? { urgent } : {}), ...(resupplied !== undefined ? { resupplied } : {}) } };
+}
 //# sourceMappingURL=task-notification-facets.js.map

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

@@ -92,15 +92,14 @@ export type DeclaredKey = ManifestShape & {
     readonly optional?: true;
 };
 /**
- * `TaskEvent` **信封**上的键 —— 这一族构造器一个都不管,所以在每一只 TaskEvent 面上统一扣除。
- *  · `type`：臂名由调用点自己拼在投影体外(`{ type: "tool_end", ...toolEndEventData(ev) }`),不是载荷键;
- *  · `sourceTaskId` / `bgAgentId`：live 腿的**四键身份**由 `liveIdentityFields` 单独挑(durable 两腿只挑两键),
- *    属主是那只函数而不是各面构造器 —— 所以对本族构造器它们恒不在投影体里。
+ * `TaskEvent` **信封**上的键 —— 这一族构造器一个都不管,所以在每一只 TaskEvent 面上统一扣除:只有 `type`(臂名由调用点自己拼在投影体外,
+ * `{ type: "tool_end", ...toolEndEventData(ev) }`,不是载荷键)。身份四键(`eventId` / `parentToolCallId` / `sourceTaskId` / `bgAgentId`)
+ * 是载荷键,每只构造器经同一只 `identityFields` 投 —— 不在这里扣。
  * 这是**一条统一规则**,不是十六个面各自的豁免名单:新臂进来自动适用。
  */
-export declare const FRAME_ENVELOPE_KEYS: readonly ["type", "sourceTaskId", "bgAgentId"];
+export declare const FRAME_ENVELOPE_KEYS: readonly ["type"];
 /** 探针文件要从 `@sema-agent/core` 具名导入的类型(`coreType` 表达式里用到的全部名字)。 */
-export declare const WIRE_PROJECTION_CORE_IMPORTS: readonly ["TaskEvent", "BrainStatus", "TaskNotificationPayload", "WiringManifest", "EngineNotice", "MemoryImportReport", "OriginClearanceRow", "OriginClearanceEvent", "MemoryEntryOrigin", "TraceEvent", "PromptManifestIdentity", "PromptIdentityLayers", "PromptManifestSelectors", "PromptManifestSection", "PromptChainLink", "SupersededOverlay", "ToolDisclosureManifest"];
+export declare const WIRE_PROJECTION_CORE_IMPORTS: readonly ["TaskEvent", "BrainStatus", "TaskNotificationPayload", "WiringManifest", "EngineNotice", "MemoryImportReport", "OriginClearanceRow", "OriginClearanceEvent", "MemoryEntryOrigin", "TraceEvent", "PromptManifestIdentity", "PromptIdentityLayers", "PromptManifestSelectors", "PromptManifestSection", "PromptChainLink", "SupersededOverlay", "ToolDisclosureManifest", "SemaProvenance", "MailboxPeerMeta", "MailboxPeerNoticeMeta", "CrossSessionEnvelopeFields"];
 /**
  * `wiring_manifest` 的 **operator 面多投的那几段**(`wiringManifestOperatorEventData` 在租户形之上加的段)。
  * operator 行的 `excluded` = 租户行减本常量(派生);四段各自的受众裁定在 `core-keyset-guard.ts` ⑥b。
@@ -213,16 +212,52 @@ export declare const WIRE_PROJECTION_FACES: {
     readonly human_input: {
         readonly projector: "humanInputEventData";
         readonly coreType: string;
-        readonly excluded: readonly ["principal", "runOrigin"];
+        readonly excluded: readonly ["principal"];
         readonly minted: readonly [];
     };
     readonly task_notification: {
         readonly projector: "taskNotificationEventData";
         readonly coreType: `TaskNotificationPayload & ${string}`;
-        readonly excluded: readonly ["peer", "crossSessionMessage", "crossSessionNotice", "inboxNotice", "received"];
+        readonly excluded: readonly ["peer", "received"];
         readonly unwrapped: readonly ["notification"];
         readonly minted: readonly ["injected"];
     };
+    readonly task_notification_cross_session_message: {
+        readonly projector: "taskNotificationEventData";
+        readonly coreType: "CrossSessionEnvelopeFields & NonNullable<TaskNotificationPayload[\"crossSessionMessage\"]>";
+        readonly excluded: readonly [];
+        readonly minted: readonly [];
+    };
+    readonly task_notification_cross_session_notice: {
+        readonly projector: "taskNotificationEventData";
+        readonly coreType: "NonNullable<TaskNotificationPayload[\"crossSessionNotice\"]>";
+        readonly excluded: readonly [];
+        readonly minted: readonly [];
+    };
+    readonly task_notification_inbox_notice: {
+        readonly projector: "taskNotificationEventData";
+        readonly coreType: "NonNullable<TaskNotificationPayload[\"inboxNotice\"]>";
+        readonly excluded: readonly ["box"];
+        readonly minted: readonly [];
+    };
+    readonly task_notification_provenance: {
+        readonly projector: "taskNotificationEventData";
+        readonly coreType: "SemaProvenance";
+        readonly excluded: readonly [];
+        readonly minted: readonly [];
+    };
+    readonly task_notification_peer_meta: {
+        readonly projector: "taskNotificationEventData";
+        readonly coreType: "MailboxPeerMeta";
+        readonly excluded: readonly ["senderKey", "gateReceiptId", "occupant", "fromOccupant"];
+        readonly minted: readonly [];
+    };
+    readonly task_notification_peer_notice: {
+        readonly projector: "taskNotificationEventData";
+        readonly coreType: "MailboxPeerNoticeMeta";
+        readonly excluded: readonly [];
+        readonly minted: readonly [];
+    };
     readonly wiring_manifest_tenant: {
         readonly projector: "wiringManifestEventData";
         readonly coreType: `WiringManifest & ${string}`;

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

@@ -1,4 +1,4 @@
-export const FRAME_ENVELOPE_KEYS = ["type", "sourceTaskId", "bgAgentId"];
+export const FRAME_ENVELOPE_KEYS = ["type"];
 export const WIRE_PROJECTION_CORE_IMPORTS = [
     "TaskEvent",
     "BrainStatus",
@@ -17,6 +17,10 @@ export const WIRE_PROJECTION_CORE_IMPORTS = [
     "PromptChainLink",
     "SupersededOverlay",
     "ToolDisclosureManifest",
+    "SemaProvenance",
+    "MailboxPeerMeta",
+    "MailboxPeerNoticeMeta",
+    "CrossSessionEnvelopeFields",
 ];
 const arm = (name) => `Extract<TaskEvent, { type: "${name}" }>`;
 const MANIFEST_FRAME = `Extract<TraceEvent, { kind: "prompt.assembled" }>`;
@@ -41,14 +45,35 @@ export const WIRE_PROJECTION_FACES = {
     turn_end: { projector: "turnEndEventData", coreType: arm("turn_end"), excluded: [], minted: [] },
     compaction_outcome: { projector: "compactionOutcomeEventData", coreType: arm("compaction_outcome"), excluded: [], minted: [] },
     compaction_started: { projector: "compactionStartedEventData", coreType: arm("compaction_started"), excluded: [], minted: [] },
-    human_input: { projector: "humanInputEventData", coreType: arm("human_input"), excluded: ["principal", "runOrigin"], minted: [] },
+    human_input: { projector: "humanInputEventData", coreType: arm("human_input"), excluded: ["principal"], minted: [] },
     task_notification: {
         projector: "taskNotificationEventData",
         coreType: `TaskNotificationPayload & ${arm("task_notification")}`,
-        excluded: ["peer", "crossSessionMessage", "crossSessionNotice", "inboxNotice", "received"],
+        excluded: ["peer", "received"],
         unwrapped: ["notification"],
         minted: ["injected"],
     },
+    task_notification_cross_session_message: {
+        projector: "taskNotificationEventData",
+        coreType: `CrossSessionEnvelopeFields & NonNullable<TaskNotificationPayload["crossSessionMessage"]>`,
+        excluded: [],
+        minted: [],
+    },
+    task_notification_cross_session_notice: {
+        projector: "taskNotificationEventData",
+        coreType: `NonNullable<TaskNotificationPayload["crossSessionNotice"]>`,
+        excluded: [],
+        minted: [],
+    },
+    task_notification_inbox_notice: {
+        projector: "taskNotificationEventData",
+        coreType: `NonNullable<TaskNotificationPayload["inboxNotice"]>`,
+        excluded: ["box"],
+        minted: [],
+    },
+    task_notification_provenance: { projector: "taskNotificationEventData", coreType: "SemaProvenance", excluded: [], minted: [] },
+    task_notification_peer_meta: { projector: "taskNotificationEventData", coreType: "MailboxPeerMeta", excluded: ["senderKey", "gateReceiptId", "occupant", "fromOccupant"], minted: [] },
+    task_notification_peer_notice: { projector: "taskNotificationEventData", coreType: "MailboxPeerNoticeMeta", excluded: [], minted: [] },
     wiring_manifest_tenant: {
         projector: "wiringManifestEventData",
         coreType: `WiringManifest & ${arm("wiring_manifest")}`,

package/dist/unread-request-members.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 「请求里有本版读者读不出、而这台部署本会采纳的成员」—— **一只**判据,两个调用点:`boot/resolve-spec.ts` 装配腿首(**拒点**;两腿同判)与
+ * `http/stored-body-replay.ts` 的存体重放预判(五个续跑问点同调,认领之前答)。
+ *
+ * ## 律(一条)
+ * 请求的某个成员,本版的读者读不出(整只不交,或其中几处不交给引擎),而这台部署对这个成员本会采纳(读得出就会生效)⇒ 这份请求不跑。
+ *  · 新提交:`settings.env` 有成员不是帽内串 ⇒ 本判据是唯一的拒点(受理门只判形与帽;HTTP 新提交也走到这里)—— 采纳 env 的车道上 400,其余车道零变;
+ *    其余成员在受理门 / 腿首按各自的判据已 400(本判据在新提交腿上对它们只接得住绕过受理门直调 `resolveSpec` 的嵌入方);
+ *  · 续跑重放(盘上的存量请求体,升级前受理时读得出、本版读不出):拒续跑 —— 409 `resume_blocked_by_policy`(`blockedBy` = `request.field_invalid`,
+ *    `field` = 第一个读不出的坐标,句子点名全部坐标、不回显值),卡仍待决、行不动;出路 = 取消后按本版的形重提。
+ * 修前续跑重放腿把读不出的成员丢掉照跑,只留一行运维 warn(`task_settings_deferred` / `mcp_transport_members_dropped` / `a2a_peer_headers_members_dropped`):
+ * 丢掉的可能是同一份 hooks 里真在拦的守卫、MCP 服务的鉴权头 —— 调用方只看到续跑成功。三条 warn 与 P-DEBT 计数随本判据删除。
+ *
+ * ## 成员(三座,闭集)
+ *  · `settings.<键>`:请求设置解析层(`task-settings.ts` `parseTaskSettings`)报 `deferred` 的键 —— `hooks`(唯一读者拒;续跑重放腿上一次性迁移 M20 的窗开着时先剥键重读,过了就读得出)、
+ *    `env`(有成员读不出:不是对象 / 过帽 / 值不是帽内的串;空记录不算)、`permissions`(不是对象 / 桶不合法)、「只收紧」座位(座位门不过)。采纳与否按键({@link settingsMemberHonored}):
+ *    `hooks` 读 `taskHooksHonored`;`env` 的读者有两个 —— 模型的工具 shell(部署形表行 `callerCwd`)与 settings hooks 的子进程 env / http `$NAME` 插值源(`taskHooksHonored` ∧ 这份请求带着读得出的 hooks),
+ *    任一在 ⇒ 采纳;其余每条车道都采纳;
+ *  · `mcpServers[<下标>].transport.<路径>`:请求面 MCP 条目挂得上、名字不被部署占住(部署声明过的名字一律关给请求面,与挂载的合并同一只 `deploymentClosedMcpNames`)、
+ *    transport 却有几处不交给引擎(`task-mcp.ts` `requestMcpTransportUnread`);采纳 = `mcpInjectionHonored`;
+ *  · `a2aPeers[<下标>].headers.<成员>`:请求面 A2A 对端挂得上、`headers` 里剔掉的成员(`task-a2a.ts` `requestA2aHeadersUnread`);采纳 = `a2aInjectionHonored`。
+ * 坐标只有键路径与下标(成员名只会是读器的保留名),不带值、不带调用方写的名字。
+ * A2A 一座不看部署同名占位:A2A 的占位是**按场景**的部署对端(`a2aForScenario`),存体预判在认领之前答、不知道这一跑落在哪个场景 ⇒ 一只读不出的对端若会输给同场景的部署同名对端(不挂),
+ * 本判据照样拒 —— 方向是多拒一次(出路同上),不是少拦。MCP 的占位与场景无关(部署声明过的全部名字),所以 MCP 一座按占位判。
+ *
+ * ## 不在射程内(已披露)
+ * 读者把**整条**摘下的条目(MCP / A2A 条目不是对象、硬键坏形:有用户面通告 `mcp.injection_dropped` / 运维 warn `a2a_injection_dropped`)、条目上被丢的软键
+ * (`contentOrigin` 降级、`elicitation` / `source` 读不出)不在本判据里。
+ */
+import { type LaneAxisInput, type PrincipalAxisInput } from "./deployment-shape.js";
+import { type SettingsEnvLayer } from "./task-settings.js";
+import { mcpInjectionHonored } from "./task-mcp.js";
+import type { CenterMcp } from "./config-types.js";
+import { type A2aGateConfig } from "./task-a2a.js";
+import type { StoredToolAxesRereadM19 } from "./stored-request-tool-axes-m19.js";
+import type { Refusal } from "./http/refusal-body.js";
+/** 判据读的部署事实(`ServiceConfig` 结构上满足):租户轴、已合成的车道、两只注入闸的否决位、部署的 MCP 声明(占住的名字)。 */
+export type UnreadMembersDeployment = PrincipalAxisInput & LaneAxisInput & A2aGateConfig & Parameters<typeof mcpInjectionHonored>[0] & {
+    readonly mcpServers?: Pick<CenterMcp, "servers" | "reservedNames"> | undefined;
+};
+/** 请求里本判据读的三座(原样;调用方从请求体取 —— `resolveSpec` 的 A2A 一座递它腿首那一份快照)。 */
+export interface UnreadMembersRequest {
+    readonly settings: unknown;
+    readonly mcpServers: unknown;
+    readonly a2aPeers: unknown;
+}
+/** 读的是哪条腿,与那条腿的读法座:续跑重放腿递 M19 的重读座(调用方求值一次,挂载那一读用同一份)与「今天」(M20 的窗按它问);新提交腿两座都没有。 */
+export type UnreadMembersLeg = {
+    readonly replay: false;
+    readonly settingsEnv?: SettingsEnvLayer | undefined;
+} | {
+    readonly replay: true;
+    readonly today: string;
+    readonly storedToolAxes: StoredToolAxesRereadM19 | undefined;
+    readonly settingsEnv?: SettingsEnvLayer | undefined;
+};
+/** 拒句(与运维行)至多点名的坐标数(余下的报总数)。 */
+export declare const MAX_NAMED_MEMBERS = 8;
+/** 读不出、而本部署会采纳的成员坐标(文档序:设置 → MCP → A2A);空 = 这份请求的每个成员都读得出(或读不出的那几个本部署本来就不采纳)。 */
+export declare function unreadRequestMembers(request: UnreadMembersRequest, deployment: UnreadMembersDeployment, leg: UnreadMembersLeg): readonly string[];
+/**
+ * 判据命中的拒:码 `request.field_invalid`(各成员的新提交判据答的同一个码),`field` = 第一个坐标,句子点名全部坐标(至多 {@link MAX_NAMED_MEMBERS} 个,余下报总数)。
+ * 拒点(`resolveSpec`)把它抛成 400;续跑口把它折成 409 `resume_blocked_by_policy`(预判与折叠调同一只折法,同码同句)。纯数据。
+ */
+export declare function unreadRequestMembersRefusal(members: readonly [string, ...string[]]): Refusal;
+//# sourceMappingURL=unread-request-members.d.ts.map

package/dist/unread-request-members.js

@@ -0,0 +1,41 @@
+import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
+import { parseTaskSettings, taskHooksHonored } from "./task-settings.js";
+import { deploymentClosedMcpNames, mcpInjectionHonored, requestMcpTransportUnread } from "./task-mcp.js";
+import { a2aInjectionHonored, requestA2aHeadersUnread } from "./task-a2a.js";
+import { storedHooksRereadM20 } from "./stored-request-hooks-m20.js";
+export const MAX_NAMED_MEMBERS = 8;
+function settingsMemberHonored(key, deployment, carriesHooks) {
+    switch (key) {
+        case "hooks":
+            return taskHooksHonored(deployment);
+        case "env":
+            return DEPLOYMENT_SHAPE_PREDICATES.callerCwd.holds(deployment) || (carriesHooks && taskHooksHonored(deployment));
+        default:
+            return true;
+    }
+}
+export function unreadRequestMembers(request, deployment, leg) {
+    const hooksReread = leg.replay && taskHooksHonored(deployment) ? storedHooksRereadM20(leg.today) : undefined;
+    const settings = parseTaskSettings(request.settings, { ...(hooksReread !== undefined ? { storedHooksReread: hooksReread } : {}), ...(leg.settingsEnv !== undefined ? { settingsEnv: leg.settingsEnv } : {}) });
+    const carriesHooks = settings.settings?.hooks !== undefined;
+    const out = settings.deferred.filter((key) => settingsMemberHonored(key, deployment, carriesHooks)).map((key) => `settings.${key}`);
+    const storedToolAxes = leg.replay ? leg.storedToolAxes : undefined;
+    if (mcpInjectionHonored(deployment)) {
+        const closed = deploymentClosedMcpNames(deployment.mcpServers?.servers.map((s) => s.spec), deployment.mcpServers?.reservedNames ?? []);
+        out.push(...requestMcpTransportUnread(request.mcpServers, closed, storedToolAxes));
+    }
+    if (a2aInjectionHonored(deployment))
+        out.push(...requestA2aHeadersUnread(request.a2aPeers, storedToolAxes));
+    return out;
+}
+export function unreadRequestMembersRefusal(members) {
+    const named = members.slice(0, MAX_NAMED_MEMBERS);
+    const more = members.length > named.length ? ` (and ${members.length - named.length} more)` : "";
+    return {
+        errorCode: "request.field_invalid",
+        message: `this request carries ${members.length === 1 ? "a member" : "members"} this server version's readers cannot take as written, on a deployment that would apply ${members.length === 1 ? "it" : "them"}: ` +
+            `${named.join(", ")}${more} — running it would silently leave ${members.length === 1 ? "that member" : "those members"} out (a hook that guards a tool, an MCP server's credentials); submit it again with ${members.length === 1 ? "this member" : "these members"} in the current form`,
+        facts: { field: members[0] },
+    };
+}
+//# sourceMappingURL=unread-request-members.js.map

package/dist/upstream-body.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 🔴 **上游应答体的 JSON 读口(唯一)** —— 本服务对任何上游(配置中心 / 记忆同步对端 / fleet 协调器 / 搜索后端 / bake 队列 / hook 的模型端点 / 凭据签发方 …)
+ * 的应答体解 JSON,只经这里。
+ *
+ * 一条律:**上游应答体的字节不进本服务铸的报错句**(只说体长,{@link buildBodyWithheldNote})。V8 的 `JSON.parse` 报错句内嵌入参的片段
+ * (`Unexpected token 's', "sk-proj-ab"... is not valid JSON`)—— 那是在出口座**之前**就切好的半截:脱敏器认得整枚令牌,认不得它的前 10 个字,
+ * 于是之后任何经出口座的出口(运维日志接缝、trace 帧)都挡不住它(env 旋钮的坏 JSON 早就不转述 V8 句,同一条理由)。
+ * 这里解析失败只说形:`the response body is not JSON (<n> characters; the body is not echoed)`;类名照旧是 `SyntaxError` ——
+ * 调用方按类定成因的读法不变(中心拉取:`SyntaxError` ⇒ 候选被拒 `rejected`;hook 模型端点:按名判 `bad_response`)。
+ * 读体途中的传输错(连接被重置的 `TypeError`、超时的 `AbortError`)原样抛:那不是「答错了」,是没拿到完整应答。
+ *
+ * 门:`test/upstream-json-single-reader.test.ts` —— `src/` 里 `.json()` 调用在本模块之外恒为 0(语法树)。
+ * 纯叶(零 import)。
+ */
+/** 报错句的固定头(钉与读者按它认这一形;句子其余部分只有体长)。 */
+export declare const UPSTREAM_BODY_NOT_JSON = "the response body is not JSON";
+/** 一段应答体进报错句时的那一格(只有体长;本服务对上游应答体在报错句里只说这一句 —— 体不是 JSON 的句子与记忆同步对端的非 2xx 句同读)。 */
+export declare function buildBodyWithheldNote(text: string): string;
+/** 已读出的应答体文本 → JSON 值;不是 JSON ⇒ 抛 `SyntaxError`(句子只有体长,不带体的任何字节)。 */
+export declare function parseUpstreamJson(text: string): unknown;
+/** 读完应答体再解 JSON(`Response.json()` 的替身:同一份 UTF-8 解码);读体途中的传输错原样抛。 */
+export declare function readUpstreamJson(res: Response): Promise<unknown>;
+//# sourceMappingURL=upstream-body.d.ts.map

package/dist/upstream-body.js

@@ -0,0 +1,16 @@
+export const UPSTREAM_BODY_NOT_JSON = "the response body is not JSON";
+export function buildBodyWithheldNote(text) {
+    return `(${text.length} characters; the body is not echoed)`;
+}
+export function parseUpstreamJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new SyntaxError(`${UPSTREAM_BODY_NOT_JSON} ${buildBodyWithheldNote(text)}`);
+    }
+}
+export async function readUpstreamJson(res) {
+    return parseUpstreamJson(await res.text());
+}
+//# sourceMappingURL=upstream-body.js.map

package/dist/url-refusal.d.ts

@@ -31,10 +31,10 @@ export declare function buildRefusalShownUrl(raw: string): string;
 /**
  * **自由文本里每一条嵌着的 http(s) URL 换成它的展示形**({@link buildRefusalShownUrl}:`scheme://host[:port]`,origin 之后还有东西接 `/…`;读法不唯一 / 读不出的串给展示铸点的占位),
  * 句子其余部分逐字不动。用在宿主不控制句子的日志面 —— 引擎把「拨不通的 A2A 对端 / MCP 服务器」连同被拨的 URL 拼成一句交来(`onError`),宿主手里没有那条 URL 的结构化值,
- * 只能在文本上换。展示形的铸点仍只有 {@link buildRefusalShownUrl} 一只(userinfo / 路径 / query / fragment 一个字节不进,不赌形状律认得出的令牌形);本函数只负责「找到文本里的 URL」。
- * 非 http(s) 的 scheme 不在射程(这两座的 URL 读器只收 http(s))。纯函数。
+ * 只能在文本上换。展示形的铸点仍只有 {@link buildRefusalShownUrl} 一只(userinfo / 路径 / query / fragment 一个字节不进,不赌形状律认得出的令牌形);本函数只负责「找到文本里的 URL」,
+ * 找的界见 {@link EMBEDDED_HTTP_URL}(authority 文法)。非 http(s) 的 scheme 不在射程(这两座的 URL 读器只收 http(s))。纯函数。
  *
- * 已知的界(不是兜底):URL 串里含**裸空白**的(userinfo 里写了空格)在第一个空白处被截 —— 余下的尾巴留在句里。那一形是调用方在受理口就被拒的(userinfo 一律 400),
+ * 已知的界(文法之外,不是兜底):userinfo 里的**裸空白**不是 URL 文法的一部分 —— 串在第一个空白处结束,余下的尾巴留在句里。那一形是调用方在受理口就被拒的(userinfo 一律 400),
  * 到不了这里的只有存量停驻体 / 部署基线;引擎的警告句对该形也是把 URL 原样拼进去,没有结构化值可救。
  */
 export declare function buildShownUrlsInText(text: string): string;

package/dist/url-refusal.js

@@ -11,11 +11,18 @@ export function buildRefusalShownUrl(raw) {
     const origin = `${u.protocol}//${u.host}`;
     return `${buildDisplaySafeUrl(origin)}${u.href === `${origin}/` ? "" : "/…"}`;
 }
-const EMBEDDED_HTTP_URL = /https?:\/\/[^\s"'`<>()[\]{}]+/gi;
+const EMBEDDED_HTTP_URL = /(https?:\/\/)(?=\S)((?:[^\s/?#\\]*@)?(?:\[[^\s\]/?#\\]*\]|[^\s"'`<>()[\]{}/?#\\@:]*)(?::\d+)?)(\S*)/gi;
+const SENTENCE_TAIL_CHARS = ".,;:!?)]}>'\"`";
+function sentenceTailStart(rest) {
+    let at = rest.length;
+    while (at > 0 && SENTENCE_TAIL_CHARS.includes(rest.charAt(at - 1)))
+        at -= 1;
+    return at;
+}
 export function buildShownUrlsInText(text) {
-    return text.replace(EMBEDDED_HTTP_URL, (token) => {
-        const trail = /[.,;:!?]+$/.exec(token)?.[0] ?? "";
-        return buildRefusalShownUrl(trail === "" ? token : token.slice(0, -trail.length)) + trail;
+    return text.replace(EMBEDDED_HTTP_URL, (_token, scheme, authority, rest) => {
+        const at = sentenceTailStart(rest);
+        return buildRefusalShownUrl(`${scheme}${authority}${rest.slice(0, at)}`) + rest.slice(at);
     });
 }
 export function buildHttpUrlRefusal(subject, raw, flaws) {

package/dist/user-authored-text.d.ts

@@ -32,7 +32,7 @@ export declare function buildRunObjectivePreview(objective: string): string;
  * 这条消息是不是**附件帧**(core 7.50.0 请求层附件:目标声明的每只文件由引擎铸成一条自己的 user 消息,紧跟目标提交)。
  * 判据 = 引擎写在消息上的送达记录 `attachment` **在场**(core:那只记录是「这条消息是附件帧」的唯一来源,文本从不判)。坏形记录同样算在场 ——
  * 两个读者都往「不是人写的话」那一侧落(预览走下一条;会话视图按文件字节脱敏),那是安全的一侧。
- * 一个事实一个读法:会话视图的处置表(`audit.ts`)与本地会话列表的预览(`plugins/local-session-store.ts`)同调这一只。
+ * 一个事实一个读法:会话视图的处置表(`audit.ts`)调这一只(会话列表的预览读 run 行预览列,不读会话条目 —— 附件帧本不在其中)。
  */
 export declare function isAttachmentFrame(message: unknown): boolean;
 //# sourceMappingURL=user-authored-text.d.ts.map