@sema-agent/server 7.146.0 → 7.147.0

package/dist/trace/sema-provenance.d.ts

@@ -1,45 +1,49 @@
 /**
- * [ref](a)(core 7.2.0 / [ref] 片6 d1):`task_notification` 帧上 `_sema_provenance` typed 归因侧记的
- * **单点**投影判据——live 三腿(`trace/project.ts` 的 `taskNotificationEventData`)与 park 半场
- * (`orchestration/workflow-completion-inbox.ts` 的 `taskNotificationInboxEntry`)共用,两腿字节同判。
+ * [ref](a)(core 7.2.0 / [ref] 片6 d1)· [ref](会话箱车道三 lane 同批翻):`task_notification` 帧上 `_sema_provenance` typed 归因侧记的
+ * **单点**投影判据 —— live 三腿(`trace/project.ts` 的 `taskNotificationEventData`)与 park 半场
+ * (`orchestration/workflow-completion-inbox.ts` 的 `taskNotificationInboxEntry`)共用,两腿同判(park 腿的 drain 直接 spread extras 成帧、
+ * 不再经 project.ts,判据必须在入库前做,而且只能有一份)。一只 wire 键一个判据文件:同帧三只会话箱载体在 `task-notification-facets.ts`。
  *
- * `kind` 是**闭集**——wire 上只许出现 core 词表里的 lane 词。两向锚([ref]/[ref] 同纪律,与
- * routes/notify-wake.ts 的 `NOTIFY_STATUSES` 同形):`satisfies` 保「表内无词表外的词」(core 删/改词 ⇒ 编译红),
- * 穷举断言保「词表无表外的词」(core 加 lane ⇒ 编译红,新词必须由人处置——它是 cli 渲染判别键,静默透传一个
- * 未知 lane 等于替 core 声明一种渲染形)。运行期闭集外的值(上游漂了 / 载荷被改过)⇒ **丢整键**,与 `priority`
- * 的闭集守卫(`trace/injection-tier.ts`)同判:消费端退回老形卡,不按未知 lane 猜;`agentMessage` 不受牵连
- * (它是渲染判别,不是 lane 词)。
+ * 规则与那三只载体同一条:逐成员挑(绝不 spread)、在场才带、**在场却读不出 ⇒ 整键丢并计一次**(`dropProjectedFace`,NP-5)、缺席不计;
+ * 身份 / 地址 / 闭集词 / 计数 / 时刻逐字,展示 / 自由文本成员经出口座(座由腿给:{@link FrameTextSeat})。
+ *  · `kind` —— **闭集**:wire 上只许出现 core 词表里的 lane 词。两向锚([ref]/[ref] 同纪律):`satisfies` 保「表内无词表外的词」(core 删 / 改词
+ *    ⇒ 编译红),穷举断言保「词表无表外的词」(core 加 lane ⇒ 编译红 —— 新词必须由人处置:它是渲染判别键,静默透传一个未知 lane 等于替 core 声明一种
+ *    渲染形)。运行期词表外的值(上游漂了 / 载荷被改过)⇒ 整键丢并计一次,消费端退回老形卡;同帧载体不受牵连(它们是渲染判别,不是 lane 词)。
+ *  · `from` / `taskId` / `seq` 必需,`agentType` 可选(本 mount 的 agent_message lane 恒缺席,在场即逐字)。
+ *  · `peerMeta` —— 两种箱记录 lane 上 store 记录的 typed peer 元数据(core:「the store record's typed peer metadata, verbatim (authority; a notice
+ *    frame's `peerMeta.notice` is the typed notice, its carrier holds only the rendered line)」)。逐成员:`fromSession` / `fromRoot` / `fromScope`
+ *    身份 / 寻址串逐字;`fromMode` / `kind` 闭集取 core 导出的 `MAILBOX_PEER_FROM_MODES` / `MAILBOX_PEER_RECORD_KINDS`(不手抄,[ref]);`urgent` 布尔;
+ *    `notice` 见下。**`senderKey` / `gateReceiptId` / `occupant` / `fromOccupant` 不读不投**(登记在 `wire-projection-faces.ts` 的
+ *    `task_notification_peer_meta` 行,一条律:凭据 / 身份令牌类 —— 准入闸的发信方键、跨主体投递闸的回执号、收发两方会话的化身令牌;
+ *    与顶层 `peer.senderKey` 同律,安全轴 fail-closed)。
+ *  · `peerMeta.notice` —— 回执 / idle 通告的 typed 正体:`state` 必需、**开集串逐字**(core 型 `string`;新词原样过境,kind↔state 的配对是 drain 的判,
+ *    本服务不复判);`refSeq` / `finishedAt` 非负有限数(与 core 存储校验同界);`recipient` / `target`(展示标签)、`detail`(目标会话的那一行)、
+ *    `dropReason` 是别处来的文本 ⇒ 经座。
+ * 不跨成员判(哪个 lane 带 `peerMeta`、哪个 lane 配哪只载体):那是产生者的律,core 在铸点守;本服务只判每个成员自己的形。
  */
-import type { SemaProvenance } from "@sema-agent/core";
-/** wire 放行的 lane 词(PROJECTED)。 */
-export declare const SEMA_PROVENANCE_KINDS: readonly ["agent_message"];
-/**
- * 有意**不**放行的 lane 词(EXCLUDED,逐词记账;运行期落到「丢整键」臂 —— 与闭集外的未知词同臂,但这里的词是
- * core 词表**内**的、经人裁定不上 wire 的):
- *  · `cross_session_message` —— core fc52b4d4 [ref] §4.1(session-box drain 铸;`from` 是对端**地址**、`peerMeta`
- *    携 typed peer 记录)。🔴 **7.91.0 订正**:`RunnerDeps.peerDirectory` 座已接线([ref])⇒ 「本仓不可达」那半句作废,
- *    有席的部署上这个 lane 词真的会被铸出来;仍不放行的理由只剩**注入帧渲染形候 [ref] @server③ 表态**。
- *    与 core-keyset-guard.ts ① 的 `crossSessionMessage` / ①-nested 的 `peerMeta` 同批同判,表态之后三处同翻。
- *  · `cross_session_notice` —— core 7.4.0 [ref] §4.4/§5.2(片4;本闭集 2026-09-05 真红出它)。**同一条车道的
- *    第二个载体**,不是新判据:同一个 session-box drain 铸(`agents/peer-session-drain.js` 的 notice 臂),同一个
- *    `RunnerDeps.peerDirectory` 座前提(同样自 7.91.0 起在场);渲染形与它的载体 `crossSessionNotice`
- *    (core-keyset-guard.ts ① 的同名排除键)一同候 [ref] 表态。放进 EXCLUDED 而不是 PROJECTED,是**沿用**上一行的
- *    裁定而不是新增特判:表态未出前放行一个 lane 词,等于替它预先声明一种 cli 渲染形。表态落定那天三处(本簿、
- *    载体键、①-nested 的 `peerMeta`)同批翻。
- *  · `inbox_notice` —— core 7.30.0 [ref]([ref] 提货;本闭集当拍真红出它)。**同一条车道的第三个载体**(收件箱通告,
- *    `crossSessionMessage` / `crossSessionNotice` 之后),同一个 session-box drain 铸;载体键 `inboxNotice` 在
- *    core-keyset-guard.ts ① 同批进 EXCLUDED。沿用上两行的裁定,不是新判据:[ref] 表态落定那天四处同批翻。
- */
-export declare const SEMA_PROVENANCE_KINDS_EXCLUDED: readonly ["cross_session_message", "cross_session_notice", "inbox_notice"];
-/** 本仓两条腿入参的**形**(不是 core 类型:入参是运行期载荷,`kind` 先当 string 收、经闭集才成 typed)。 */
-export interface SemaProvenanceInput {
-    kind: string;
-    from: string;
-    taskId: string;
-    seq: number;
-    agentType?: string;
-}
-/** 逐成员挑取(绝不 spread —— core 给侧记加成员时必须经 keyset 门处置,见 `trace/core-keyset-guard.ts` ①);
- *  返回 undefined = 闭集外 / 形不合 ⇒ 调用方丢整键。`agentType` 缺席不编(本 mount 恒缺席,在场即透传)。 */
-export declare function semaProvenanceOrAbsent(p: SemaProvenanceInput): SemaProvenance | undefined;
+import { type MailboxPeerMeta, type MailboxPeerNoticeMeta, type SemaProvenance } from "@sema-agent/core";
+import { type SafeText } from "./exit-seat.js";
+import { type FaceExcluded, type FrameTextSeat } from "./task-notification-facets.js";
+/** wire 放行的 lane 词 = core 词表全员(会话箱车道三词自 [ref] 起与 `agent_message` 同簿;不再有「有意不放行」的第二簿)。 */
+export declare const SEMA_PROVENANCE_KINDS: readonly ["agent_message", "cross_session_message", "cross_session_notice", "inbox_notice"];
+type NoticeText = "recipient" | "dropReason" | "detail" | "target";
+/** `peerMeta.notice` 的 wire 形:core 型减登记表排除;展示 / 自由文本成员是出口座铸的 {@link SafeText}。 */
+export type PeerNoticeWire = Omit<MailboxPeerNoticeMeta, NoticeText | FaceExcluded<"task_notification_peer_notice">> & {
+    [K in Exclude<NoticeText, FaceExcluded<"task_notification_peer_notice">>]?: SafeText;
+};
+/** `peerMeta` 的 wire 形:core 型减登记表排除(`senderKey` / `gateReceiptId` / `occupant` / `fromOccupant`)。 */
+export type PeerMetaWire = Omit<MailboxPeerMeta, "notice" | FaceExcluded<"task_notification_peer_meta">> & {
+    notice?: PeerNoticeWire;
+};
+/** 侧记的 wire 形:core 型减登记表排除(今天零排除)。 */
+export type SemaProvenanceWire = Omit<SemaProvenance, "peerMeta" | FaceExcluded<"task_notification_provenance">> & {
+    peerMeta?: PeerMetaWire;
+};
+/** `_sema_provenance` 这一只键(在场才铸;读不出 ⇒ 整键丢并计一次)。两腿入参的形不是 core 类型:运行期载荷先当 `unknown` 收、判过形才成 typed。 */
+export declare function semaProvenanceFields(n: {
+    _sema_provenance?: unknown;
+}, seat: FrameTextSeat): {
+    _sema_provenance?: SemaProvenanceWire;
+};
+export {};
 //# sourceMappingURL=sema-provenance.d.ts.map

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

@@ -100,7 +100,7 @@ export type DeclaredKey = ManifestShape & {
  */
 export declare const FRAME_ENVELOPE_KEYS: readonly ["type", "sourceTaskId", "bgAgentId"];
 /** 探针文件要从 `@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。
@@ -219,10 +219,46 @@ export declare const WIRE_PROJECTION_FACES: {
     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

@@ -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" }>`;
@@ -45,10 +49,31 @@ export const WIRE_PROJECTION_FACES = {
     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/user-input-ledger.d.ts

@@ -46,7 +46,7 @@
  * 转移只有四条(open → settled | converged;converged → announced),两只孪生都按 CAS 守它们(File 单进程 = 内存判;SQL = `WHERE state=…`)。
  *  · `erased`    —— ([ref])**会话树删除**:该会话此前的每一次受理(不论状态)离开账本。行随会话走 —— 账本行的唯一归属键就是 `sessionId`,
  *                   所以两条删会话树的级联(在线删除协调器 `boot/session-faces.ts` 的 `purgeSession`、托管留存的事务化孪生
- *                   `retention-store-sql.ts` 的 `purgeSessionTrees`)各有一臂删它,谓词同一只(`session_id` 单键,店动词 `deleteBySession`)。
+ *                   `plugins/retention-deployment.ts` 的 `deleteDeploymentSessionRows`)各有一臂删它,谓词同一只(`session_id` 单键,店动词 `deleteBySession`)。
  *                   File 孪生的盘上形 = 一行会话级墓碑 `{ kind:"erased", sessionId, at }`(与 workflow 完成信箱 `drain{sessionId}` 同形),
  *                   只擦它**之前**的同会话行 —— 会话 id 删后可被重新登记,之后的受理属于下一位住客;SQL 孪生 = 真删行。被删受理上迟到的转移全输
  *                   (行不在了,与「未知 acceptId」同一条守卫)。
@@ -264,7 +264,7 @@ export interface UserInputLedgerStore {
     /** [ref] —— **会话树删除**:删掉该会话**每一种状态**的受理,回删除条数(没有可删的 ⇒ 0、零写;幂等)。按 `session_id` 单键:行上没有属主列,
      *  会话所有权由调用方证过(在线删除 = 路由的 DELETE 门;留存 = 候选集本身出自本域加锁读的 `session_meta`),与 anchors / exemptions /
      *  attachments 同律。调用方 = 在线删除协调器(`boot/session-faces.ts` `purgeSession` 的一腿);托管留存的事务化孪生不调店、在自己的事务里
-     *  发**同一只谓词**(`retention-store-sql.ts` `purgeSessionTrees` ④)。写不进 ⇒ 抛(协调器据此不删会话本体,幂等重试收敛)。 */
+     *  发**同一只谓词**(`retention-deployment.ts` `deleteDeploymentSessionRows` ④)。写不进 ⇒ 抛(协调器据此不删会话本体,幂等重试收敛)。 */
     deleteBySession(sessionId: string): Promise<number>;
 }
 /** 收敛判词读的 run 店面(只读一只动词)。 */