@sema-agent/server 7.136.0 → 7.138.0

package/dist/mcp-assertion-header.d.ts

@@ -1,12 +1,19 @@
 /**
- * http 传输的 `assertionHeader` —— 托管连接器「断言头」的**头名**(settings-schema ≥12.2.0 的 `McpTransport` http 形键)。
+ * 请求面一条 MCP 条目的形与它交给引擎之前的拆法({@link toMcpDraft}),以及 http 传输的 `assertionHeader` —— 托管连接器「断言头」的**头名**(settings-schema ≥12.2.0 的 `McpTransport` http 形键)。
  *
- * ## 一条律:一个键一种读法
+ * ## 请求面条目 → 草稿(一张按传输分臂的处置表)
+ * 请求面条目的形 = 契约包的请求传输形({@link RequestMcpServerSpec}:stdio 带 `env`、http 带 `headers` / `principalHeader` / `assertionHeader`),wire 上的形由它说。
+ * 交给引擎的声明不带件值:引擎的声明收据对带 `headers` / `env` 的声明整条拒,件由部署的对端座在发送时作答。所以每条条目按它那一臂的处置表
+ * ({@link MCP_STDIO_TRANSPORT_DISPOSITION} / {@link MCP_HTTP_TRANSPORT_DISPOSITION})拆成草稿:`env` / `headers` 进草稿的件,`assertionHeader` 承载不发送,其余进声明。
+ * 拆法只有 `plain-string-record.ts` 的 `splitDeclaration` 一只、键的去处只有表一处说;两张表各带三道编译格(请求臂加 / 减键、引擎臂加键、引擎臂删键都编译红)。
+ * 草稿只有胜出者(部署同名者赢,`task-mcp.ts` 的 `mergeRequestMcp`)才经对端座的唯一铸点(`peer-seat.ts` 的 `mintDeclaration`)登记,登记换来的引用放进声明的传输臂。
+ *
+ * ## `assertionHeader`:一条律,一个键一种读法
  * 两个面收下这个键,读法是同一个:
  *  · **settings 面**(部署声明:中心下发 + 本地 `config.d`)—— 契约包在**解析期**受理它,并判它与 `principalHeader` 互斥
  *    (同设 = 两个答案:「这台 http 服务器的请求上用哪个头送身份」);本仓这一面只承载,铸 spec 在 `resolveMcpServers`;
  *  · **请求面**(任务提交体 `mcpServers[].transport`;探测口 `…/mcp/probe` 读同一张键表)—— 本仓在**受理期**兑现同一条规则:
- *    受理 = 字符串才收;互斥 = 同设即拒;投影 = 铸 spec 时不投(见下)。
+ *    受理 = 字符串才收;互斥 = 同设即拒;去处 = 处置表的 `withheld`(声明与件两边都不进)。
  * 同一条规则、两处执行者(契约包解析期 / 请求面受理期);判据 {@link mcpIdentityHeadersIssue} 与互斥拒句
  * {@link describeMcpIdentityHeadersConflict} 对契约包的原判官**逐字**对齐 —— 不是靠这句注释,而是
  * `test/task-mcp.test.ts` 的 [ref] 组把两边对拍(格子差分 + 拒句逐字相等),契约包改一个字那一组当场红。
@@ -18,38 +25,52 @@
  *    所以读器(契约包的 `readMcpIdentityHeaders`,`normalizeServer` 的 http 传输读两个身份头用它)的处置是**降级到升级前的读法**:`principalHeader` 胜(照挂,与升级前逐字相同),`assertionHeader` 不生效;
  *    不静默 —— 真挂上的这类条目由 {@link noteMcpAssertionHeaderIgnored} 说一行 warn(部署声明面没有这一格:配置不是被重放的存量任务,契约包解析期那一刀直接丢这一条)。
  *
- * ## 发送归引擎座(本版只承载,不发送)—— 「发不发」只有一只开关
-core 的 http 传输只有 `url` / `headers` / `principalHeader`,**没有**断言头座。所以本键承载到「铸 core 规格」为止:
-请求面在 {@link toCoreMcpServerSpec} 剥掉它,settings 面的 `resolveMcpServers` 不投它;两处都用同一只
-{@link noteMcpAssertionHeaderNotSent} 说出一行 info(声明在、发送未接)—— 披露,不是兜底:server 照常挂载、不带断言头,
-要求断言的托管连接器会拒这些调用,运维据这一行知道原因在哪。
-「这台 server 发不发」是**一个事实**,只有一只开关 {@link MCP_ASSERTION_HEADER_SENT} 说它;读它的地方共五处,全经 {@link withholdsMcpAssertionHeader} 这一只谓词
-(能力位 `GET /v1/capabilities` 的 `mcpAssertionHeaderSent` 直读开关本人):请求面剥键、settings 面不投、一行 info、探测口整条拒、能力位。所以「位为真」与「还在说发送未接」
-结构上不可能同时成立,消费方按位分支、位真时不再看到任何披露句;发送座到货的那天翻的就是这一行(与下面的退役门同批)。
-
-## 退役(编译期自动逼,零人工记忆)
- * 引擎的 http 传输一旦长出同名座,{@link _CoreHasNoAssertionSeat} 当场编译红:届时删本文件里的 {@link RequestMcpServerSpec}
- * 扩展与 {@link toCoreMcpServerSpec} 的剥键、两处 info,把键直接投进引擎规格(发送由引擎座兑现)。
+ * ## 断言不发送 —— 「发不发」只有一处说
+ * 引擎的断言头是**固定的名**(引擎包根的 `MCP_ASSERTION_HEADER`),值由部署的对端座对 `assertion` 种类的引用作答;本部署没有断言来源,对端座对这一种恒拒
+ * (`peer-seat.ts` 的拒因 `kind_assertion`)。所以请求面写的这个头名**承载、不发送**:处置表那一格是 `withheld`,开关 {@link MCP_ASSERTION_HEADER_SENT} 从表那一格读出(恒假),
+ * 读它的地方全经 {@link withholdsMcpAssertionHeader} 这一只谓词(能力位 `GET /v1/capabilities` 的 `mcpAssertionHeaderSent` 直读开关本人):一行 info(请求面与 settings 面)、探测口整条拒、能力位;
+ * 两面铸声明时都不投这个键(请求面经处置表,settings 面不写它)。
+ * 声明在、发送未接 = 运维要知道的事实,不是兜底 —— server 照常挂载、不带断言头,要求断言的托管连接器会拒这些调用,运维据 {@link noteMcpAssertionHeaderNotSent} 那一行知道原因在哪。
+ * 退役门押在座上({@link _SeatRefusesAssertion}):对端座哪天开始对 `assertion` 作答,那一格当场编译红,届时重判这一格的去处(键本身随契约包删键一起退役)。
  */
 import type { McpServerSpec } from "@sema-agent/core";
-type CoreMcpTransport = McpServerSpec["transport"];
-type CoreStdioTransport = Extract<CoreMcpTransport, {
+import type { RequestMcpTransport } from "@sema-agent/settings-schema";
+import type { McpDraft } from "./peer-seat.js";
+/** 请求面 stdio 传输的形(契约包):引擎的 stdio 传输去掉凭据引用位、加上 `env`(件)。 */
+export type RequestStdioMcpTransport = Extract<RequestMcpTransport, {
     kind: "stdio";
 }>;
-type CoreHttpTransport = Extract<CoreMcpTransport, {
+/** 请求面 http 传输的形(契约包):引擎的 http 传输去掉凭据引用位、加上 `headers`(件)与承载不发送的 `assertionHeader`。 */
+export type RequestHttpMcpTransport = Extract<RequestMcpTransport, {
     kind: "http";
 }>;
-/** 请求面 http 传输的形:引擎的 http 传输 + 本仓承载的 `assertionHeader`(引擎无座,见头注)。 */
-export type RequestHttpMcpTransport = CoreHttpTransport & {
-    assertionHeader?: string;
-};
 /**
  * 请求面一条 `mcpServers[]` 条目在 wire 上的形(= `TaskRequestBody.mcpServers` 的元素型,也是 `normalizeServer` 的产物):
- * 引擎的 {@link McpServerSpec} 加上 http 传输上的 `assertionHeader`。交给引擎之前一律经 {@link toCoreMcpServerSpec}。
+ * 引擎的 {@link McpServerSpec} 条目层 + 契约包的请求传输形。交给引擎之前一律经 {@link toMcpDraft} 拆成草稿。
  */
 export type RequestMcpServerSpec = Omit<McpServerSpec, "transport"> & {
-    transport: CoreStdioTransport | RequestHttpMcpTransport;
+    transport: RequestMcpTransport;
+};
+/** stdio 臂的处置表(键序 = 键闭集序):`env` 是件,其余进声明。 */
+export declare const MCP_STDIO_TRANSPORT_DISPOSITION: {
+    readonly args: "engine";
+    readonly command: "engine";
+    readonly env: "seat";
+    readonly kind: "engine";
 };
+/** http 臂的处置表(键序 = 键闭集序):`headers` 是件,`assertionHeader` 承载不发送(见头注),其余进声明。 */
+export declare const MCP_HTTP_TRANSPORT_DISPOSITION: {
+    readonly assertionHeader: "withheld";
+    readonly headers: "seat";
+    readonly kind: "engine";
+    readonly principalHeader: "engine";
+    readonly url: "engine";
+};
+/**
+ * 请求面条目 → 草稿:传输按它那一臂的处置表拆(`env` / `headers` 进件,`assertionHeader` 两边都不进,其余进声明);条目层的键原样进声明。件缺席或空 ⇒ 草稿不带件(登记时什么都不留)。
+ * 纯函数:不登记、不读部署状态;被扣下的 `assertionHeader` 由调用方另说一行 info。
+ */
+export declare function toMcpDraft(spec: RequestMcpServerSpec): McpDraft;
 /** 一份原始 http 传输上两个身份头的问题类:`both_set` = 同设了 `principalHeader` 与 `assertionHeader`;`not_a_string` = `assertionHeader` 在场但不是字符串。 */
 export type McpIdentityHeadersIssue = "both_set" | "not_a_string";
 /**
@@ -64,27 +85,18 @@ export declare function describeMcpIdentityHeadersConflict(server: string): stri
 /** `assertionHeader` 值不是字符串的**原因句**(不带条目名与键路径:点名由请求面统一的拒形 `entryFieldRefusal` 负责;值的形状只说种类,不回显值本身:它是一个调用方写的头名位置,可能是任何东西)。 */
 export declare function describeMcpAssertionHeaderNotAString(value: unknown): string;
 /**
- * 引擎的 http 传输有没有断言头发送座 —— **全仓唯一的开关**。今天没有(core 的 http 传输无同名座,见头注与退役门)⇒ `false`:声明在、发送未接。
- * 翻真 = 这一行 + 删退役门 + 把 {@link RequestHttpMcpTransport} 并进引擎型;剥键、披露、探测口拒、settings 面投影、能力位 `mcpAssertionHeaderSent` 随它一起翻
- * (五处都读 {@link withholdsMcpAssertionHeader} / 本常量,没有第六处)。声明成 `boolean` 而不是字面 `false`:谓词里的真臂是活代码(单测传 `sent=true` 钉它),不是被收窄掉的死分支。
+ * 本部署发不发请求面声明的断言头 —— **全仓唯一的开关**,从 http 臂处置表的那一格读出(`withheld` ⇒ 假;依据见头注「断言不发送」与退役门)。
+ * 读它的地方全经 {@link withholdsMcpAssertionHeader} / 本常量(一行 info、探测口拒、能力位 `mcpAssertionHeaderSent`),所以表那一格与开关不可能脱钩。
+ * 声明成 `boolean` 而不是字面 `false`:谓词里的真臂是活代码(单测传 `sent=true` 钉它),不是被收窄掉的死分支。
  */
 export declare const MCP_ASSERTION_HEADER_SENT: boolean;
 /**
- * 这一份 `assertionHeader` 声明是不是「被扣下」的那一类(需要剥键、需要说一行 info、探测口要拒的那一类)—— 即**声明了,而发送座不在**。
- * 三处消费(剥键 / 披露 / 探测口拒)与 settings 面的投影共读这一只;`sent` 缺省读开关,单测传显式值钉另一臂。
+ * 这一份 `assertionHeader` 声明是不是「被扣下」的那一类(需要说一行 info、探测口要拒的那一类)—— 即**声明了,而本部署不发送**。
+ * 披露(请求面与 settings 面)/ 探测口拒共读这一只;`sent` 缺省读开关,单测传显式值钉另一臂。
  */
 export declare function withholdsMcpAssertionHeader(assertionHeader: unknown, sent?: boolean): boolean;
 /** {@link withholdsMcpAssertionHeader} 在请求面条目上的读法:只有 http 传输有这个键(stdio 形上它不存在)。 */
 export declare function specWithholdsMcpAssertionHeader(spec: RequestMcpServerSpec): boolean;
-/**
- * settings 面铸 spec 时「这个键投不投进引擎规格」:发送座在(`sent` 真)且声明了字符串 ⇒ 投,否则整键缺席。今天恒为空对象(开关假);
- * 开关翻真的那天 settings 面因此自动跟着投,不会出现「位说发了、部署声明面却没投」。
- */
-export declare function sentMcpAssertionHeaderMember(assertionHeader: unknown, sent?: boolean): {
-    assertionHeader?: string;
-};
-/** 请求面条目 → 交给引擎的规格:被扣下的 `assertionHeader` 剥掉(引擎无座);其余逐字不动。被扣下的条目由调用方另说一行 info。 */
-export declare function toCoreMcpServerSpec(spec: RequestMcpServerSpec): McpServerSpec;
 /** `noteMcpAssertionHeaderNotSent` 的日志行名(运维 grep 用;请求面与 settings 面同一个名字)。 */
 export declare const MCP_ASSERTION_HEADER_NOT_SENT = "mcp_assertion_header_not_sent";
 /** `noteMcpAssertionHeaderIgnored` 的日志行名。 */
@@ -93,10 +105,9 @@ export declare const MCP_ASSERTION_HEADER_IGNORED = "mcp_assertion_header_ignore
 export declare function noteMcpAssertionHeaderIgnored(logger: {
     warn?(msg: string, meta?: unknown): void;
 } | undefined, server: string, reason: McpIdentityHeadersIssue): void;
-/** 说出「这台 server 声明了 `assertionHeader`,本版没有发送」—— 一台一行 info。两个铸 spec 点(请求面 `classifyHonored`、
+/** 说出「这台 server 声明了 `assertionHeader`,本部署不发送」—— 一台一行 info。两个铸 spec 点(请求面 `classifyHonored`、
  *  settings 面 `resolveMcpServers`)共用这一只,所以行名与措辞只有一份。 */
 export declare function noteMcpAssertionHeaderNotSent(logger: {
     info?(msg: string, meta?: unknown): void;
 } | undefined, server: string): void;
-export {};
 //# sourceMappingURL=mcp-assertion-header.d.ts.map

package/dist/mcp-assertion-header.js

@@ -1,3 +1,11 @@
+import { splitDeclaration } from "./plain-string-record.js";
+export const MCP_STDIO_TRANSPORT_DISPOSITION = { args: "engine", command: "engine", env: "seat", kind: "engine" };
+export const MCP_HTTP_TRANSPORT_DISPOSITION = { assertionHeader: "withheld", headers: "seat", kind: "engine", principalHeader: "engine", url: "engine" };
+export function toMcpDraft(spec) {
+    const { transport, ...entry } = spec;
+    const split = transport.kind === "http" ? splitDeclaration(transport, MCP_HTTP_TRANSPORT_DISPOSITION) : splitDeclaration(transport, MCP_STDIO_TRANSPORT_DISPOSITION);
+    return { spec: { ...entry, transport: split.engine }, ...(split.pieces === undefined ? {} : { pieces: split.pieces }) };
+}
 export function mcpIdentityHeadersIssue(transport) {
     if (transport.kind !== "http")
         return undefined;
@@ -14,22 +22,13 @@ export function describeMcpAssertionHeaderNotAString(value) {
     const kind = value === null ? "null" : Array.isArray(value) ? "an array" : `a ${typeof value}`;
     return `must be a string (the HTTP header NAME the connector assertion travels in) — got ${kind}; omit the key to send no assertion header`;
 }
-export const MCP_ASSERTION_HEADER_SENT = false;
+export const MCP_ASSERTION_HEADER_SENT = MCP_HTTP_TRANSPORT_DISPOSITION.assertionHeader !== "withheld";
 export function withholdsMcpAssertionHeader(assertionHeader, sent = MCP_ASSERTION_HEADER_SENT) {
     return !sent && assertionHeader !== undefined;
 }
 export function specWithholdsMcpAssertionHeader(spec) {
     return spec.transport.kind === "http" && withholdsMcpAssertionHeader(spec.transport.assertionHeader);
 }
-export function sentMcpAssertionHeaderMember(assertionHeader, sent = MCP_ASSERTION_HEADER_SENT) {
-    return sent && typeof assertionHeader === "string" ? { assertionHeader } : {};
-}
-export function toCoreMcpServerSpec(spec) {
-    if (spec.transport.kind !== "http" || !withholdsMcpAssertionHeader(spec.transport.assertionHeader))
-        return spec;
-    const { assertionHeader: _declaredNotSent, ...transport } = spec.transport;
-    return { ...spec, transport };
-}
 export const MCP_ASSERTION_HEADER_NOT_SENT = "mcp_assertion_header_not_sent";
 export const MCP_ASSERTION_HEADER_IGNORED = "mcp_assertion_header_ignored";
 export function noteMcpAssertionHeaderIgnored(logger, server, reason) {
@@ -44,7 +43,7 @@ export function noteMcpAssertionHeaderIgnored(logger, server, reason) {
 export function noteMcpAssertionHeaderNotSent(logger, server) {
     logger?.info?.(MCP_ASSERTION_HEADER_NOT_SENT, {
         server,
-        note: "declaration KEPT but NOT SENT — the engine's http transport has no seat for an assertion header yet, so this server mounts WITHOUT one (a hosted connector that requires the assertion will refuse its calls); sending follows the engine seat",
+        note: "declaration KEPT but NOT SENT — the engine sends a connector assertion only under its own fixed header name, answered by the deployment's peer seat, and this deployment has no assertion source; this server mounts WITHOUT one (a hosted connector that requires the assertion will refuse its calls)",
     });
 }
 //# sourceMappingURL=mcp-assertion-header.js.map

package/dist/mcp-authorization-face.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MCP 授权事实(core 7.59.0 `McpAuthorization`:`{ reason, authorizeUrl?, resourceMetadataUrl? }`,与 `errorCode: "unauthorized"` 同行)的**出门投影** ——
+ * 本仓三张面(`wiring_manifest.mcp[]` 行、重拨回执的 `status`、`//mcp` 面板的 `servers[]`)同读这一只。
+ *
+ * 只投闭集词 `reason`(`rejected` = 端点答 401 且授权座的重问没给出能过的凭据 / `scope` = 403 `insufficient_scope` / `none` = 授权座答「未授权」):
+ * 判据直读引擎的 `MCP_AUTHORIZATION_REASONS`(不抄词表);词出闭集、非串、整只不是对象 ⇒ 整格缺席(最弱断言,不铸词)。
+ * 两只地址**不出门**:`authorizeUrl` 只来自部署的授权座,本部署今天没有授权座;`resourceMetadataUrl` 是远端在挑战头里自报的地址,不可信 —— 两只地址的去向
+ * (授权座 + 出口座)是授权记录面的设计,不在本投影里放行。用户面的「去授权」由会话通告 `mcp.authorization_required` 承载。
+ */
+import { type McpAuthorizationReason } from "@sema-agent/core";
+/** 授权记录的处置表(三面同读;`core-keyset-guard.ts` 读表 —— 门与投影一个写者):`reason` 认得才出门(闭集词;在场而认不得 ⇒ 丢并计一次),两只地址本面不出现。 */
+export declare const MCP_AUTHORIZATION_DISPOSITIONS: {
+    readonly reason: {
+        readonly forward: (w: unknown) => w is McpAuthorizationReason;
+    };
+    readonly authorizeUrl: "strip";
+    readonly resourceMetadataUrl: "strip";
+};
+/** 处置表一格的放行谓词所窄化到的型(`forward: (w: unknown) => w is T` ⇒ `T`):表放行什么,出门值就是什么型。 */
+type ForwardedAs<F> = F extends (w: unknown) => w is infer T ? T : never;
+/** 本投影的产物 = 表里 `reason` 一格放行后的型。词的型只有表这一个写者,出口不再判第二遍。 */
+export type McpAuthorizationFace = {
+    readonly reason: ForwardedAs<(typeof MCP_AUTHORIZATION_DISPOSITIONS)["reason"]["forward"]>;
+};
+export declare function projectMcpAuthorization(v: unknown): McpAuthorizationFace | undefined;
+export {};
+//# sourceMappingURL=mcp-authorization-face.d.ts.map

package/dist/mcp-authorization-face.js

@@ -0,0 +1,15 @@
+import { MCP_AUTHORIZATION_REASONS } from "@sema-agent/core";
+import { projectByTable } from "./trace/projection-table.js";
+const isAuthorizationReason = (w) => typeof w === "string" && MCP_AUTHORIZATION_REASONS.includes(w);
+export const MCP_AUTHORIZATION_DISPOSITIONS = {
+    reason: { forward: isAuthorizationReason },
+    authorizeUrl: "strip",
+    resourceMetadataUrl: "strip",
+};
+export function projectMcpAuthorization(v) {
+    if (typeof v !== "object" || v === null || Array.isArray(v))
+        return undefined;
+    const { reason } = projectByTable("mcp.authorization", MCP_AUTHORIZATION_DISPOSITIONS, v, undefined);
+    return reason !== undefined ? { reason } : undefined;
+}
+//# sourceMappingURL=mcp-authorization-face.js.map

package/dist/memory-operator-faces.d.ts

@@ -63,11 +63,20 @@ export interface MemoryComplianceFaces {
      * 抹除。入参 `unknown`:调用方递交的是未校验的对象,三选一选择子的整体判决归 core
      * (`erasureRequestInvalid` 是它的单一属主面)—— 在本层抄一遍就是第二真源。
      *
-     * `opts.allowedScopes` = **授权信封座**(见 {@link erasureEnvelopeRefusal} 的头注)。
+     * ## 授权座只有一只:引擎的 `EraseMemoryEntriesInput.expectedScopes`
+     *
+     * 「这个调用方能删哪些 scope」由引擎判:在场 ⇒ 选择子自己的 scope(地点选择子,读店之前判)与**每个解析出的 id 的绑定 scope**
+     * 都得是集内成员,判在解析之后、店锁之内;违者整单拒 `config.memory_erasure_scope`,拒句不带数、不带 id、不带 scope(集外 id
+     * 与从没存在过的 id 同句,不是存在性神谕)。本层不另设信封:一只只读得到 `{ scope }` 选择子字面量的信封判不了 `ids` /
+     * `sessionId` 两腿、只能整拒,而且让「哪些 scope 能删」有两个答者。集随**入参**走(与 `requestId` / `select` 同一个对象),
+     * 本面没有第二个形参。
+     *
+     * 今天谁传集:operator 面原样递交调用方的体(调用方自己写的 `expectedScopes` = 它自己收窄自己);路由不替 operator 铸集 ——
+     * 本仓没有任何授权源能对一个 operator 说「你只能动这些 scope」(`routes/memory-policy.ts` 的 `gateMemoryScope`:operator 支在查
+     * 目录之前就 allow;`org-memory-admission.ts`:v1 不中央收窄 operator 声明的 scope)。拿 org 目录的 grant 集去凑一个集就是在本层
+     * 发明第二套授权语义,与 `gateMemoryScope` 对同一个身份给出相反答案。会话自助面的选择子由路径铸,不带集。
      */
-    erase: (input: unknown, opts?: {
-        allowedScopes?: readonly string[];
-    }) => Promise<MemoryErasureAttestation>;
+    erase: (input: unknown) => Promise<MemoryErasureAttestation>;
 }
 /**
  * **选择子替身**的拦截谓词(codex 交叉复审 [critical],亲验复现后修 —— 复现器与结论逐条在

package/dist/memory-operator-faces.js

@@ -24,19 +24,6 @@ export function erasureInputSmugglesPrototypeKey(input) {
     }
     return false;
 }
-function erasureEnvelopeRefusal(input, allowedScopes) {
-    if (allowedScopes === undefined)
-        return undefined;
-    const select = typeof input === "object" && input !== null ? input.select : undefined;
-    const scope = typeof select === "object" && select !== null ? select.scope : undefined;
-    if (typeof scope === "string" && allowedScopes.includes(scope))
-        return undefined;
-    const e = new Error(typeof scope === "string"
-        ? `memory erasure refused: scope ${JSON.stringify(scope)} is outside this caller's erasure envelope`
-        : "memory erasure refused: this request's selector is not scope-addressable, and an envelope that cannot judge a selector must not admit it");
-    e.code = "memory.erasure_scope_forbidden";
-    return e;
-}
 export function createMemoryComplianceFaces(store, opts) {
     if (!backendOwnsControlPlane(store.backend))
         return undefined;
@@ -48,15 +35,12 @@ export function createMemoryComplianceFaces(store, opts) {
     });
     return {
         provenanceOf: (entryId) => engine.provenanceOf(entryId),
-        erase: (input, opts) => {
+        erase: (input) => {
             if (erasureInputSmugglesPrototypeKey(input)) {
                 const e = new Error("memory erasure refused: the request carries a key that rewrites an object's prototype — such a key is not a selector, and core's selector dispatch would read it in preference to the declared one");
                 e.code = "memory.erasure_selector_unsafe";
                 return Promise.reject(e);
             }
-            const refusal = erasureEnvelopeRefusal(input, opts?.allowedScopes);
-            if (refusal !== undefined)
-                return Promise.reject(refusal);
             return engine.eraseMemoryEntries(input);
         },
     };

package/dist/memory-store-refusal.d.ts

@@ -23,11 +23,11 @@
  *     那几行的前缀是**条目路径**(模型可写)—— 本仓今天不读 warnings 车道(既有面,不是本批回归),也不在模型可写的文本上
  *     找码;这一半候 core 的结构化码位(登记在案,codex 一审 C3)。
  *
- * ## 不是这一族的三形(core 同表「different surface」,本仓**不**自拼码,如实走各自既有臂)
+ * ## 不是这一族的形(core 同表「different surface」,本仓**不**自拼码,如实走各自既有臂;今两形 + 一只已退的形)
  *  · journal 重放目标目录成链 ⇒ `ControlPlaneCorruptError`(无 `.code`,KL-1094-b)⇒ 路由 typed 500 `internal.memory_control_plane_corrupt`
  *    (core 7.44.0 起 scope home 非目录**不再**走这一类 —— 它有了自己的码,见上;`ControlPlaneCorruptError` 只剩真控制面损坏);
- *  · 引擎原地写撞硬链(nlink>1)⇒ 文本 `has N names (a hard link)`、无码(KL-1094-g / [ref])⇒ 走该写点既有的失败车道(harvest
- *    warnings / 挂载失败),抛出面够不着;
+ *  · (已不存在的一形)引擎原地写撞硬链(nlink>1):≤ 引擎 7.55.x 是无码文本 `has N names (a hard link) … not written`、走该写点既有的失败车道;
+ *    引擎 7.56.0 起那只写给**这个名字**另建一个新文件(原子改名落位,其余名字保留原文件),拒绝与那句文本一并消失 —— 本仓从未读过那句文本,零码;
  *  · 解析故障(`EACCES` / `ELOOP` / `ENOTDIR`)⇒ 以 errno 本身抛 ⇒ 路由未分类 500 + 运维 warn(`String(err)` 带 core 补救句)。
  *
  * ## 运维行也在这里铸(两受众同一只,{@link logStoreFormRefusal})

package/dist/memory-sync-client.js

@@ -4,6 +4,12 @@ import { dirname, join } from "node:path";
 import { encodeScopeSegment, syncMemoryScope, } from "@sema-agent/core";
 import { replicationCovers } from "./memory-scope.js";
 import { parseProjectLayerKey } from "./project-layer-key.js";
+const CURSOR_MISMATCH_CODE = "config.memory_sync_cursor_mismatch";
+const CURSOR_PREDATES_STORE_NOTICE = "memory_sync_cursor_predates_store";
+const CURSOR_PREDATES_STORE_OUTS = "this layer's sync baseline was written before sync cursors carried a store binding, so the layer does not sync until the operator picks one of two ways out: " +
+    "(1) run one sync round on the previous server version so deletions made since the last round reach the other side, then delete this file; " +
+    "(2) delete this file now to accept re-convergence from an empty baseline — entries changed on both sides are reported as conflicts, " +
+    "and entries deleted on one side since the last round come back from the other side";
 export const DEFAULT_MEMORY_SYNC_PEER = "central";
 export function createMemorySyncTransport(opts) {
     const base = opts.url.replace(/\/+$/, "");
@@ -25,32 +31,56 @@ export function createMemorySyncTransport(opts) {
 export function memorySyncCursorPath(memoryRoot, peer, scope) {
     return join(memoryRoot, "sync-cursors", encodeScopeSegment(peer), `${createHash("sha256").update(scope, "utf8").digest("hex").slice(0, 32)}.json`);
 }
-function legacyMemorySyncCursorPath(memoryRoot, peer) {
+function perPeerCursorPath(memoryRoot, peer) {
     return join(memoryRoot, `sync-cursor-${encodeScopeSegment(peer)}.json`);
 }
-async function loadCursor(path, scope, peer, log) {
+async function readCursorFile(path) {
     let raw;
     try {
         raw = await readFile(path, "utf8");
     }
     catch (err) {
-        if (err.code !== "ENOENT")
-            log.warn("memory_sync_cursor_read_failed", { path, err: String(err), note: "treating as first round" });
-        return undefined;
+        return err.code === "ENOENT" ? { kind: "absent" } : { kind: "unreadable", err: String(err) };
     }
-    let parsed;
     try {
-        parsed = JSON.parse(raw);
+        const value = JSON.parse(raw);
+        return { kind: "parsed", value };
     }
     catch (err) {
-        log.warn("memory_sync_cursor_corrupt", { path, err: String(err), note: "treating as first round" });
-        return undefined;
+        return { kind: "corrupt", err: String(err) };
+    }
+}
+function predatesStoreBinding(parsed, scope, peer) {
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return false;
+    const c = parsed;
+    return c["scope"] === scope && c["peer"] === peer && c["store"] === undefined;
+}
+async function loadLayerBaseline(path, perPeer, scope, peer, log) {
+    const read = await readCursorFile(path);
+    switch (read.kind) {
+        case "absent": {
+            if (perPeer === undefined)
+                return { kind: "none" };
+            const legacy = await readCursorFile(perPeer);
+            return legacy.kind === "parsed" && predatesStoreBinding(legacy.value, scope, peer) ? { kind: "predates-store", path: perPeer } : { kind: "none" };
+        }
+        case "unreadable":
+            log.warn("memory_sync_cursor_read_failed", { path, err: read.err, note: "treating as first round" });
+            return { kind: "none" };
+        case "corrupt":
+            log.warn("memory_sync_cursor_corrupt", { path, err: read.err, note: "treating as first round" });
+            return { kind: "none" };
+        case "parsed": {
+            if (predatesStoreBinding(read.value, scope, peer))
+                return { kind: "predates-store", path };
+            const cursor = cursorOf(read.value, scope, peer);
+            if (cursor !== undefined)
+                return { kind: "cursor", cursor };
+            log.warn("memory_sync_cursor_invalid", { path, scope, peer, note: "shape/identity mismatch — treating as first round" });
+            return { kind: "none" };
+        }
     }
-    const cursor = cursorOf(parsed, scope, peer);
-    if (cursor !== undefined)
-        return cursor;
-    log.warn("memory_sync_cursor_invalid", { path, scope, peer, note: "shape/identity mismatch — treating as first round" });
-    return undefined;
 }
 function cursorOf(parsed, scope, peer) {
     if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -58,43 +88,18 @@ function cursorOf(parsed, scope, peer) {
         const baseRevsRaw = c["baseRevs"];
         if (c["scope"] === scope &&
             c["peer"] === peer &&
+            typeof c["store"] === "string" &&
             typeof c["updatedAtMs"] === "number" &&
             Number.isFinite(c["updatedAtMs"]) &&
             baseRevsRaw !== null &&
             typeof baseRevsRaw === "object" &&
             !Array.isArray(baseRevsRaw) &&
             Object.values(baseRevsRaw).every((v) => typeof v === "string" && v.length > 0)) {
-            return { scope, peer, baseRevs: { ...baseRevsRaw }, updatedAtMs: c["updatedAtMs"] };
+            return { scope, peer, store: c["store"], baseRevs: { ...baseRevsRaw }, updatedAtMs: c["updatedAtMs"] };
         }
     }
     return undefined;
 }
-async function adoptLegacyCursor(memoryRoot, scope, peer, log) {
-    const target = memorySyncCursorPath(memoryRoot, peer, scope);
-    const legacy = legacyMemorySyncCursorPath(memoryRoot, peer);
-    const facts = await Promise.all([readFile(target, "utf8").then(() => "present", (err) => (err.code === "ENOENT" ? "absent" : "present")), readFile(legacy, "utf8").then((text) => ({ text }), (err) => ({ err }))]);
-    const [targetFact, legacyRead] = facts;
-    if (targetFact === "present")
-        return;
-    if ("err" in legacyRead) {
-        if (legacyRead.err.code !== "ENOENT")
-            log.warn("memory_sync_cursor_read_failed", { path: legacy, err: String(legacyRead.err), note: "legacy cursor not adopted — this layer starts from its own cursor" });
-        return;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(legacyRead.text);
-    }
-    catch (err) {
-        log.warn("memory_sync_cursor_corrupt", { path: legacy, err: String(err), note: "legacy cursor not adopted" });
-        return;
-    }
-    if (cursorOf(parsed, scope, peer) === undefined)
-        return;
-    await mkdir(dirname(target), { recursive: true });
-    await rename(legacy, target);
-    log.info("memory_sync_cursor_adopted", { from: legacy, to: target, scope, peer });
-}
 async function saveCursor(path, cursor) {
     await mkdir(dirname(path), { recursive: true });
     const tmp = `${path}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
@@ -110,7 +115,6 @@ export function createMemorySyncRunner(opts) {
     const peer = opts.peer ?? DEFAULT_MEMORY_SYNC_PEER;
     const coverage = { kind: "layers", layers: [opts.scope] };
     const tracked = new Set();
-    let legacyCursorChecked = false;
     let enumerationWarned = false;
     const isCoveredProjectLayer = (scope) => scope !== opts.scope && parseProjectLayerKey(scope) !== undefined && replicationCovers(coverage, scope);
     const layersOfRound = () => {
@@ -124,21 +128,36 @@ export function createMemorySyncRunner(opts) {
     };
     const syncLayer = async (scope, reason) => {
         const cursorPath = memorySyncCursorPath(opts.memoryRoot, peer, scope);
-        let cursor = await loadCursor(cursorPath, scope, peer, opts.log);
+        const baseline = await loadLayerBaseline(cursorPath, scope === opts.scope ? perPeerCursorPath(opts.memoryRoot, peer) : undefined, scope, peer, opts.log);
+        if (baseline.kind === "predates-store") {
+            opts.log.warn(CURSOR_PREDATES_STORE_NOTICE, { scope, peer, path: baseline.path, note: CURSOR_PREDATES_STORE_OUTS });
+            throw new Error(`memory sync: layer ${JSON.stringify(scope)} not synced — its baseline ${baseline.path} predates the store binding (see warn ${CURSOR_PREDATES_STORE_NOTICE})`);
+        }
+        let cursor = baseline.kind === "cursor" ? baseline.cursor : undefined;
         let result;
         let subRound = 0;
         for (;;) {
             subRound += 1;
-            result = await syncMemoryScope({
-                backend: opts.backend,
-                scope,
-                transport: opts.transport,
-                peer,
-                ...(cursor !== undefined ? { cursor } : {}),
-                ...(opts.now !== undefined ? { now: opts.now } : {}),
-                ...(opts.maxPushEntries !== undefined ? { maxPushEntries: opts.maxPushEntries } : {}),
-                ...(opts.maxPullEntries !== undefined ? { maxPullEntries: opts.maxPullEntries } : {}),
-            });
+            try {
+                result = await syncMemoryScope({
+                    backend: opts.backend,
+                    scope,
+                    transport: opts.transport,
+                    peer,
+                    ...(cursor !== undefined ? { cursor } : {}),
+                    ...(opts.now !== undefined ? { now: opts.now } : {}),
+                    ...(opts.maxPushEntries !== undefined ? { maxPushEntries: opts.maxPushEntries } : {}),
+                    ...(opts.maxPullEntries !== undefined ? { maxPullEntries: opts.maxPullEntries } : {}),
+                });
+            }
+            catch (err) {
+                if (cursor === undefined || err?.code !== CURSOR_MISMATCH_CODE)
+                    throw err;
+                opts.log.warn("memory_sync_cursor_rebound", { scope, peer, subRound, note: "the persisted cursor is bound to another store — running this round from no cursor and replacing it" });
+                cursor = undefined;
+                subRound -= 1;
+                continue;
+            }
             for (const w of result.warnings ?? [])
                 opts.log.warn("memory_sync_warning", { scope, peer, subRound, warning: w });
             if (!(result.pushTruncated === true || result.pullTruncated === true))
@@ -192,10 +211,6 @@ export function createMemorySyncRunner(opts) {
         return result;
     };
     const round = async (reason) => {
-        if (!legacyCursorChecked) {
-            legacyCursorChecked = true;
-            await adoptLegacyCursor(opts.memoryRoot, opts.scope, peer, opts.log);
-        }
         const layers = [];
         const failures = [];
         for (const scope of layersOfRound()) {

package/dist/memory-sync.d.ts

@@ -2,7 +2,7 @@ import { type MemoryBackend, type MemoryEntry, type PatchReport } from "@sema-ag
 import type { MemorySyncStore } from "./plugins/memory-sync-store-pg.js";
 /** 一轮同步请求(验型后的干净形状——`parseMemorySyncRequest` 是唯一铸造点)。 */
 export interface MemorySyncRequest {
-    /** 对端标识(MemorySyncCursor.peer,per-(scope,peer) 游标分区键)。 */
+    /** 对端标识(`CentralSyncCursor.peer`,per-(scope,peer) 游标分区键)。 */
     peer: string;
     /** 客户端游标的共同基线:id → rev at last completed sync round(空 map = 首轮)。 */
     baseRevs: Record<string, string>;

package/dist/model-entry-refusal.d.ts

@@ -49,6 +49,8 @@ export interface CatalogEntryLike {
     readonly api?: unknown;
     /** [ref]:供应商附加头的承载形(`unknown`:判据在 `model-entry-headers.ts`,不信这张型)。 */
     readonly headers?: unknown;
+    /** 引擎已退役的每模型引导句(core 7.56.0 [ref];settings-schema 的 `ModelEntry` 仍收它)—— 只读在场与否,见 {@link judgeCatalogEntry}。 */
+    readonly promptGuidance?: unknown;
 }
 /**
  * **逐条判据**:`undefined` = 本部署能完整服务它。判序即语义:先形(不合形的条目谈不上走哪条腿),再腿。

package/dist/model-entry-refusal.js

@@ -31,6 +31,17 @@ export function judgeCatalogEntry(m, ctx) {
     const headers = readCatalogEntryHeaders(m.headers, m.api);
     if (!headers.ok)
         return entryInvalidRefusal(m.id, m.provider, headers.fields, headers.issue);
+    if (Array.isArray(m.promptGuidance) && m.promptGuidance.length > 0) {
+        return {
+            ...refusalCause("config.model_entry_invalid"),
+            id: m.id,
+            provider: m.provider,
+            fields: ["promptGuidance"],
+            detail: "the catalog entry carries per-model guidance sentences (promptGuidance), which the engine no longer delivers — the entry is not served here " +
+                "rather than served with its sentences silently dropped; move each sentence into a center or deployment prompt overlay on the behavior band " +
+                "and remove promptGuidance from the entry to bring it back",
+        };
+    }
     const lane = catalogBrainLane(m.provider);
     const mount = laneMount(lane, ctx);
     if (!mount.mounted) {

package/dist/model-route-gap.d.ts

@@ -1,23 +1,3 @@
-/**
- * **env 模型路由读数的唯一读口**:`readModelRouteEnv(env)`、env 腿的条目表 `envLaneTable`,与车道值级端口 `laneAndEndpointFor`。
- *
- * ## 形(一只读口、一处调用)
- * 「env 里哪几把键是模型路由、空串 = 未设、provider 的显式 / 推断 / 缺省、env 腿铸哪几个条目槽」的读法只在这里:
- *  · {@link readModelRouteEnv}:`parseModelDomain`(`config.ts`,起服铸 `ServiceConfig` 的路由字段)吃它的读数(`process.env` 与测试快照是同一个入参位);
- *  · {@link envLaneTable}:env 腿的条目名与键序(`parseModelDomain` 铸真 `Model` 表经它);
- *  · {@link laneAndEndpointFor}:值级端口 —— 「这只模型在这张路由表上走哪条车道、这条车道的端点 / 凭据取哪一对 env 键」。车道只经 `brainLaneFor`
- *    (core `brainLaneOf` 对路由表的答案)取,键名取 {@link MODEL_ROUTE_ENV_KEYS};**只交键名不交值**。
- * 路由判据本身(「将要服务的那张表里每条 openai 兼容路由是否解析得到端点」)不在这里:唯一属主是 `model-route-endpoint.ts` 的 `judgeModelRouteEndpoint`,
- * 起服段与 `GET /v1/models.modelPlane` 经 `judgeServedModelRoute` 问它 —— 它们判的是**将要服务的那张表**(env 表或目录表),不是本文件读出的 env 视图。
- *
- * ## 对外
- * 本模块的精选再导出是子路径 `@sema-agent/server/model-route-env`(`src/model-route-env.ts`):引擎 core 是 BYOM(只吃调用方给的路由表,不读这些键),
- * 别仓要在引擎起之前回答「走哪条车道、端点 / 凭据取哪一对键」,读这一只,不各抄一份键名与车道判。
- *
- * ## 纯
- * 不读 `process.env`、不读文件、不枚举快照 —— 只按 {@link MODEL_ROUTE_ENV_KEYS} 点名取值(依赖闭包里没有 `node:*` / `process`,
- * `test/model-route-env-reading.test.ts` 钉)。同入同出;返回值是新对象。provider 词域外的值在这里按引擎派发的口径读作网关腿(`brainLaneFor`:域外词的路由表里没有那个键 ⇒ 引擎路由器落网关 fallback),不在此拒(域外拒启是 `model-provider-word` 那条不变量的事)。
- */
 import { type ModelBrainLane } from "./model-provider.js";
 /**
  * 路由读数读的九把 env 键(**闭表**;{@link readModelRouteEnv} 只碰这几把,测试用代理钉「读集 ⊆ 本表」)。
@@ -59,8 +39,9 @@ export interface ModelRouteEnvReading {
     /** `MODEL_GATEWAY_FALLBACK_URLS` 逐项 trim、丢空项。 */
     readonly gatewayFallbackUrls: string[];
     /**
-     * `MODEL_API_KEY`(网关腿的部署级凭据):**原样**读 —— 与其余各把不同,空串**不**折成未设。brain 装配以**真值**判这把凭据发不发(空串部署一个凭据字节都不发),
+     * `MODEL_API_KEY`(网关腿的部署级凭据):读数**原样**交出 —— 与其余各把不同,空串**不**折成未设:
      * 起服铸的 `ServiceConfig.gatewayApiKey` 逐字保留空串(compose 的 `${VAR:-}` 模板与空 Secret 挂载天天产它);读数改折叠会改变那一位。
+     * 「这把凭据设了没有」的问法不在读数里折,而是消费方问 {@link declaredCredential}(引擎的 `isBlankCredential`:空串与只含空白都 = 没有)。
      * 它只与网关端点配对(没有 {@link gatewayBaseUrl} 就不装载),配对由消费方判。
      */
     readonly gatewayApiKey: string | undefined;
@@ -85,6 +66,9 @@ export interface ModelRouteEnvReading {
     /** cheap 槽铸不铸(见 {@link EnvCheapSlot})。 */
     readonly cheapSlot: EnvCheapSlot;
 }
+/** 一把凭据键「设了没有」的唯一问法(两把 anthropic 键与网关键 `MODEL_API_KEY` 同读):引擎的 `isBlankCredential`(整串 trim 后为空 ⇒ 没有凭据)—— 与引擎对同一个值的读法同一只,
+ *  不自拼第二种「空」:只含空白的 key 旁边的 token 是 bearer(引擎让那只头作凭据照发),不是同设冲突;两把都空白 = 缺席、路由不挂;只含空白的网关 key = 没有部署凭据。 */
+export declare const declaredCredential: (v: string | undefined) => string | undefined;
 /** 逗号串读法的归一点:逐项 trim、丢空项(缺席 = 空串 = `[]`)。本文件的 CSV 路由键与 `config.ts` 的逗号串旋钮(按名薄壳 `csv(name)`)同读这一只;
  *  目录模块的回显分词与 `SERVICE_AUTH_TOKENS` 的 `k=v` 对分词是同形的另两处,尚未改调(清账版收,本函数届时挪到中性模块)。 */
 export declare const csvOf: (raw: string | undefined) => string[];
@@ -98,7 +82,7 @@ export declare function readModelRouteEnv(env: ModelRouteEnv): ModelRouteEnvRead
  *  · `ANTHROPIC_API_KEY`    ⇒ `x-api-key`(只发它);
  *  · `ANTHROPIC_AUTH_TOKEN` ⇒ `Authorization: Bearer`(只发它);
  *  · 两个都设 ⇒ `conflict`:两个名字说的是两种头,哪个赢都是替运维猜(7.135.0 及以前是「AUTH_TOKEN 优先」,x-api-key 被静默丢弃)⇒ 起服拒启,拒句 {@link anthropicCredentialRefusal}。
- * 空串 = 未设(与 {@link readModelRouteEnv} 同尺)。入参是两个名字各自的值 —— env 读数的两位或 `config.anthropic` 的 `apiKey` / `authToken` —— 不读 `process.env`。
+ * 「设了没有」按引擎的 `isBlankCredential` 读(空串与只含空白都 = 未设;与 {@link declaredCredential} 同一只)。入参是两个名字各自的值 —— env 读数的两位或 `config.anthropic` 的 `apiKey` / `authToken` —— 不读 `process.env`。
  * 读者:起服(`config.ts` 的拒启锚与跨键不变量表 `anthropic-credential-exclusive` 同一句)· brain 装配(交引擎哪种头)· hook 直连腿(哪种头、交引擎配对判官的那份值)·
  * 车道端口 {@link laneAndEndpointFor}(哪把键)· 起服的 Bearer 部署诊断(`boot/web-admin.ts`)。
  */