@sema-agent/server 7.145.0 → 7.147.0

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。
@@ -171,7 +171,7 @@ export declare const WIRE_PROJECTION_FACES: {
     readonly workspace_changed: {
         readonly projector: "workspaceChangedEventData";
         readonly coreType: string;
-        readonly excluded: readonly ["root", "remote", "entered", "project"];
+        readonly excluded: readonly ["root", "remote", "entered", "project", "session"];
         readonly minted: readonly [];
     };
     readonly status: {
@@ -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" }>`;
@@ -34,7 +38,7 @@ export const WIRE_PROJECTION_FACES = {
     tool_roster_delta: { projector: "toolRosterDeltaEventData", coreType: arm("tool_roster_delta"), excluded: [], minted: [] },
     diagnostics: { projector: "diagnosticsEventData", coreType: arm("diagnostics"), excluded: [], minted: [] },
     steering_injected: { projector: "steeringInjectedEventData", coreType: arm("steering_injected"), excluded: [], minted: [] },
-    workspace_changed: { projector: "workspaceChangedEventData", coreType: arm("workspace_changed"), excluded: ["root", "remote", "entered", "project"], minted: [] },
+    workspace_changed: { projector: "workspaceChangedEventData", coreType: arm("workspace_changed"), excluded: ["root", "remote", "entered", "project", "session"], minted: [] },
     status: { projector: "brainStatusEventData", coreType: `BrainStatus & ${arm("status")}`, excluded: [], minted: [] },
     compacted: { projector: "compactedEventData", coreType: arm("compacted"), excluded: [], minted: [] },
     context_usage: { projector: "contextUsageEventData", coreType: arm("context_usage"), excluded: [], minted: [] },
@@ -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/usage-analytics.d.ts

@@ -16,6 +16,10 @@
  *    第二种口径不完整:**有 echo 行但缺数值键**(该键按 0 计入 ⇒ 总量偏低)——两臂同义:别把总数当精确值;
  *  - 行内数值键一律走 {@link numOf} 守卫:数据源是 DB 里的 JSON,裸算术遇缺席/非数会 NaN 毒掉整窗(#59);
  *  - 扫窗有行数上限(store 侧 LIMIT)——触顶时结果携带 `truncated:true`(诚实截断,绝不静默)。
+ *
+ * 窗契约(三个后端同一条,`usageScan(fromMs, toMs)`):窗是**半开 `[fromMs, toMs)`** —— 创建毫秒 `t` 满足 `fromMs <= t < toMs` 的行才计
+ * (内存 / 文件腿 `t < fromMs || t >= toMs` 跳过;SQL 腿 `created_at >= ? AND created_at < ?`,列是毫秒精度)。上界**不含**。
+ * 路由 `/v1/usage/*` 的**缺省** `to` 取 `now + 1`(「到此刻为止,含此刻」是缺省值的定义,店不为它开特例);请求显式给的 `to` 原义不变(不含)。
  */
 /** store 侧 usageScan 的行投影(所有后端同形状;createdAtMs=epoch ms)。 */
 export interface UsageRow {

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 店面(只读一只动词)。 */

package/dist/web-admin-client/apply-effective.js

@@ -1,9 +1,9 @@
 import { expandTiers, modelOriginOf, resolveTaskModel as coreResolveTaskModel } from "@sema-agent/core";
-import { CATALOG_REPLACES_ENV_MODELS_CODE, SandboxGitConfig, WEB_ADMIN_ENV, envModelsDecisionTag, formatConfigPath, narrowAtMention, resolveActiveTiers, resolveCatalogDefaultModel, sanitizeZodError } from "@sema-agent/settings-schema";
+import { CATALOG_REPLACES_ENV_MODELS_CODE, SandboxGitConfig, WEB_ADMIN_ENV, envModelsDecisionTag, formatConfigPath, narrowAtMention, parseDomainSalvaged, resolveActiveTiers, resolveCatalogDefaultModel, sanitizeZodError } from "@sema-agent/settings-schema";
 import { modelKeyPoison } from "../key-resolver.js";
 import { DEFAULT_MODEL_REF, buildEnvModelIdNotServedNotice, mintCapabilityKeys, readAtMention, servedModelTableLeg } from "../model-select.js";
 import { applyAutoCompactWindow, buildModelCostKey, isRosterGateArmed, ownCredentialHitsInForce, parseAutonomy, unmatchableToolNamesRefusal } from "../config.js";
-import { NAME_TABLE_BEHAVIOR } from "../namespaced-rule-name.js";
+import { NAME_TABLE_BEHAVIOR, retiredWithoutSuccessorEntries } from "../namespaced-rule-name.js";
 import { buildModelCompat, readModelCompat } from "../model-compat.js";
 import { buildModelHeadersKey } from "../model-entry-headers.js";
 import { validateCommandRules } from "../runtime-governance.js";
@@ -29,13 +29,11 @@ function envDerivedModel(config) {
 }
 function toModel(m, envDefaults = {}, logger) {
     const thinkingDefault = envDefaults.defaultThinking;
-    const declared = readModelCompat(m.compat);
+    const declared = readModelCompat(m.api, m.compat);
     if (!declared.ok)
         logger?.warn("model_compat_dropped", { model: m.name, issue: declared.issue, hint: "the per-model wire-compat declaration was dropped whole — the engine falls back to its own inference (today's behaviour); fix the entry to make it live" });
-    else if (declared.compat !== undefined && m.provider === "anthropic") {
-        logger?.warn("model_compat_dropped", { model: m.name, issue: "declared on an anthropic model", hint: "`compat` mirrors OpenAICompletionsCompat — the Anthropic brain reads AnthropicMessagesCompat and never sees these keys; the declaration is dropped" });
-    }
-    const compat = m.provider === "anthropic" ? undefined : buildModelCompat(declared.ok ? declared.compat : undefined, envDefaults.compat);
+    const envCompat = envDefaults.api === m.api ? envDefaults.compat : undefined;
+    const compat = buildModelCompat(m.api, declared.ok ? declared.compat : undefined, envCompat);
     const model = {
         id: m.id,
         name: m.name,
@@ -52,6 +50,7 @@ function toModel(m, envDefaults = {}, logger) {
         params: { ...(m.tier ? { tier: m.tier } : {}), promptCacheFamily: m.provider === "anthropic" ? "input-excludes-cached" : "input-includes-cached" },
         ...(thinkingDefault ? { defaultThinking: thinkingDefault } : {}),
         ...(compat ? { compat } : {}),
+        ...(m.thinkingLevelMap !== undefined ? { thinkingLevelMap: m.thinkingLevelMap } : {}),
         ...(m.extraBody ? { extraBody: m.extraBody } : {}),
         ...buildModelHeadersKey(m.name, m.headers, m.api),
     };
@@ -399,7 +398,7 @@ function stageModelPlane(config, eff, source, logger, sealedKeys) {
         const modelApiKeyEnv = {};
         const modelApiKeys = {};
         const envModel = envDerivedModel(config);
-        const envDefaults = { maxTokens: envModel.maxTokens, contextWindow: envModel.contextWindow, charsPerToken: envModel.charsPerToken, defaultThinking: envModel.defaultThinking, compat: envModel.compat };
+        const envDefaults = { maxTokens: envModel.maxTokens, contextWindow: envModel.contextWindow, charsPerToken: envModel.charsPerToken, defaultThinking: envModel.defaultThinking, api: envModel.api, compat: envModel.compat };
         for (const m of usable) {
             if (m.baseUrl)
                 logger?.warn("web_admin_model_base_url", { model: m.name, baseUrl: buildDisplaySafeUrl(m.baseUrl), hint: "registry-directed gateway override — this model's key authenticates AGAINST THIS URL" });
@@ -543,22 +542,10 @@ function stageEffective(config, eff, logger, opts) {
     const approvalGate = stageApprovalGate(config, eff.governance, opts, logger);
     const limits = stageLimits(config, { version: typeof eff.version === "number" ? eff.version : 0, ...("limits" in eff ? { limits: eff.limits } : {}) }, logger);
     const hot = stageRuntimeHot(config, eff.governance, logger);
-    const projDomain = eff.projects;
-    const rawProjects = (projDomain && typeof projDomain === "object" && !Array.isArray(projDomain) &&
-        "projects" in projDomain && typeof projDomain.projects === "object"
-        ? (projDomain.projects ?? {})
-        : {}) ?? {};
-    const projects = {};
-    for (const [pid, reg] of Object.entries(rawProjects)) {
-        if (!reg || typeof reg !== "object" || Array.isArray(reg))
-            continue;
-        const r = reg;
-        projects[pid] = {
-            ...(typeof r.displayName === "string" ? { displayName: r.displayName } : {}),
-            ...(Array.isArray(r.gitRemotes) ? { gitRemotes: r.gitRemotes.filter((x) => typeof x === "string") } : {}),
-            ...(Array.isArray(r.defaultScopes) ? { defaultScopes: r.defaultScopes.filter((x) => typeof x === "string") } : {}),
-        };
-    }
+    const projectWarnings = [];
+    const projects = eff.projects === undefined ? {} : { ...parseDomainSalvaged("projects", eff.projects, (w) => projectWarnings.push(w)).projects };
+    for (const w of projectWarnings)
+        logger?.warn("web_admin_projects_read_warning", { kind: w.kind, ...(w.kind === "entry-dropped" ? { entry: formatConfigPath(w.path), ...(w.reasonCode !== undefined ? { reasonCode: w.reasonCode } : {}) } : {}) });
     const sandboxGit = stageSandboxGit(eff, logger);
     return {
         version: typeof eff.version === "number" && Number.isFinite(eff.version) ? eff.version : 0,
@@ -635,7 +622,7 @@ function stageApprovalRequire(raw) {
         return { ok: false, detail, reason: detail, names: nonString.map((e) => `[${e.i}]`), kept: KEPT_WOULD_REMOVE_GATE };
     }
     const names = raw.filter((n) => typeof n === "string").map((n) => n.trim()).filter((n) => n.length > 0);
-    const unmatchable = unmatchableToolNamesRefusal("published governance.approvalRequire", names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR });
+    const unmatchable = unmatchableToolNamesRefusal("published governance.approvalRequire", names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR, noticeSeat: "server" });
     if (unmatchable !== undefined) {
         return {
             ok: false,
@@ -645,7 +632,7 @@ function stageApprovalRequire(raw) {
             kept: KEPT_WOULD_MATCH_NOTHING,
         };
     }
-    return { ok: true, value: names };
+    return { ok: true, value: names, skipped: retiredWithoutSuccessorEntries(names, NAME_TABLE_BEHAVIOR) };
 }
 function unserviceableOnLeg(leg, candidate) {
     switch (leg.leg) {
@@ -672,6 +659,7 @@ function stageApprovalGate(config, gov, leg, logger) {
     };
     const raw = gov?.approvalRequire;
     let next;
+    let skipped = [];
     if (raw === undefined) {
         next = [...approvalEnvBaseline.get(config)];
     }
@@ -680,10 +668,18 @@ function stageApprovalGate(config, gov, leg, logger) {
         if (!verdict.ok)
             return refuse(verdict);
         next = verdict.value;
+        skipped = verdict.skipped;
     }
     const unserviceable = unserviceableOnLeg(leg, { ...config, approvalRequire: next });
     if (unserviceable !== undefined)
         return refuse({ detail: unserviceable, reason: unserviceable, names: next, kept: KEPT_WOULD_NEVER_PARK });
+    if (skipped.length > 0) {
+        logger?.warn("web_admin_approval_require_legacy_tool_name", {
+            names: skipped.map((s) => s.entry),
+            guidance: skipped.map((s) => s.guidance),
+            note: "published governance.approvalRequire names tools the engine retired with no successor — they reach no tool this server knows, so those entries guard nothing (kept as written: a tool of that exact name mounted by an embedder is still matched); the list is applied; remove them from the published list if written for the retired tool",
+        });
+    }
     const same = next.length === config.approvalRequire.length && next.every((n, i) => n === config.approvalRequire[i]);
     return same ? {} : { next };
 }

package/dist/web-admin-client/candidate-gate.d.ts

@@ -39,9 +39,21 @@ export interface CandidateDomainError {
 /** 判官拒一份候选的成因(闭集):某个域判形失败(含 prompts 面)`domain_invalid` ∪ 被拒文档自带的词(契约闭集 `CONFIG_DOCUMENT_REFUSAL_REASONS`:
  *  `empty` / `invalid_json` / `not_object` / `io` / `too_deep` 文件层,`retired_domain` 墓碑)—— 被拒文档的词表只在契约一处定义,这里派生(契约加词 ⇒ 按词穷举的读者编译红)。 */
 export type CandidateRejectReason = "domain_invalid" | ConfigDocumentRefusalReason;
-/** 拒判里的一条:哪一域、为什么(读腿 / 契约包的原句)、成因词。`config_candidate_rejected` 行的 `errors` 就是这一列。 */
+/**
+ * 拒因的**类词**(闭集,机读,不含任何自由文本):这一条拒是哪一类事 —— 拒启句(`defaultModelRefusal` 的回落原因)只许据它说「为什么」,**不许**抄 `error` 原文(见 {@link CandidateDomainRejection.kind})。
+ * 成因词 {@link CandidateRejectReason} 已是闭集,但 `io` 一个词盖了三件事(悬空符号链接 / 权限 / I/O 故障),类词把悬空链接拆出来:
+ * `schema_invalid`(域判形失败 / 引用悬空 / prompts 坏形)· `empty` · `parse_error`(JSON 解析不过)· `not_object` · `too_deep` · `retired_domain`(退役域墓碑)· `dangling_symlink` · `unreadable`(在场却读不出的其余形)。
+ */
+export declare const CANDIDATE_REJECTION_KINDS: readonly ["schema_invalid", "empty", "parse_error", "not_object", "too_deep", "retired_domain", "dangling_symlink", "unreadable"];
+export type CandidateRejectionKind = (typeof CANDIDATE_REJECTION_KINDS)[number];
+/**
+ * 拒判里的一条:哪一域、为什么(读腿 / 契约包的原句)、成因词、类词。`config_candidate_rejected` 行的 `errors` 就是这一列。
+ * `error` 是读腿 / 契约的原句(可能点名链接指向的目标路径等操作数),**只走 warn 行**;`kind` 是机读的类词(只在 {@link judgeConfigCandidate} 铸一次),
+ * 拒启句读 `kind` 不读 `error`。
+ */
 export interface CandidateDomainRejection extends CandidateDomainError {
     readonly reason: CandidateRejectReason;
+    readonly kind: CandidateRejectionKind;
 }
 /** 判官的输入:一份读出来的候选。`refusedDocuments` = 读腿交出的被拒文档(两条读腿同形,契约的类型 `ConfigDocumentRefusal`;判官只读文档名、拒句与成因词)。 */
 export interface ConfigCandidateRead {
@@ -82,19 +94,39 @@ export declare function buildCandidateRejectedFields(r: {
  * 最近一次被判官整拒的候选的**结论**(纯数据)—— 判官判决的持有形:`domains` 就是 {@link judgeConfigCandidate} 交出的 `rejected.domains`(排序去重的域名集),
  * 一个字没改写;`source` = 这份候选是哪种配置源读出来的(`"local"` 本地 `config.d` / `"remote"` 中心);`at` = 判官判下这份候选的时刻(毫秒)。
  * 持有者(`boot/web-admin.ts` 的 `candidateRejection`)是它的**唯一**座:`config_candidate_rejected` 日志行的去重键与 `GET /v1/models.candidateRejected`
- * 的投影({@link buildCandidateRejectedWire})读的是同一份 —— 拒因文案(`errors`)与文件路径(`dir`)只走日志,不进这份结论,也就不上 wire。
+ * 的投影({@link buildCandidateRejectedWire})读的是同一份。`errors` 是判官交出的 `rejected.errors` 那一列的**同一个数组**(`config_candidate_rejected` 行体的 `errors` 也是它,
+ * {@link buildCandidateRejectedFields}):进程内的读者 —— 起服期「回落 env 之后没有缺省模型」的拒启句(`defaultModelRefusal` 的回落原因)—— 读它点名被拒的文档与拒码,
+ * 不读日志、不自铸第二份。拒因文案(`errors`)与文件路径(`dir`)只走日志与这条进程内的读,**不上 wire**:wire 投影 {@link buildCandidateRejectedWire} 只挑 `domains` / `at` / `source` 三键。
  */
 export interface CandidateRejection {
     readonly version: number;
     readonly domains: readonly string[];
     readonly source: "local" | "remote";
     readonly at: number;
+    readonly errors: readonly CandidateDomainRejection[];
+    /** 本地读腿的配置根(`config_candidate_rejected` 行的 `dir` 同一个值;远程读腿缺席)—— 拒启句据它 + 域名点得出被拒文档的路径。 */
+    readonly dir?: string;
 }
 export declare function candidateRejectionOf(r: {
     readonly effective: EffectiveConfig;
 }, verdict: Extract<ConfigCandidateVerdict, {
     verdict: "rejected";
-}>, source: CandidateRejection["source"], at: number): CandidateRejection;
+}>, source: CandidateRejection["source"], at: number, dir?: string): CandidateRejection;
+/**
+ * 拒启句里「回落原因」的一格(纯数据):被拒的文档名 · 成因词(拒码)· 原因类词 · 被拒文档的路径(本地读腿才有)。
+ * **不含** `error` 原文:契约句 / 读腿句里的链接目标路径等操作数只留在 `config_candidate_rejected` 行(那里已过产出边界脱敏)。
+ */
+export interface CandidateRejectionNote {
+    readonly document: string;
+    readonly code: CandidateRejectReason;
+    readonly cause: string;
+    readonly path?: string;
+}
+/**
+ * {@link CandidateRejection} 的拒因列 → 拒启句的「回落原因」格(`defaultModelRefusal` 的视图成员读它)。来源就是判官交出的那一列 `errors`(与 `config_candidate_rejected` 行同一份),
+ * 路径 = `<dir>/config.d/<域>.json`(拒行「据 dir + 域点得出文件」的同一读法,`localConfigDirOf` 是本仓 `config.d` 路径的唯一写法)。
+ */
+export declare function buildCandidateRejectionNotes(rejection: Pick<CandidateRejection, "errors" | "dir">): CandidateRejectionNote[];
 /** `GET /v1/models` 顶层 `candidateRejected` 的 wire 形(契约 §A.1d「`GET /v1/models` 的 `candidateRejected`」):域名闭集词 + ISO 时刻 + 源形态,零自由文本。 */
 export interface CandidateRejectedWire {
     readonly domains: string[];