@sema-agent/server 7.146.0 → 7.148.0

package/dist/http/idempotency.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage } from "node:http";
 import type { ServiceConfig } from "../config-types.js";
+import type { Subject } from "../owner-brands.js";
 import type { WiringManifestReceipt } from "./wire-types.js";
 import type { SubmitReplayFace } from "./submit-replay.js";
 import type { RunIdemBinding } from "../plugins/store-contracts.js";
@@ -36,8 +37,8 @@ export declare class IdempotencyCache<T> {
  * `Idempotency-Key` 的**资源族**闭集 —— 键的作用域里那一位是**资源族,不是端点**。
  *
  *  · `run`    —— 一条 run(`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` · A2A `message/send` 都建同一种行;
- *                同一条 run 换腿重试仍同键,不会重复计费)。同族的两个动词口(`/v1/runs/:id/steer` · `/interrupt`)
- *                也按本族取键,收成引擎的 `inputId`(它们的去重属主是引擎的输入队列,不是本仓的行)。
+ *                同一条 run 换腿重试仍同键,不会重复计费)。同族的动词口 `/v1/runs/:id/steer`
+ *                也按本族取键,收成引擎的 `inputId`(它的去重属主是引擎的输入队列,不是本仓的行;`/interrupt` 是不带输入的 halt,不取键)。
  *  · `leader` —— 一条 leader run(`leader_run.idem_key`)。
  *  · `bake`   —— 一次镜像烘焙(`image_bake.idem_key`)。
  *
@@ -45,12 +46,14 @@ export declare class IdempotencyCache<T> {
  */
 export type IdemFamily = "run" | "leader" | "bake";
 /**
- * 一次提交的**调用方身份**(幂等的作用域就是它)—— 授权口建立的那两样:验过的 principal(`gatedPrincipal`)与凭据族
+ * 一次提交的**调用方身份**(幂等的作用域就是它)—— 授权口建立的那两样:验过的 principal(`gatedSubject`)与凭据族
  * (`source`:鉴权门由出示的服务凭据派生的系统名,`RouteRequestState.source` 是它唯一的赋值点)。由 {@link idemCallerOf}
  * 从请求一处读出;键里用的那一位由 {@link idemIdentityOf} 一处定。
  */
 export interface IdemCaller {
-    readonly principal: string | null | undefined;
+    /** 验过的主体(分区键;`gatedSubject` 的读数,带 `Subject` 品牌 —— 提交重放与 leader 登记表的属主门直接拿它当调用方,不再另铸;
+     *  幂等身份位读它 ⇒ 同一只 `Idempotency-Key` 在同一个人的两个场景里是两把键)。 */
+    readonly subject: Subject | null | undefined;
     readonly source: string | null | undefined;
 }
 /** 本次请求的 {@link IdemCaller} —— 一处读:验过的 principal + 鉴权门派生的凭据族(两样都是既有的席位,这里不另判身份)。 */
@@ -118,7 +121,8 @@ export declare function inflightKeyOf(idem: RunIdemBinding, face: SubmitReplayFa
  * 就成了「键缺席」,而 present-iff 的读法会把它读成「这台引擎不给回执」。挂在 outcome 上 = 它是**这条 run 的
  * 属性**(哪条腿跑的都一样),由各腿自己的应答构造器在送出那一刻按自己的 wire 形挂。
  * 落定之后的同键重放不走这里:它读行,体是首答的信封 + `replay: true`(`http/submit-replay.ts` → `http/sync-submit-body.ts`)—— 回执是起手那一帧
- * 的活捕获、不落行,所以重放体上**不带** `wiringManifest`(`replay: true` 就是那一形的判别位)。
+ * 的活捕获、不落行,所以读行的重放体上**不带** `wiringManifest`。在飞合流的跟随方拿的是这一只 outcome(回执照带)经 `replayedOutcome` 叠位 ——
+ * `replay: true` 只说「这份结局不是本次请求产出的」,不判别带不带回执。
  *
  * 🔴 **租户面安全(别在复审里当成漏)**:合流的那份回执是按**第一位调用方**的 `explicitOperatorOk` 投的,
  * 而键本身就按身份位分区(`idemKeyOf` 的 `principal ?? source`)⇒ 合流到它的只可能是**同一个** principal(无 principal 时

package/dist/http/idempotency.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { canonicalJsonStringify } from "@sema-agent/core";
-import { gatedPrincipal } from "./principal-gate.js";
+import { gatedSubject } from "./principal-gate.js";
 export class IdempotencyCache {
     ttlMs;
     sweepThreshold;
@@ -66,11 +66,11 @@ function idemFamilyTag(family) {
     }
 }
 export function idemCallerOf(req, ctx) {
-    return { principal: gatedPrincipal(req, ctx.deps.config), source: ctx.req.source };
+    return { subject: gatedSubject(req, ctx.deps.config), source: ctx.req.source };
 }
 export function idemIdentityOf(caller) {
-    if (caller.principal !== undefined && caller.principal !== null)
-        return `principal\x1e${caller.principal}`;
+    if (caller.subject !== undefined && caller.subject !== null)
+        return `principal\x1e${caller.subject}`;
     if (caller.source !== undefined && caller.source !== null)
         return `source\x1e${caller.source}`;
     return "";

package/dist/http/memory-compliance-failure-reply.d.ts

@@ -8,39 +8,38 @@
  * core 的另外三只 409 与 `ControlPlaneCorruptError` 全落 500 `internal.error` —— 「同一个 requestId 拿去抹另一个会话」这种**调用方自己
  * 能改**的错被说成服务器坏了。两份分类 = 两个判官,少的那份恒是静默的一份。现在**码与状态**只在这里判一次,两面同读。
  *
- * ## 规则(三层,与 operator 面既有层序逐字同序)
+ * ## 规则(两层,与 operator 面既有层序逐字同序)
+ *  ⓪ 先于本映射:两面的 catch 先调记忆面的一只收尾 `sentMemoryFaceFault`(`memory-face-fault-reply.ts`:层拒 / 控制面损坏 `ControlPlaneCorruptError`,
+ *     九只记忆面同一只;控制面损坏一码两义的固定句在那里按面分)—— 本映射只接 core 的带码拒;
  *  ① core 的**本口专属**码(闭集穷举 `switch`,见 {@link sentCoreCode})—— 码与状态两面同;文案按受众(下一节,一条规则);
- *  ② **店形拒**两码 `memory.target_outside_store`(core 7.31.1 [ref])/ `memory.scope_home_not_directory`(core 7.44.0 [ref])—— 跨面 store 状态码,409、码原样
+ *  ② **店形拒**一族(按族表读;成员举例 `memory.target_outside_store` / `memory.scope_home_not_directory` / 引擎 7.65.0 起 `memory.control_plane_links_unsupported` / 引擎 7.66.0 起 `memory.control_plane_strays`)—— 跨面 store 状态码,409、码原样
  *     (判据 `memory-store-refusal.ts` 一只;运维行 `memory_store_form_refused { code, path?, form? }` 两受众同一只铸点,路径只在那里);
- *  ③ `ControlPlaneCorruptError` —— typed 500 `internal.memory_control_plane_corrupt`(fail-closed 信号,一码两义;映射本体在 `memory-control-plane-corrupt-reply.ts` 那一只,导出导入 / 外源 / 整理 / 合规各口同调);
  *  其余 ⇒ `false`(未分类,调用方发它自己那句 500 且**不回显**内部文本)。
  *
- * ## 文案按受众分(码与状态不分)—— **一条规则,三层同施,不按码挑**(F9,7.108.0 合并复审 opus 腿 O-9)
- * core 原句是写给运维的诊断材料:③ 点名**宿主路径**(控制面账本文件;② 自 core 7.44.0 起句子不带路径、路径在 `detail.path` ⇒ 运维行),① 的 `selector_mismatch` 带**首个请求的
+ * ## 文案按受众分(码与状态不分)—— **一条规则,各层同施,不按码挑**(F9,7.108.0 合并复审 opus 腿 O-9;⓪ 那只收尾同一条规则)
+ * core 原句是写给运维的诊断材料:控制面损坏点名**宿主路径**(控制面账本文件;② 自 core 7.44.0 起句子不带路径、路径在 `detail.path` ⇒ 运维行),① 的 `selector_mismatch` 带**首个请求的
  * 选择子哈希**(`pinned set <selectHash>`,无盐 sha256 —— operator 选择子可字典还原,首个请求未必是这位会话所有者发的):
  *  · operator 受众 ⇒ 原句上 wire(过了 operator 门,这些材料对这个受众不是泄露);
  *  · 会话所有者受众 ⇒ **一律**一句固定指路(每码一句,只说「怎么办」),原句整句交 `withheld` 落运维 warn —— 不逐码判断哪句安全
- *    (逐码挑 = core 改一句文案就可能静默漏出一样新东西)。② ③ 的固定句**两形都真**:
- *    ② 链先于请求在场 ⇒ 提交点之前拒、什么都没做;提交点之后才换上的链 ⇒ 已删的几条算数、journal 留盘(codex 一审 C1);scope home 不是真目录那一句
- *       同样不许诺零删除(home 被换掉的时刻本层判不出),只指路「运维放回真目录后用同一个 requestId 重发」;
- *    ③ 一码两义 —— 操作前账本读不出 ⇒ 什么都没发生;落定后残留枚举失败 ⇒ 抹除已提交、重放收敛(core 原话)。两句都不许诺零删除,
- *    都指路「运维修好后用同一个 requestId 重发」(两义下这句都对)。本层**不**嗅 core 文案分辨前后(拿上游自由文本当判别式是第二真源)。
+ *    (逐码挑 = core 改一句文案就可能静默漏出一样新东西)。② 的固定句**两形都真**:链先于请求在场 ⇒ 提交点之前拒、什么都没做;提交点之后才换上的链
+ *    ⇒ 已删的几条算数、journal 留盘(codex 一审 C1);scope home 不是真目录那一句同样不许诺零删除(home 被换掉的时刻本层判不出),只指路
+ *    「运维放回真目录后用同一个 requestId 重发」。本层**不**嗅 core 文案分辨前后(拿上游自由文本当判别式是第二真源)。
  */
 import type { ServerResponse } from "node:http";
 import type { Logger } from "../observability/logger.js";
+import type { MemoryFaceAudience } from "./memory-face-fault-reply.js";
 /**
  * 已分类拒 → HTTP 状态的**唯一**码表 = 自铸 wire 值登记处的 `sessionMemoryEraseStatus` 集(F3:wire 变更清单从同一张表 diff,状态改一处、
  * 清单跟着列)。两面同读([ref]:码与状态只判一次)。键写错 ⇒ tsc 红(索引的是 `as const` 表的键)。
  */
-/** 读这张映射的受众(闭集)。会话所有者受众必须交一只 `withheld` —— 被换成固定句的 core 原句落到那里(运维材料不许丢)。 */
-export type MemoryComplianceAudience = {
+/** 读这张映射的受众:记忆面受众闭集里 operator 与会话所有者的抹除面(本映射的固定句都是抹除句;会话所有者的状态面不读它 ⇒ 型面上传不进来)。 */
+export type MemoryComplianceAudience = Extract<MemoryFaceAudience, {
     readonly kind: "operator";
 } | {
-    readonly kind: "session_owner";
-    readonly withheld: (coreMessage: string) => void;
-};
+    readonly face: "erase";
+}>;
 /**
- * 按上面三层应答;返回 `true` = 已应答,`false` = 未分类(一个字节都没写,调用方发它自己那句 500 并落它自己的运维 warn)。
+ * 按上面两层应答;返回 `true` = 已应答,`false` = 未分类(一个字节都没写,调用方发它自己那句 500 并落它自己的运维 warn)。
  * `logger` = 店形拒那一条运维行的去处(两受众同一只;缺席 ⇒ 不落)。
  */
 export declare function sentMemoryComplianceFailure(res: ServerResponse, err: unknown, audience: MemoryComplianceAudience, logger: Pick<Logger, "warn"> | undefined): boolean;

package/dist/http/memory-compliance-failure-reply.js

@@ -1,5 +1,4 @@
 import { logStoreFormRefusal, storeFormRefusalOf } from "../memory-store-refusal.js";
-import { sentControlPlaneCorrupt } from "./memory-control-plane-corrupt-reply.js";
 import { sentMemoryStoreRefusal } from "./memory-store-refusal-reply.js";
 import { sendError } from "./send.js";
 import { assertNever } from "./route-ctx.js";
@@ -63,6 +62,12 @@ export function sentMemoryComplianceFailure(res, err, audience, logger) {
                     case "memory.scope_home_not_directory":
                         sendError(res, 409, "memory.scope_home_not_directory", "session memory erasure refused — a scope directory in this deployment's memory store is not a real directory (it was replaced by a link or a file), so this erasure did not complete; ask the operator to put the real directory back, then resend with the same requestId");
                         return true;
+                    case "memory.control_plane_links_unsupported":
+                        sendError(res, 409, "memory.control_plane_links_unsupported", "session memory erasure refused — this deployment's memory control plane is on a file system that cannot make hard links, so its memory store does not open and this erasure changed nothing; ask the operator to move the control plane to a volume that supports hard links, then resend with the same requestId");
+                        return true;
+                    case "memory.control_plane_strays":
+                        sendError(res, 409, "memory.control_plane_strays", "session memory erasure refused — this deployment's memory engine was not opened because its control plane still holds records from before that its governance store does not read, so this erasure changed nothing; ask the operator to adopt those records into the governance store, then resend with the same requestId");
+                        return true;
                     default:
                         return assertNever(storeForm.code);
                 }
@@ -70,6 +75,6 @@ export function sentMemoryComplianceFailure(res, err, audience, logger) {
                 return assertNever(audience);
         }
     }
-    return sentControlPlaneCorrupt(res, err, audience);
+    return false;
 }
 //# sourceMappingURL=memory-compliance-failure-reply.js.map

package/dist/http/memory-face-fault-reply.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 记忆面的**一只收尾**:「定店 / 读控制面时说不清」这一个故障源的两种形 —— 本服务的层拒 `MemoryLayerRefusal` 与 core 的控制面损坏
+ * `ControlPlaneCorruptError` —— 在 HTTP 上的答法,唯一一处;外加记忆动词的**层座**读法。
+ *
+ * ## 规则(一条)
+ * 一只记忆面的 catch 只调 {@link sentMemoryFaceFault} 一次,先于它自己的码表(两形都是类判别、与 core 的带码拒不相交:层拒的 `code` 是本服务的
+ * `request.memory_layer`,控制面损坏没有 `code`)。挂不挂哪一形不由各面记 —— 两种形同一个故障源(定店 / 读控制面),哪一只面都可能收到哪一形,
+ * 组合是全面律,不按今天能不能构造出来挑面。两只单件是本模块私有的(不导出 ⇒ 面上不可能只挂一半);`instanceof` 判别只住这里。
+ * 调用面(九只):导出 / 导入包 · 外源三口 · 整理 run · 整理状态 · 合规两口(运维)· 记忆导出 · 记忆同步 · 会话记忆状态 · 会话记忆抹除。
+ *
+ * ## 层拒 ⇒ 400 `request.memory_layer`
+ * 一次记忆请求只落一只店(店的那一半在 `src/memory-scope-stores.ts`):请求点名的层读不出 / 点名的几层分住两只店 / 两店部署上没点名层 ——
+ * 请求可以改对,服务器没坏。
+ *
+ * ## 控制面损坏 ⇒ 500 `internal.memory_control_plane_corrupt`
+ * core 的 fail-closed 信号:记忆引擎的控制面(账本 / 事务日志 / 清标账 / 治理账 / 作用域登记簿)说不清,它宁可不答,也不在一个说不清的账上拼一个答案。
+ * 消费端按 `errorCode` 分支,运维有具体动作(修 / 重建之后重试)。
+ *
+ * ## 文案按受众分(码与状态不分;与 `memory-compliance-failure-reply.ts` 同一条规则):受众拿到的句子 = 它看得的材料
+ *  · operator ⇒ 原句上 wire(层拒点名部署配置的层与哪几层住在哪只店;控制面损坏点名**哪一张**账坏了、带宿主路径 —— 过了 operator 门的受众拿它不是泄露);
+ *  · 层属主(中心记忆导出 / 同步上过了层属主门、但不是 operator 的调用方:本人的 user 层 / 本人的项目层 / org 目录成员)⇒ 层拒原句(这两面只点名
+ *    一层,层拒句只带请求自己的层键与引擎的读法句,不带部署配置的层);控制面损坏换固定句(原句带宿主路径),原句整句交 `withheld` 落运维行;
+ *  · 会话所有者 ⇒ 固定句(只说怎么办),原句整句交 `withheld` 落运维行。层拒的固定句面无关(两形都真:点名的层读不出 / 本部署配置的层读不出);
+ *    控制面损坏的固定句按面分(受众闭集的面位,穷举 `switch`):
+ *      - `erase`:一码两义都真 —— 操作前账本读不出 ⇒ 什么都没发生;落定后残留枚举失败 ⇒ 抹除已提交、重放收敛(core 原话)。不许诺零删除,
+ *        指路「运维修好后用同一个 requestId 重发」;
+ *      - `status`:读面,只说「控制面读不清,运维修好后再读」—— 不许诺零删除、不提 requestId。
+ *    本层**不**嗅 core 文案去分辨哪一义(拿上游自由文本当判别式是第二真源)。
+ *
+ * ## 层座的读法({@link readLayerSeat})
+ * 不点名层的动词(条目 id / 会话 id / 店级账本)多一个可选的 `scope`:GET 口在查询串(`?scope=<层键>`),POST 口在体里(`"scope": "<层键>"`);
+ * 点名的层只用来定店,动词本身的语义不变。缺席 ⇒ 没点名;在场 ⇒ 必须是非空串,否则 400 `request.field_invalid`、面一次都不调
+ * (空串与非串不是「没点名」—— 静默当缺席会把请求答在另一只店上)。
+ *
+ * 每处 `sendError` 的码与固定句都写**字面量**:错误码目录门(`test/error-code-catalog-live.test.ts`)与文案冻结门(`test/api-error-text-freeze.test.ts`)
+ * 扫的是源码字面量,变量态的码 / 句对它们隐形。
+ */
+import type { ServerResponse } from "node:http";
+import type { MemoryLayerSeat } from "../memory-operator-faces.js";
+/** 会话所有者受众:面位(控制面损坏的固定句按它分)+ `withheld`(被换成固定句的原句落到那里 —— 运维材料不许丢)。 */
+type SessionOwnerAudience<F extends string> = {
+    readonly kind: "session_owner";
+    readonly face: F;
+    readonly withheld: (coreMessage: string) => void;
+};
+/** 层属主受众(中心记忆导出 `export` / 同步 `sync`;过了层属主门而不是 operator 的调用方)。 */
+type LayerOwnerAudience = {
+    readonly kind: "layer_owner";
+    readonly face: "export" | "sync";
+    readonly withheld: (coreMessage: string) => void;
+};
+/** 读记忆面收尾的受众(闭集)。会话所有者两面:自助抹除 `erase` · 会话记忆状态 `status`;层属主一类(中心导出 / 同步)。 */
+export type MemoryFaceAudience = {
+    readonly kind: "operator";
+} | LayerOwnerAudience | SessionOwnerAudience<"erase"> | SessionOwnerAudience<"status">;
+/**
+ * 层座:`present` = 键在不在(查询串 `has` / 体 `in`),`value` = 它的值。缺席 ⇒ `undefined`;非空串 ⇒ `{ layer }`;
+ * 其余 ⇒ 已答 400 `request.field_invalid`,返回 `null`(调用方 `return`)。
+ */
+export declare function readLayerSeat(res: ServerResponse, present: boolean, value: unknown): MemoryLayerSeat | undefined | null;
+/**
+ * `err` 是这一个故障源的两形之一 ⇒ 已应答,返回 true:层拒 ⇒ 400 `request.memory_layer`;控制面损坏 ⇒ 500 `internal.memory_control_plane_corrupt`
+ * (文案按受众)。否则 false,一个字节都不写(调用方接着走它自己的码表)。
+ */
+export declare function sentMemoryFaceFault(res: ServerResponse, err: unknown, audience: MemoryFaceAudience): boolean;
+export {};
+//# sourceMappingURL=memory-face-fault-reply.d.ts.map

package/dist/http/memory-face-fault-reply.js

@@ -0,0 +1,71 @@
+import { ControlPlaneCorruptError } from "@sema-agent/core";
+import { MemoryLayerRefusal } from "../memory-scope-stores.js";
+import { assertNever } from "./route-ctx.js";
+import { sendError } from "./send.js";
+export function readLayerSeat(res, present, value) {
+    if (!present)
+        return undefined;
+    if (typeof value === "string" && value.length > 0)
+        return { layer: value };
+    sendError(res, 400, "request.field_invalid", "scope must be a non-empty memory layer key when present — it names the layer whose memory store this request is answered on");
+    return null;
+}
+export function sentMemoryFaceFault(res, err, audience) {
+    if (err instanceof MemoryLayerRefusal) {
+        sendLayerRefusal(res, err, audience);
+        return true;
+    }
+    if (err instanceof ControlPlaneCorruptError) {
+        sendControlPlaneCorrupt(res, err, audience);
+        return true;
+    }
+    return false;
+}
+function sendLayerRefusal(res, err, audience) {
+    switch (audience.kind) {
+        case "operator":
+        case "layer_owner":
+            sendError(res, 400, "request.memory_layer", err.message);
+            return;
+        case "session_owner":
+            audience.withheld(err.message);
+            sendError(res, 400, "request.memory_layer", "the memory store this request reaches cannot be told — the `scope` in the request is not a memory layer this deployment can read, or this deployment's own memory layer configuration cannot be read; resend without `scope` (or with a readable layer), or ask the operator");
+            return;
+        default:
+            return assertNever(audience);
+    }
+}
+function sendControlPlaneCorrupt(res, err, audience) {
+    switch (audience.kind) {
+        case "operator":
+            sendError(res, 500, "internal.memory_control_plane_corrupt", err.message);
+            return;
+        case "layer_owner":
+            audience.withheld(err.message);
+            switch (audience.face) {
+                case "export":
+                    sendError(res, 500, "internal.memory_control_plane_corrupt", "memory export could not be completed — the memory store of this layer could not be read cleanly (its memory control plane is damaged); ask the operator to repair it, then retry");
+                    return;
+                case "sync":
+                    sendError(res, 500, "internal.memory_control_plane_corrupt", "memory sync could not be completed — the memory store of this layer could not be read cleanly (its memory control plane is damaged); ask the operator to repair it, then retry the round");
+                    return;
+                default:
+                    return assertNever(audience);
+            }
+        case "session_owner":
+            audience.withheld(err.message);
+            switch (audience.face) {
+                case "erase":
+                    sendError(res, 500, "internal.memory_control_plane_corrupt", "session memory erasure could not be completed — this deployment's memory control plane could not be read cleanly (depending on where it stopped, either nothing was changed or the deletions were already committed and a replay finishes them); ask the operator to repair it, then resend with the same requestId");
+                    return;
+                case "status":
+                    sendError(res, 500, "internal.memory_control_plane_corrupt", "session memory status could not be read — this deployment's memory control plane could not be read cleanly; ask the operator to repair it, then read the status again");
+                    return;
+                default:
+                    return assertNever(audience);
+            }
+        default:
+            return assertNever(audience);
+    }
+}
+//# sourceMappingURL=memory-face-fault-reply.js.map

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

@@ -1,6 +1,6 @@
 /**
- * **店形拒**两码(`memory.target_outside_store` / `memory.scope_home_not_directory`,判据在 `src/memory-store-refusal.ts`)的
- * **operator 面 HTTP 映射** + 两受众共用的**运维行** —— 唯一一处码字面量。挂在每一个触 store 树的 operator 记忆口的已分类收尾上:
+ * **店形拒**一族(`memory.target_outside_store` / `memory.scope_home_not_directory` / `memory.control_plane_links_unsupported` / `memory.control_plane_strays`,族表与判据在 `src/memory-store-refusal.ts`)的
+ * **operator 面 HTTP 映射** + 两受众共用的**运维行** —— operator 面唯一一处码字面量(会话所有者面的逐码臂在 `http/memory-compliance-failure-reply.ts`;引擎加码 ⇒ 两处各补一臂)。挂在每一个触 store 树的 operator 记忆口的已分类收尾上:
  * `routes/memory-compliance.ts`(出处 / 抹除;经 `http/memory-compliance-failure-reply.ts` 的 operator 受众臂)· `routes/memory-origin.ts`(外源列表 / 清标;**不含**只读控制面的清标账列表 ——
  * core 的 wire 表逐字:只碰控制面的面不判,给它挂一条永远收不到的码路径正是附录 A 活触发门要防的形)·
  * `routes/memory-bundle.ts`(导出 / 导入)。会话所有者的自助抹除口**不走这里的 wire 句**(经 `http/memory-compliance-failure-reply.ts` 的会话所有者受众臂:同码、固定文案),
@@ -8,7 +8,7 @@
  * `POST /v1/admin/memory/consolidation/run` 也不走这里:那口把 core 的**任何**有码拒一律收成 409 `memory.consolidation_refused`
  * (码进文案,附录 A 该行),这一族已在那条臂上,不再给它第二个码。
  *
- * ## 为什么 409(两码同一条)
+ * ## 为什么 409(一族同一条)
  * core 的读法:operator 要处置的盘形(去掉 store 里那只通到外面的目录链 / 把 scope home 放回真目录),不是可重试的 IO 故障,也不是对调用方的裁决。与
  * `memory.erasure_census_incomplete` 同一类(**当前 store 状态**下这次做不了;状态修好后重发即改判)⇒ 409,不 500(服务器没坏)、
  * 不 4xx 请求族(请求没写错)。抹除面:链先于请求在场 ⇒ core 在提交点之前拒,零删除、零 journal(真 core 格钉在

package/dist/http/memory-store-refusal-reply.js

@@ -12,6 +12,12 @@ export function sentMemoryStoreRefusal(res, err, logger) {
         case "memory.scope_home_not_directory":
             sendError(res, 409, "memory.scope_home_not_directory", refusal.message);
             return true;
+        case "memory.control_plane_links_unsupported":
+            sendError(res, 409, "memory.control_plane_links_unsupported", refusal.message);
+            return true;
+        case "memory.control_plane_strays":
+            sendError(res, 409, "memory.control_plane_strays", refusal.message);
+            return true;
         default: {
             const unhandled = refusal.code;
             throw new Error(`unhandled store-form refusal word: ${String(unhandled)}`);