@sema-agent/server 7.137.0 → 7.139.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-sync-client.d.ts

@@ -1,29 +1,68 @@
 import { type MemoryBackend, type MemorySyncClientResult, type MemorySyncTransport } from "@sema-agent/core";
+import { type OneTimeMigrationWindow } from "./plugins/one-time-migrations.js";
 /** 结构化日志面(src/observability/logger.ts Logger 的结构子集——测试可注入捕获器)。 */
 export interface MemorySyncLog {
     info(msg: string, fields?: Record<string, unknown>): void;
     warn(msg: string, fields?: Record<string, unknown>): void;
 }
-/** 缺省对端名(core `syncMemoryScope` 同款缺省;cursor 按 (scope,peer) 分区)。 */
-export declare const DEFAULT_MEMORY_SYNC_PEER = "central";
 /**
- * fetch transport(core `MemorySyncTransport` 的部署实现)。`url` = 中心 server 基址(尾斜杠剥除,
- * core 传来的 path 以 `/` 开头);`token` 走 Authorization: Bearer(与中心侧 gatedPrincipal 的
- * verified-principal 门对齐)。非 2xx throw(status + body 前 200 字节——中心 4xx/5xx 的 typed error
- * body 就是最好的诊断线索);2xx 返回解码后的 JSON(形状校验在 core parseMemorySyncResponse,职责
- * 不重复)。`timeoutMs`(缺省 60s,AbortSignal.timeout)是活性保护:fire-and-forget 轮挂死会把
- * inflight 节流永久卡住(undici 默认 headers 超时 300s 太钝)。
+ * 中心基址 → 同步对端的身份(规范化基址)。本仓唯一的铸点:`config.ts` 读 env 时调它拒启(引擎关着也拒),transport 建时再调它铸身份 —— 同一只纯函数,同一个答案。
+ * 两道判,各归各的属主,本函数不另写规则:
+ *  ① 地址的形 —— 这只地址是「后面要拼路径的基址」座位(post 把同步路径拼在它后面),判官与拒句就是那一座位的那一只({@link pathBaseUrlRefusal}:层级式 http(s),
+ *     不带 userinfo / query / fragment;拒句只点名规则、值只到 origin);
+ *  ② 身份里有没有凭据 —— 判官是引擎包根的 `carriesCredential`(引擎同步客户端判 `transport.peer` 的同一只:任何 userinfo,或同主体出口脱敏会遮掉的任何一段,
+ *     例如路径段里的令牌形),判的就是规范化之后的身份 —— 引擎第一轮判的那个值。身份随每个请求体与落盘游标走,所以带凭据的地址拒而不清洗
+ *     (清洗过的身份是另一个身份;令牌只走 `MEMORY_SYNC_TOKEN`);拒句不引地址的任何部分。
+ * 规范化 = WHATWG URL 的 `origin`(协议与主机小写、缺省端口省掉)+ 路径去尾斜杠;规范化之后装不进中心侧 `peer` 列({@link MEMORY_SYNC_PEER_COLUMN_CHARS},
+ * 每一轮都会被中心拒)⇒ 同样拒。
+ */
+export declare function memorySyncPeerOf(url: string): string;
+/**
+ * 起服日志行 `memory_sync_enabled` 的字段(两处起服 —— `boot/stores.ts` 与 `run-local.ts` —— 同读这一只)。`peer` 是运维改绑游标时要抄的那个值:
+ * 它已过 {@link memorySyncPeerOf} 的两道判(带凭据的身份起不来);仍过展示铸点({@link buildDisplaySafeUrl}),日志里的 URL 值一律经它 —— 两只判官
+ * (引擎的出口脱敏与本仓的展示形状律)不是同一份实现,本仓的那一只若遮了引擎放行的一段,这一行带遮记号而不是逐字(响亮,不漏)。
+ */
+export declare function buildMemorySyncEnabledFields(peer: string, scope: string, cursorPath: string): {
+    readonly peer: string;
+    readonly scope: string;
+    readonly cursorPath: string;
+};
+/**
+ * fetch transport(core `MemorySyncTransport` 的部署实现)。`peer` = {@link memorySyncPeerOf}(`url`)(建时铸一次;拒的地址在这里抛,一个请求都不发),
+ * `post` 打 `${peer}${path}`(core 传来的 path 以 `/` 开头);`token` 走 Authorization: Bearer(与中心侧 gatedPrincipal 的 verified-principal 门对齐)。
+ * 非 2xx throw(status + body 前 200 字节——中心 4xx/5xx 的 typed error body 就是最好的诊断线索);2xx 返回解码后的 JSON(形状校验在 core
+ * parseMemorySyncResponse,职责不重复)。`timeoutMs`(缺省 60s,AbortSignal.timeout)是活性保护:fire-and-forget 轮挂死会把 inflight 节流永久卡住
+ * (undici 默认 headers 超时 300s 太钝)。
  */
 export declare function createMemorySyncTransport(opts: {
     url: string;
     token: string;
     timeoutMs?: number;
-    fetchImpl?: typeof fetch;
+    /** The one call shape this transport makes (`fetch` itself fits it). */
+    fetchImpl?: (url: string, init: RequestInit) => Promise<Response>;
 }): MemorySyncTransport;
-/** cursor 文件路径:`memoryRoot`(= RunnerDeps.memoryEngineDir 的 resolved config root,memory/ 目录旁)下的
- *  per-(peer, scope) sidecar(`sync-cursors/<peer>/<scope 摘要>.json`)。peer 段走 core encodeScopeSegment(文件名安全字符纪律与 scope 目录同);scope 段取 sha256 前 32 hex
- *  (scope 键带 `:` `/` 且可长过段编码的 64 字符帽 —— 名字只需区分,内容里仍记原 scope,读时比对)。 */
-export declare function memorySyncCursorPath(memoryRoot: string, peer: string, scope: string): string;
+/** 一层的游标文件路径:`memoryRoot`(= RunnerDeps.memoryEngineDir 的 resolved config root)下 `sync-cursors/<scope 摘要>.json`。一层一只,不随对端变。
+ *  落在子目录里:与更早的根下一层文件名 `sync-cursor-<peer>.json` 的空间不相交。 */
+export declare function memorySyncCursorPath(memoryRoot: string, scope: string): string;
+/** M31 一次的读数(测试按它断言)。`window: "closed"` ⇒ 一行都没读。 */
+export interface SyncCursorRelocationM31Report {
+    readonly window: "open" | "closed";
+    readonly moved: number;
+    readonly left: number;
+}
+/**
+ * ⑤ 一次性迁移 M31:把升级前的游标搬到各自那一层的路径(`rename`,字节不变;只搬不改,判归引擎)。`today` = UTC 日历日;窗关 ⇒ 不搬。
+ *  · 上一版的分区目录 `sync-cursors/central/<scope 摘要>.json` ⇒ `sync-cursors/<同名>`(两种布局的文件名是同一只 scope 摘要);搬空的目录删掉;
+ *    名字不是摘要形的(写游标的 staging 残片)原地不动。
+ *  · 更早的 `sync-cursor-central.json` ⇒ 它记的那一层的路径;读不成对象 / 没有 scope ⇒ 原地不动、一行 warn(没法说它是哪一层的基线)。
+ *  · 目标路径上已有游标 ⇒ 不搬、不删,一行 warn(这一层用路径上的那一份;留下的那只没有读者)。
+ * 与同一数据根上并跑的另一个进程(server + run-local)同搬:源已被对方搬走(`ENOENT`)⇒ 跳过。残余(如实):先查目标再 `rename` 之间若有写者在目标路径上
+ * 落下游标,会被盖掉 —— 写者只有本模块的 runner,而 runner 写任何游标之前先跑完本步。别的读写错 ⇒ 抛(这一轮整轮失败、下一轮再搬)。
+ */
+export declare function relocateSyncCursorsM31(memoryRoot: string, log: MemorySyncLog, opts: {
+    readonly today: string;
+    readonly window?: Pick<OneTimeMigrationWindow, "removableAfter">;
+}): Promise<SyncCursorRelocationM31Report>;
 /** 一轮里一层的结果。 */
 export interface MemorySyncLayerResult {
     readonly scope: string;
@@ -59,9 +98,9 @@ export declare function createMemorySyncRunner(opts: {
     /** 同步层(`config.memorySync.scope`);它同属主的项目层随它一起同步。 */
     scope: string;
     memoryRoot: string;
+    /** 对端 = 它的 `peer`(这一轮的对端只有这一个来源;游标绑的对端由引擎对它判)。 */
     transport: MemorySyncTransport;
     log: MemorySyncLog;
-    peer?: string;
     now?: () => number;
     /** S2.5 分批(core 1.284 两 seam):push 集/pull 集单轮上限。未设=不分批(wire 字节不变)。 */
     maxPushEntries?: number;