@sema-agent/server 7.145.0 → 7.147.0

package/dist/boot/memory-consolidation.d.ts

@@ -2,7 +2,9 @@ import { type LaneHomeDeployment } from "../execution-lane-caps.js";
 import { type MemoryScopeStores } from "../memory-scope-stores.js";
 import type { RestartSliceCtx } from "../web-admin-client/restart-signal.js";
 import type { MemoryConsolidationDriverConfig, ServiceConfig } from "../config-types.js";
-import { resolveMemoryConsolidationDriver, type ConsolidationWriteJudge, type ConsolidationWriteJudgeInput, type EngineNotice, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type MemoryConsolidationDriverDeps, type PermissionRuleStoreProvider } from "@sema-agent/core";
+import { resolveMemoryConsolidationDriver, type ConsolidationWriteJudge, type ConsolidationWriteJudgeInput, type EngineNotice, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type MemoryBackend, type MemoryConsolidationDriverDeps, type MemoryGovernanceDurability, type PermissionRuleStoreProvider, type CompliancePosture, type RunMemoryConsolidationOptions } from "@sema-agent/core";
+/** 合规档位座的型 = 驱动动词 `compliance.postureOf` 收的那一只(core 的座型不在包根导出面上;取动词选项的成员型,形的属主仍是 core)。 */
+type CompliancePostureSeat = NonNullable<NonNullable<RunMemoryConsolidationOptions["compliance"]>["postureOf"]>;
 /**
  * 座解析的 options 形 = core 解析器交回的那只(core 7.50.0 起它**不含** `writeJudge`:判官不是模型席的一部分,由调用方在动词上带)。
  * 取解析器的返回型而不是自己写 `Omit<…>`:形的属主是 core 的解析器,本仓不持第二份。
@@ -11,7 +13,7 @@ type ConsolidationSeatOptions = ReturnType<typeof resolveMemoryConsolidationDriv
 /** D3 投影的座标签闭集。`role:<name>` 里的 name 只可能是 core 的 role 链两跳之一。 */
 export type ConsolidationSeatLabel = "explicit" | "role:consolidate" | "role:summarize";
 /** {@link buildConsolidationValveAudit} 的告警名闭集(事件名进日志 ⇒ 运维可按名过滤/告警)。 */
-export type ConsolidationValveWarningTag = "memory_consolidation_valve_unreachable" | "memory_consolidation_run_credential_gated";
+export type ConsolidationValveWarningTag = "memory_consolidation_run_credential_gated";
 /** {@link resolveConsolidationValve} 的起服提示名闭集([ref] / [ref];事件名进日志 ⇒ 运维可按名过滤/告警)。 */
 export type ConsolidationValveNoticeTag = "memory_consolidation_default_off_no_cheap_model" | "memory_consolidation_on_main_model";
 /**
@@ -141,11 +143,12 @@ export declare function createPerScopeSingleFlight<T>(): (scope: string, run: ()
  *
  *  ① **记忆引擎没接线**(`MEMORY_ENGINE=off`,或多租户形——本仓的记忆引擎只在单用户部署上装配):
  *     没有引擎就没有库可折叠,阀门是一句空话;
- *  ② **后端不自带控制面归属**(`controlPlaneRoot`):driver 的 run 账(`distiller-runs.json`)、mint 归档
- *     与引擎的 consolidation gate 全住在控制面上。缺它时 core 会把控制面**回落到本进程的本地盘**
- *     (`deriveControlPlaneDir`),而本仓是 stateless replicas ⇒ 一轮分钟级 run 的续跑账会落在某个随机
- *     pod 的盘上,pod 重建即失,而 run 是**可续跑**设计的(重跑=整库重新 mint,真金白银)。判据与
- *     `createMemoryComplianceFaces` 逐字同源(读的是后端的**面**,不看后端方言名);
+ *  ② **整理状态不随后端走**(引擎对这只后端的答案 `memoryGovernanceDurability` = `"replica-local"`):driver 的 run 账
+ *     (`distiller-runs.json`)、mint 归档与引擎的 consolidation gate 住在引擎的控制面上;后端不发布控制面时 core 会把它
+ *     **回落到本进程的本地盘**(`deriveControlPlaneDir`),而本仓是 stateless replicas ⇒ 一轮分钟级 run 的续跑账会落在某个随机
+ *     pod 的盘上,pod 重建即失,而 run 是**可续跑**设计的(重跑=整库重新 mint,真金白银)。判据**只问引擎的这一个答案**
+ *     (「整理能不能开」就是它回答的那一问;不自读后端的面、不看后端方言名);部署面(合规 / 外源 / 状态 / 部署对象)问的是
+ *     另一件事 —— 后端发不发布控制面 —— 读 `backendOwnsControlPlane`,不读这里;
  *  ③ **`MEMORY_PROVENANCE=off`**:core 的 `screenConsolidationOptions` 明写 consolidation 不能在
  *     `provenance:"off"` 下开(fold law 必须铸得出 origin 标记,否则一个被标记过的输入折出来的产物会
  *     **不带标记**地提交)。这一条本来就会在引擎构造期抛,提前判只为一件事:把**两根**旋钮的名字同时
@@ -164,15 +167,20 @@ export declare function assertConsolidationDriverWirable(input: ConsolidationWir
 export interface ConsolidationWiringFacts {
     /** 本部署接了记忆引擎吗(`boot/stores.ts` 的 `memoryEngine !== undefined`)。 */
     readonly memoryEngineWired: boolean;
-    /** 记忆后端自带控制面归属吗(`typeof backend.controlPlaneRoot === "string"` 且非空)。 */
-    readonly controlPlaneOwned: boolean;
+    /** 整理读写的状态随不随后端走:引擎对这只后端的答案(`memoryGovernanceDurability`,`"backend"` / `"replica-local"`)。
+     *  引擎契约逐字「a host that arms or reports consolidation asks here, never of a backend member it probes itself」——
+     *  阀门就是「整理能不能开」这一问,所以只问引擎、不自己读后端的面;部署面(合规 / 外源 / 状态 / 部署对象)问的是另一件事
+     *  (后端发不发布控制面,`backendOwnsControlPlane`),不问这里。记忆引擎没接 ⇒ `"replica-local"`(判官先答 `no-memory-engine`)。 */
+    readonly governanceDurability: MemoryGovernanceDurability;
     /** 只进文案 —— 让「该去拧哪根旋钮」这句话指向该腿上**真的**有效的那一根。 */
     readonly memoryEngineBackend: ServiceConfig["memoryEngineBackend"];
     /** 部署声明的 provenance 姿态(`config.memoryProvenance`;缺席 ≡ core 缺省 `carry`)。 */
     readonly provenance?: "off" | "carry";
+    /** 部署的合规档位(`config.compliancePosture`;缺席 = 无档位)。否决集只经引擎的 `resolveComplianceDenies` 求(与装配三座席同一只)。 */
+    readonly compliancePosture?: CompliancePosture;
 }
-/** 「阀门若开,这台部署结构上跑不起来」的三种成因(闭集;加一种 = 下面两只穷举 switch 编译红)。 */
-export type ConsolidationUnwirable = "no-memory-engine" | "no-control-plane" | "provenance-off";
+/** 「阀门若开,这台部署结构上跑不起来」的四种成因(闭集;加一种 = 下面两只穷举 switch 编译红)。`"replica-local"` 是引擎 `MemoryGovernanceDurability` 的那个词,逐字。 */
+export type ConsolidationUnwirable = "no-memory-engine" | "replica-local" | "provenance-off" | "compliance-denied";
 /**
  * 「阀门若开,这台部署结构上跑不跑得起来」的**判官**(三臂逐条理由见 {@link assertConsolidationDriverWirable} 头注)。
  * 返回成因词;`undefined` = 跑得起来。两处读它:显式 on 的拒启(句子 = {@link unwirableRefusal}),以及出厂缺省派生
@@ -209,8 +217,8 @@ export declare function consolidationSeatBillingOf(plane: ConsolidationSeatPlane
  *    (结构上跑不起来由下游 D1 三条拒启臂照拒,本判决不吞);开而座落主模型 ⇒ 开 + 一行
  *    `memory_consolidation_on_main_model`(部署方显式承担,但必须知道账按主模型记)。
  *  · **未设 = 出厂缺省派生**([ref] 取代 [ref] ① 的「出厂 off」实况):
- *      结构上跑不起来(判官 {@link consolidationDriverUnwirable} 有成因:多租户 / `MEMORY_ENGINE=off` / pg·mysql
- *      记忆后端 / `MEMORY_PROVENANCE=off`)⇒ **恒关、零提示、零探针** —— 派生开撞上 D1 拒启臂 = 每台配了便宜模型的
+ *      结构上跑不起来(判官 {@link consolidationDriverUnwirable} 有成因 —— 成因表只有 {@link ConsolidationUnwirable} 这一份;
+ *      配置目录说明与 USAGE 各列的同一串各有一条钉对着它)⇒ **恒关、零提示、零探针** —— 派生开撞上 D1 拒启臂 = 每台配了便宜模型的
  *      多租户 worker 升级即起不来;而配不配便宜模型它都开不了,一句指向 `MODEL_CHEAP_ID` 的提示是误导;
  *      座不落主模型({@link consolidationSeatBillingOf} = `own-model`)⇒ **开**;
  *      否则(落主模型 / 解不出)⇒ **关** + 一行 `memory_consolidation_default_off_no_cheap_model`(点名 `MODEL_CHEAP_ID`,
@@ -271,10 +279,10 @@ export declare function createConsolidationValve(input: ConsolidationValveInput
 };
 /** 阀门判决的两件输入(装配点与纯判共用一只形 —— 两个入口递的是同一组事实)。 */
 export interface ConsolidationValveInput {
-    readonly config: Pick<ServiceConfig, "memoryConsolidationDriver" | "memoryEngineBackend" | "memoryProvenance" | "models" | "tiers" | "roles">;
-    /** 只读两件:在不在(记忆引擎接没接线)、后端有没有控制面归属(`backendOwnsControlPlane` 只问那一个面)。 */
+    readonly config: Pick<ServiceConfig, "memoryConsolidationDriver" | "memoryEngineBackend" | "memoryProvenance" | "compliancePosture" | "models" | "tiers" | "roles">;
+    /** 只读两件:在不在(记忆引擎接没接线)、整理状态随不随后端走(引擎的 `memoryGovernanceDurability` 答)。 */
     readonly memoryEngine: {
-        readonly backend: unknown;
+        readonly backend: MemoryBackend;
     } | undefined;
 }
 /**
@@ -293,38 +301,27 @@ export declare function judgeConsolidationValve(input: ConsolidationValveInput):
     unwirable: Parameters<typeof resolveConsolidationValve>[0]["unwirable"];
 };
 /**
- * 阀门上了场之后的**可达性**告警两条(自查 + codex 交叉复审;姿态=warn 不拒启)。
+ * 阀门上了场之后的**可达性**告警(自查 + codex 交叉复审;姿态=warn 不拒启)。
  *
- * ## 病(结构性,而且**只在**这条阀门够得着的那种部署上成立)
+ * ## 「没有运维」那一条为什么不在这里了
  *
- * consolidation 要后端自带引擎控制面归属 ⇒ 今天只有 file 记忆后端满足 ⇒ 本仓只在**单用户**形
- * (`REQUIRE_PRINCIPAL !== true`)上装配记忆引擎 —— 而那种部署的 `OPERATOR_PRINCIPALS` 通常是**空的**。
- * 没有运维名册(名单空且没有单用户声明 `OPERATOR_SINGLE_USER`)时 `explicitOperatorOk` 对任何身份恒假(「谁是 operator」的唯一读法:空名单绝不等于
- * 「人人都是 operator」),于是:阀门开着、启动成功、两口挂着、**每一次调用 501 `capability.operator_principals_required`**(运维面同一只拒发口;403 只留给名单非空而你不在名单上),
- * 能力位诚实地报 `false` —— 唯独运维不知道为什么,而他刚刚显式拧了一根写着 "on" 的旋钮。
- *
- * ## 为什么是 warn 而不是拒启(与 D1 的三条拒启臂**刻意不同档**)
- *
- * `OPERATOR_PRINCIPALS` 是**跨面共用**的部署级旋钮(adoption / retention-ops / memory-bundle /
- * memory-compliance / admin-drain 全在同一张名单上)。为一条阀门拒掉整台机器,比这条阀门本身的价值重;
- * 而那三条拒启臂拒的是「这台机器**结构上**跑不了这件事」(没有库 / 账会丢 / 折叠法铸不出标记),
- * 本条拒的是「配齐了但没人够得着」——后者是一次**配置遗漏**,补一行 env 即可,不该要一次重启失败来教。
- * 同族先例逐字:`permission_rules_lane_unavailable`(旋钮开着却上不了场 ⇒ 打一行,不拒启)。
- * 反过来说,**沉默**同样不行:那正是「设了但没生效」病族,而这一形连能力位都是诚实的假,唯一缺的
- * 就是一句把因果说清楚的话。
+ * 曾经还有一条「阀门够不着」告警(事件名已删,不再出现在日志里):阀门开着、两口挂着,而这台部署没有运维名册 ⇒ 两口对谁都 501。
+ * 它的在场条件今天在服务腿上不可达,前提链三环:① 显式开得起来的阀门要 file 记忆后端(SQL 两只孪生不发布控制面 ⇒ 第 4 段的
+ * {@link assertConsolidationDriverWirable} 拒启),而 file 记忆引擎只在单用户形上装配(`fileMemoryPlaneFor`);② 单用户形过了起服第 1 段就一定有运维
+ * (不变量 `operator-declaration-required`:`OPERATOR_SINGLE_USER=true` 或具名名单,都没有 ⇒ 第 1 段早拒;装运维面的兜底座 `createHttpServer` 同判);
+ * ③ 本函数的唯一调用点在服务腿第 6 段。读一个不可能状态的告警是死臂,随那条不变量一起退役(钉:`test/operator-declaration-required.test.ts` ⑥,
+ * 前提链每环一格,任何一环将来不成立 ⇒ 那一格红)。
  *
  * ## 只审**显式**开的阀门([ref] / [ref] 起)
  *
- * 两条告警的前提都是「运维**显式**拧了 on」(上面那句原话)——它们是一次**表态**够不着的诊断。出厂缺省**派生**开的
- * 那台(配了便宜模型的单用户部署)没有表态可审:引擎面的自动整理照跑(不走这两个口),手动口是一件它没要过的东西。
- * 照审的后果是每一台这样的部署升级后每次起服多两行 warn,点名一根它从没设过的 `MEMORY_CONSOLIDATION_DRIVER=on`,
- * 教它去配一个它不需要的操作面。判据读阀门判决的 `source`,不读表态原词(判决是阀门开关的唯一属主)。
+ * 告警的前提是「运维**显式**拧了 on」——它是一次**表态**够不着的诊断。出厂缺省**派生**开的那台(配了便宜模型的单用户部署)
+ * 没有表态可审:引擎面的自动整理照跑(不走手动口),手动口是一件它没要过的东西。照审的后果是每一台这样的部署升级后每次起服
+ * 多一行 warn,点名一根它从没设过的 `MEMORY_CONSOLIDATION_DRIVER=on`,教它去配一个它不需要的操作面。判据读阀门判决的 `source`,
+ * 不读表态原词(判决是阀门开关的唯一属主)。
  */
 export declare function buildConsolidationValveAudit(input: {
     /** 阀门判决({@link resolveConsolidationValve} 的 `enabled` + `source`)。 */
     valve: Pick<ConsolidationValve, "enabled" | "source">;
-    /** 这台部署有没有运维名册(`operatorRosterPresent`:名单非空 ∨ 单用户声明)—— 判据不在本函数里另写一份。 */
-    operatorRosterPresent: boolean;
     /** 这台部署配了任何一把 service 凭证吗(`config.authToken` 或 `config.authTokens` 非空)。 */
     hasServiceAuth: boolean;
     /** 本地开发的显式逃生口(`ALLOW_UNAUTHED_WRITES=true`)。 */
@@ -459,8 +456,8 @@ export interface MemoryConsolidationFaces {
     /** 跑(或**续跑**)一轮。core 的 run 行是持久的:同一 scope 上有 pending run 时本调用 CONTINUE 它
      *  (同一 plan 缓存、同一 force requestId、零新 mint)—— 所以这一口对**重试安全**。 */
     run(scope: string): Promise<ConsolidationRunReceipt>;
-    /** 该 scope 最近一次 driver run 的账(`undefined` = 从没跑过 —— 诚实缺席,不编一个空壳)。 */
-    lastRun(scope: string): ConsolidationDriverRunRow | undefined;
+    /** 该 scope 最近一次 driver run 的账(`undefined` = 从没跑过 —— 诚实缺席,不编一个空壳)。core 7.63.0([ref])起经引擎的治理店座读、异步。 */
+    lastRun(scope: string): Promise<ConsolidationDriverRunRow | undefined>;
 }
 /**
  * 在**记忆作用域店**上建 consolidation 操作面。命名照 CLAUDE.md 工厂律:返回带行为的活对象 ⇒ `create*`。
@@ -506,6 +503,10 @@ export declare function createMemoryConsolidationFaces(stores: MemoryScopeStores
      *  应用时拒 = 引擎在驱动里铸的 `memory.consolidation_incomplete`;早问拒 = 驱动抛出的拒绝经引擎导出的投递口(`deliverWriteRefusal`)转成的
      *  `memory.consolidation_refused`(本仓不读通告名、不自铸通告形)。 */
     onNotice?: (notice: EngineNotice) => void;
+    /** core 7.63.0([ref]):部署的合规档位座(装配层给 `RunnerDeps.compliancePostureResolver` 那**同一只**;`undefined` = 部署没有档位)。
+     *  必填键 —— 缺席不能被读成「没有档位」:驱动动词每一轮先拿它问**层属主**的档位(契约 = {@link memoryScopeContractOf}`([scope])`,
+     *  与会话铸 spec 同一只),否决 ⇒ 在写判官、任何读、任何模型调用之前拒 `config.compliance_denied`;自动整理腿读同一只座。 */
+    postureOf: CompliancePostureSeat | undefined;
 }): MemoryConsolidationFaces;
 export {};
 //# sourceMappingURL=memory-consolidation.d.ts.map

package/dist/boot/memory-consolidation.js

@@ -1,12 +1,11 @@
 import { redactSecrets } from "../trace/redact.js";
 import { recordFailOpen } from "../observability/fail-open.js";
-import { buildOperatorRosterWayOut } from "../http/principal-gate.js";
-import { memoryMountRootOf } from "../memory-scope.js";
+import { memoryMountRootOf, memoryScopeContractOf } from "../memory-scope.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
 import { DEFAULT_MODEL_REF, resolveMainModel } from "../model-select.js";
 import { captureRecordStoreOf } from "../memory-operator-faces.js";
-import { backendOwnsControlPlane, memoryStoreForRequest } from "../memory-scope-stores.js";
-import { createConsolidationWriteJudge, deliverWriteRefusal, expandTiers, MemoryEngine, modelOriginOf, readConsolidationDriverRun, resolveMemoryConsolidationDriver, runMemoryConsolidationDriver, } from "@sema-agent/core";
+import { memoryStoreForRequest } from "../memory-scope-stores.js";
+import { createConsolidationWriteJudge, deliverWriteRefusal, expandTiers, MemoryEngine, memoryGovernanceDurability, modelOriginOf, resolveComplianceDenies, resolveMemoryConsolidationDriver, runMemoryConsolidationDriver, } from "@sema-agent/core";
 import { seatText } from "../trace/exit-seat.js";
 export function resolveConsolidationDriverSeat(deps) {
     let options;
@@ -97,10 +96,12 @@ export function assertConsolidationDriverWirable(input) {
 export function consolidationDriverUnwirable(input) {
     if (!input.memoryEngineWired)
         return "no-memory-engine";
-    if (!input.controlPlaneOwned)
-        return "no-control-plane";
+    if (input.governanceDurability !== "backend")
+        return input.governanceDurability;
     if (input.provenance === "off")
         return "provenance-off";
+    if (input.compliancePosture !== undefined && resolveComplianceDenies(input.compliancePosture).has("memory_consolidation"))
+        return "compliance-denied";
     return undefined;
 }
 function unwirableRefusal(code, facts) {
@@ -110,18 +111,23 @@ function unwirableRefusal(code, facts) {
                 `— there is no library to fold, and the two admin endpoints would answer over an engine that does not exist. ` +
                 `(The engine is wired only on single-user deployments with MEMORY_ENGINE on; a multi-tenant worker keeps memory ` +
                 `dark by design.) Wire the memory engine, or set MEMORY_CONSOLIDATION_DRIVER=off.`);
-        case "no-control-plane":
-            return (`MEMORY_CONSOLIDATION_DRIVER=on arms the memory-consolidation valve, but the wired memory backend ` +
-                `(MEMORY_ENGINE_BACKEND=${facts.memoryEngineBackend}) does NOT own an engine control plane (controlPlaneRoot) — ` +
-                `core would derive one on THIS replica's local disk, and a consolidation run's resumable account would die with ` +
-                `the pod (a lost run re-mints the whole library at full model cost on the next attempt). The file memory backend ` +
-                `owns a control plane; the pg/mysql memory backends do not. Set MEMORY_ENGINE_BACKEND=file, or set ` +
+        case "replica-local":
+            return (`MEMORY_CONSOLIDATION_DRIVER=on arms the memory-consolidation valve, but the memory engine answers "replica-local" for the ` +
+                `wired memory backend (MEMORY_ENGINE_BACKEND=${facts.memoryEngineBackend}) — a consolidation run's state would live on THIS ` +
+                `replica's local disk instead of riding the backend, and its resumable account would die with the pod (a lost run ` +
+                `re-mints the whole library at full model cost on the next attempt). The file memory backend keeps that state with the ` +
+                `backend (the engine answers "backend"); the pg/mysql memory backends do not. Set MEMORY_ENGINE_BACKEND=file, or set ` +
                 `MEMORY_CONSOLIDATION_DRIVER=off.`);
         case "provenance-off":
             return (`MEMORY_CONSOLIDATION_DRIVER=on is incompatible with MEMORY_PROVENANCE=off — core refuses to enable consolidation ` +
                 `under provenance "off" because the fold law must be able to MINT origin markers (a marked input's product would ` +
                 `otherwise commit unmarked, i.e. the fold would launder provenance). Set MEMORY_PROVENANCE=carry (or unset it, ` +
                 `which is the same posture), or set MEMORY_CONSOLIDATION_DRIVER=off.`);
+        case "compliance-denied":
+            return (`MEMORY_CONSOLIDATION_DRIVER=on arms the memory-consolidation valve, but this deployment's compliance posture ` +
+                `(COMPLIANCE_PROFILE=${facts.compliancePosture?.profile ?? "?"}, with COMPLIANCE_ADDITIONAL_DENIES) denies memory_consolidation — the engine ` +
+                `refuses every consolidation run before it reads, claims or calls a model (config.compliance_denied), on the admin endpoint and after ` +
+                `a settle alike. Set MEMORY_CONSOLIDATION_DRIVER=off, or run a posture that does not deny memory_consolidation.`);
         default: {
             const unreachable = code;
             throw new Error(`unhandled consolidation unwirable code: ${String(unreachable)}`);
@@ -132,10 +138,12 @@ function unwirableClause(code, facts) {
     switch (code) {
         case "no-memory-engine":
             return "no memory engine is wired here (multi-tenant posture, or MEMORY_ENGINE=off), so there is no library to fold";
-        case "no-control-plane":
-            return `the memory backend (MEMORY_ENGINE_BACKEND=${facts.memoryEngineBackend}) owns no engine control plane, so a consolidation run could not keep its account`;
+        case "replica-local":
+            return `the memory engine answers "replica-local" for the memory backend (MEMORY_ENGINE_BACKEND=${facts.memoryEngineBackend}), so a consolidation run's state would not outlive its replica and could not keep its account`;
         case "provenance-off":
             return "MEMORY_PROVENANCE=off, and consolidation needs provenance to mint origin markers";
+        case "compliance-denied":
+            return "the deployment's compliance posture (COMPLIANCE_PROFILE / COMPLIANCE_ADDITIONAL_DENIES) denies memory_consolidation, so the engine refuses every run";
         default: {
             const unreachable = code;
             throw new Error(`unhandled consolidation unwirable code: ${String(unreachable)}`);
@@ -194,9 +202,10 @@ export function judgeConsolidationValve(input) {
     const { config, memoryEngine } = input;
     const wiring = {
         memoryEngineWired: memoryEngine !== undefined,
-        controlPlaneOwned: backendOwnsControlPlane(memoryEngine?.backend),
+        governanceDurability: memoryEngine !== undefined ? memoryGovernanceDurability(memoryEngine.backend) : "replica-local",
         memoryEngineBackend: config.memoryEngineBackend,
         ...(config.memoryProvenance !== undefined ? { provenance: config.memoryProvenance } : {}),
+        ...(config.compliancePosture !== undefined ? { compliancePosture: config.compliancePosture } : {}),
     };
     const code = consolidationDriverUnwirable(wiring);
     const unwirable = code !== undefined ? { code, facts: wiring } : undefined;
@@ -269,18 +278,6 @@ export function buildConsolidationValveAudit(input) {
     if (!input.valve.enabled || input.valve.source !== "explicit")
         return { warnings: [] };
     const warnings = [];
-    if (!input.operatorRosterPresent) {
-        warnings.push({
-            tag: "memory_consolidation_valve_unreachable",
-            detail: "MEMORY_CONSOLIDATION_DRIVER=on armed the consolidation valve and both admin endpoints are mounted, but " +
-                "this worker has no operator: OPERATOR_PRINCIPALS is EMPTY and OPERATOR_SINGLE_USER is not set — an empty operator list means NO ONE " +
-                "is an operator (it deliberately does not mean 'everyone'), so POST /v1/admin/memory/consolidation/run and GET /v1/admin/memory/consolidation " +
-                "answer 501 capability.operator_principals_required to every caller and capabilities.memoryConsolidationDriver reports false. " +
-                `To fix: ${buildOperatorRosterWayOut()}. With OPERATOR_PRINCIPALS, callers must send a listed principal in the configured principal header; a single-user declaration needs no principal. ` +
-                "(Not a startup refusal: the operator roster is shared by every operator " +
-                "endpoint on this worker, so one valve must not decide whether the whole worker starts.)",
-        });
-    }
     if (!input.hasServiceAuth && !input.allowUnauthedWrites) {
         warnings.push({
             tag: "memory_consolidation_run_credential_gated",
@@ -363,6 +360,7 @@ export function createMemoryConsolidationFaces(stores, input) {
             const receipt = await runMemoryConsolidationDriver(engineOf(scope), scope, {
                 ...input.seat.options,
                 writeJudge: input.writeJudge,
+                compliance: { ...(input.postureOf !== undefined ? { postureOf: input.postureOf } : {}), scopeContract: memoryScopeContractOf([scope]) },
                 ...(input.onNotice !== undefined ? { onNotice: input.onNotice } : {}),
             }).catch((err) => {
                 deliverWriteRefusal(err, scope, input.onNotice);
@@ -373,7 +371,7 @@ export function createMemoryConsolidationFaces(stores, input) {
             }
             return receipt;
         }),
-        lastRun: (scope) => readConsolidationDriverRun(engineOf(scope).controlPlaneRoot, scope),
+        lastRun: (scope) => engineOf(scope).readConsolidationDriverRun(scope),
     };
 }
 //# sourceMappingURL=memory-consolidation.js.map

package/dist/boot/org-memory.js

@@ -8,7 +8,7 @@ function collectDeploymentOrgScopes(config) {
         scopes.add(config.memoryScope);
     if (config.requirePrincipal !== true) {
         for (const project of Object.values(config.projects)) {
-            for (const s of project.defaultScopes ?? [])
+            for (const s of project.defaultScopes)
                 if (s.startsWith(ORG_PREFIX))
                     scopes.add(s);
         }
@@ -31,6 +31,7 @@ export function createOrgMemoryAdmissionWiring(opts) {
                 fetchSection: (principal) => fetchPrincipalOrgMemory({ baseUrl: centerLeg.baseUrl, credential }, principal, fetch, centerLeg.worker),
                 grantTtlMs: config.memoryOrgGrantTtlMs,
                 unavailableBackoffMs: config.memoryOrgUnavailableBackoffMs,
+                logger,
             })).now;
             return { lookup: (principal) => directoryNow().lookup(principal) };
         })()
@@ -44,7 +45,7 @@ export function createOrgMemoryAdmissionWiring(opts) {
     const memoryPlaneLive = config.memoryEngineEnabled && config.memoryEngineBackend !== "file";
     if (directory === undefined && config.requirePrincipal === true && memoryPlaneLive) {
         const orgProjects = Object.entries(config.projects)
-            .filter(([, p]) => (p.defaultScopes ?? []).some((s) => s.startsWith(ORG_PREFIX)))
+            .filter(([, p]) => p.defaultScopes.some((s) => s.startsWith(ORG_PREFIX)))
             .map(([id]) => id);
         if (orgProjects.length > 0) {
             throw new Error(`multi-tenant deployment has org: keys in projects[${orgProjects.join(", ")}].defaultScopes but NO org-memory directory source ` +

package/dist/boot/parked-revive-gate.d.ts

@@ -6,7 +6,7 @@ import { type SandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
 import type { ApprovalExemptionStore } from "../plugins/approval-exemption-store.js";
 /** 本腿读的配置切面(`ServiceConfig` 结构满足)。两个构造口各自的切面 + lane 判别式读的 `remoteExec`。 */
 export interface ParkedReviveGateConfigView extends DeploymentGovernanceConfigView, ApprovalBaselineConfigView {
-    readonly remoteExec?: ServiceConfig["remoteExec"];
+    readonly remoteExec: ServiceConfig["remoteExec"];
     /** [ref]④:`executionLaneHomeDir` 读的运维声明(切面必须点名本腿消费的每一个字段,否则窄视图字面量会静默丢掉旋钮)。 */
     readonly remoteExecHomeDir?: ServiceConfig["remoteExecHomeDir"];
     /** host 腿裁决 env 的 cwd 占位根(见下方 `hostGateCwd`)。 */

package/dist/boot/parked-revive-gate.js

@@ -24,7 +24,7 @@ export function createParkedReviveInheritedGate(deps) {
                 env: new DeferredSandboxPathEnv({
                     sessionId: row.sessionId,
                     slots,
-                    logger: { warn: (event, fields) => logger.warn(event, { ...(fields ?? {}), lane: config.remoteExec?.provider, leg: "parked_revive" }) },
+                    logger: { warn: (event, fields) => logger.warn(event, { ...(fields ?? {}), lane: config.remoteExec.provider, leg: "parked_revive" }) },
                 }),
                 ...homeBase,
             }

package/dist/boot/reapers.d.ts

@@ -22,7 +22,8 @@ import type { Metrics } from "../observability/metrics.js";
 import type { WorkflowNotifyGate, WorkflowNotifyJournalStore } from "../orchestration/workflow-notify-journal.js";
 import type { TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { FileHistoryErasureFace } from "../file-history-capture.js";
-import type { ApprovalNonceStore, CheckpointStoreFull, CostQuotaStore, ImageBake, RateLimiterStore, ServiceWorkflowJournalStore, StoreBackend, ToolResultStoreFull } from "../plugins/store-backend.js";
+import type { ApprovalNonceStore, CheckpointStoreFull, CostQuotaStore, ImageBake, RateLimiterStore, StoreBackend } from "../plugins/store-backend.js";
+import { type StoreSweep, type StoreSweepLeg } from "../plugins/store-sweep.js";
 import type { ToolApprovalCoordinator } from "../tool-approval.js";
 import type { ParkCommitWatch } from "../plugins/park-commit-watch.js";
 import { type SandboxPodReaper } from "../plugins/k8s-pod-reaper.js";
@@ -56,6 +57,14 @@ export interface ThrottledReaperCatch {
  * survives across ticks — a fresh instance per tick would never accumulate past 1.
  */
 export declare function createThrottledReaperCatch(name: string, logger: Logger, threshold?: number): ThrottledReaperCatch;
+/**
+ * 维护 tick 里调后端按龄清扫动词的那一拍。逐腿上报:失败腿的原因只进那条腿的节流告警;成功腿先计数、再清连败(计数抛也记那条腿的失败)。
+ * 动词整只拒(不是 {@link StoreSweepError} 的逐腿形)⇒ 每条腿各记一次失败。永不拒(本拍的失败全由节流告警接住)。
+ */
+export declare function runStoreSweepLeg(sweep: StoreSweep, nowMs: number, report: {
+    readonly guards: Readonly<Record<StoreSweepLeg, ThrottledReaperCatch>>;
+    readonly counted: (leg: StoreSweepLeg, removed: number) => void;
+}): Promise<void>;
 /** [ref] —— 维护 tick 真正消费的那**一手**(窄口;理由见 `ReapersCtx.permissionRuleStores`)。
  *  可选成员:File 车道没有这一面(追加日志的压实是另一件事,如实登记在 `rules-consent.ts` 的
  *  `PermissionRuleStoreBundle.reapExpired` 注里),缺席 ⇒ 本腿零调用。 */
@@ -75,7 +84,8 @@ export interface ReapersCtx {
     parkCommits: ParkCommitWatch | undefined;
     rateLimiter: RateLimiter | RateLimiterStore | undefined;
     costQuota: CostQuota | CostQuotaStore | undefined;
-    toolResultStore: ToolResultStoreFull | undefined;
+    /** 本后端的按龄清扫动词(`plugins/store-sweep.ts`;腿 = 工具结果 / 名册,组合点 `boot/stores.ts`,界每次清扫现读)。tick 只调它,不逐店探按龄删的方法。 */
+    storeSweep: StoreSweep;
     /** [ref]:文件历史的**擦除脸**(后端在即在,与 `FILE_HISTORY_CAPTURE` 无关)—— 本段只用它的孤儿 blob GC。 */
     fileHistoryErasure: FileHistoryErasureFace | undefined;
     taskAttachmentStore: TaskAttachmentStore | undefined;
@@ -84,10 +94,8 @@ export interface ReapersCtx {
     workflowNotifyGate: WorkflowNotifyGate | undefined;
     /** [ref]/[ref] recover 的两半 opts(boot 与周期扫描共用,单点合成在 workflow-orchestration)。 */
     workflowRecoverOpts: Parameters<WorkflowNotifyGate["recover"]>[0];
-    workflowJournalStore: ServiceWorkflowJournalStore | undefined;
     sqlWorkflowRunStore: WorkflowRunStore | undefined;
     workflowNotifyJournal: WorkflowNotifyJournalStore | undefined;
-    rosterStore: RunnerDeps["rosterStore"];
     backgroundAgentStore: RunnerDeps["backgroundAgentStore"];
     mailboxStore: RunnerDeps["mailboxStore"];
     /** [ref] 车6:流内审批撤卡帧的投递口(收敛器/孤儿代打腿产出的帧经它反查 broker 的活连接;[ref] 起

package/dist/boot/reapers.js

@@ -1,6 +1,7 @@
 import { Runner, defaultTaskRegistry } from "@sema-agent/core";
 import { sweepStaleScratchpads } from "../env-facts.js";
 import { CostQuota } from "../observability/cost-quota.js";
+import { STORE_SWEEP_LEGS, StoreSweepError } from "../plugins/store-sweep.js";
 import { isAdoptionQuiescing, trackMaintenanceLeg } from "../adoption/quiesce.js";
 import { createApprovalReconciler } from "../approval-reconciler.js";
 import { createE2bOrphanSandboxProvider, reclaimOrphanE2bSandboxes, E2B_ORPHAN_GRACE_MS } from "../plugins/e2b-orphan-reclaim.js";
@@ -33,6 +34,32 @@ export function createThrottledReaperCatch(name, logger, threshold = REAPER_FAIL
         },
     };
 }
+export function runStoreSweepLeg(sweep, nowMs, report) {
+    const settle = (receipt, failed) => {
+        for (const leg of STORE_SWEEP_LEGS) {
+            if (failed.has(leg)) {
+                report.guards[leg].onError(failed.get(leg));
+                continue;
+            }
+            try {
+                report.counted(leg, receipt[leg]);
+                report.guards[leg].onSuccess();
+            }
+            catch (err) {
+                report.guards[leg].onError(err);
+            }
+        }
+    };
+    return Promise.resolve()
+        .then(() => sweep.sweep({ nowMs }))
+        .then((receipt) => settle(receipt, new Map()), (err) => {
+        if (err instanceof StoreSweepError)
+            settle(err.receipt, err.failed);
+        else
+            for (const leg of STORE_SWEEP_LEGS)
+                report.guards[leg].onError(err);
+    });
+}
 export function createPlacementAwareReapSessions(deps) {
     const { host, routed } = deps;
     const listPlaced = typeof host?.listPlaced === "function" ? host.listPlaced.bind(host) : undefined;
@@ -59,7 +86,7 @@ export function createPlacementAwareReapSessions(deps) {
     };
 }
 export function startReapers(ctx) {
-    const { config, logger, metrics, localRoot, backend, subRunner, runStore, checkpointStore, parkCommits, rateLimiter, costQuota, toolResultStore, fileHistoryErasure, taskAttachmentStore, imageBakes, worktreeReap, workflowNotifyGate, workflowRecoverOpts, workflowJournalStore, sqlWorkflowRunStore, workflowNotifyJournal, rosterStore, backgroundAgentStore, mailboxStore, toolApproval, permissionRuleStores, approvalNonceStore, getRunDenySweep, userInputLedger, approvalAskAudit, sandboxPodReaper, } = ctx;
+    const { config, logger, metrics, localRoot, backend, subRunner, runStore, checkpointStore, parkCommits, rateLimiter, costQuota, storeSweep, fileHistoryErasure, taskAttachmentStore, imageBakes, worktreeReap, workflowNotifyGate, workflowRecoverOpts, sqlWorkflowRunStore, workflowNotifyJournal, backgroundAgentStore, mailboxStore, toolApproval, permissionRuleStores, approvalNonceStore, getRunDenySweep, userInputLedger, approvalAskAudit, sandboxPodReaper, } = ctx;
     const leg = (p) => {
         if (p !== undefined)
             trackMaintenanceLeg(p);
@@ -70,7 +97,7 @@ export function startReapers(ctx) {
             logger.info("reaper_swept", { metric, ...labels, count: n });
         }
     };
-    const e2bOrphanProvider = config.remoteExec?.provider === "e2b" && config.remoteExec.orphanReclaim !== false
+    const e2bOrphanProvider = config.remoteExec.provider === "e2b" && config.remoteExec.orphanReclaim !== false
         ? createE2bOrphanSandboxProvider({ apiKey: config.remoteExec.apiKey })
         : undefined;
     let e2bOrphanLastRunMs = Date.now() - E2B_ORPHAN_GRACE_MS;
@@ -91,7 +118,16 @@ export function startReapers(ctx) {
     const runDenySweepGuard = createThrottledReaperCatch("run_deny_sweep", logger);
     const runsReapSuspendedGuard = createThrottledReaperCatch("runs_reap_suspended", logger);
     const checkpointReapCtxGuard = createThrottledReaperCatch("checkpoint_reap_ctx", logger);
-    const toolResultReapGuard = createThrottledReaperCatch("tool_result_reap", logger);
+    const storeSweepGuards = {
+        "roster-aged": createThrottledReaperCatch("roster_reap_older_than", logger),
+        "tool-results-aged": createThrottledReaperCatch("tool_result_reap", logger),
+        "workflow-journal-expired": createThrottledReaperCatch("workflow_journal_reap_expired", logger),
+    };
+    const storeSweepCount = {
+        "roster-aged": reapCount("roster_rows_reaped_total", {}),
+        "tool-results-aged": undefined,
+        "workflow-journal-expired": undefined,
+    };
     const fileHistorySweepOrphanBlobsGuard = createThrottledReaperCatch("file_history_sweep_orphan_blobs", logger);
     const legacySnapshotBlobSweepGuard = createThrottledReaperCatch("legacy_snapshot_blob_sweep", logger);
     const attachmentReapUnboundGuard = createThrottledReaperCatch("attachment_reap_unbound", logger);
@@ -99,11 +135,9 @@ export function startReapers(ctx) {
     const imageBakesReapStaleGuard = createThrottledReaperCatch("image_bakes_reap_stale", logger);
     const worktreeReapGuard = createThrottledReaperCatch("worktree_reap", logger);
     const workflowNotifyRecoverGuard = createThrottledReaperCatch("workflow_notify_recover", logger);
-    const workflowJournalReapExpiredGuard = createThrottledReaperCatch("workflow_journal_reap_expired", logger);
     const workflowRunReapAllScopesGuard = createThrottledReaperCatch("workflow_run_reap_all_scopes", logger);
     const workflowNotifyJournalReapAckedGuard = createThrottledReaperCatch("workflow_notify_journal_reap_acked", logger);
     const bgAgentsReapGuard = createThrottledReaperCatch("bg_agents_reap", logger);
-    const rosterReapOlderThanGuard = createThrottledReaperCatch("roster_reap_older_than", logger);
     const leaderRunStaleGuard = createThrottledReaperCatch("leader_run_reap_stale", logger);
     const leaderRunStore = config.leaderEnabled ? backend?.leaderRun?.() : undefined;
     const scratchpadSweepStaleGuard = createThrottledReaperCatch("scratchpad_sweep_stale", logger);
@@ -244,10 +278,7 @@ export function startReapers(ctx) {
         rateLimiter?.sweep();
         if (costQuota instanceof CostQuota)
             costQuota.reap();
-        const reapToolResults = toolResultStore?.reap?.bind(toolResultStore);
-        leg(reapToolResults && Promise.resolve()
-            .then(() => reapToolResults(Date.now(), { maxAgeMs: config.toolResultTtlSec * 1000 }))
-            .then(() => toolResultReapGuard.onSuccess(), toolResultReapGuard.onError));
+        leg(runStoreSweepLeg(storeSweep, Date.now(), { guards: storeSweepGuards, counted: (l, n) => storeSweepCount[l]?.(n) }));
         leg(fileHistoryErasure
             ?.sweepOrphanBlobs?.()
             .then(() => fileHistorySweepOrphanBlobsGuard.onSuccess(), fileHistorySweepOrphanBlobsGuard.onError));
@@ -290,9 +321,6 @@ export function startReapers(ctx) {
         leg(workflowNotifyGate
             ?.recover(workflowRecoverOpts)
             .then(() => workflowNotifyRecoverGuard.onSuccess(), workflowNotifyRecoverGuard.onError));
-        leg(workflowJournalStore
-            ?.reapExpired?.(Date.now(), config.workflowJournalRetentionMs)
-            .then(() => workflowJournalReapExpiredGuard.onSuccess(), workflowJournalReapExpiredGuard.onError));
         if (!wfRunReapInFlight) {
             const sweep = sqlWorkflowRunStore?.reapAllScopes?.(Date.now(), { maxAgeMs: config.workflowRunRetentionMs });
             if (sweep) {
@@ -311,10 +339,6 @@ export function startReapers(ctx) {
                 .then(() => bgAgentsReapGuard.onSuccess(), bgAgentsReapGuard.onError)
                 .finally(() => (bgAgentReapInFlight = false)));
         }
-        leg(rosterStore
-            ?.reapOlderThan?.(Date.now() - config.rosterRetentionMs)
-            .then(reapCount("roster_rows_reaped_total", {}))
-            .then(() => rosterReapOlderThanGuard.onSuccess(), rosterReapOlderThanGuard.onError));
         leg(leaderRunStore
             ?.reapStaleRunning(config.leaderRunStaleMs, Date.now())
             .then(reapCount("leader_runs_stale_reaped_total", {}))

package/dist/boot/resolve-spec.d.ts

@@ -41,6 +41,8 @@ export interface ResolveSpecCtx {
     fenceSessionOwner: (sid: string, owner: string | null) => void;
     hookLlm: ReturnType<typeof createHookLlm>["hookLlm"];
     hookAgent: HookLlmCall;
+    /** 部署座在任务座之下挂了链成员的站点式样(第 5 段装配口从引擎准入记录读出,`boot/deployment-mods.ts` 的 `belowTaskChainPatternsOf`)—— 原样交 hooks 注册上下文(托管车道在这些站上只许收紧)。 */
+    belowTaskChainPatterns: readonly string[];
     fleetBus: FleetEventBus;
     hookWakeBus: {
         deliver?: (sessionId: string, text: string) => Promise<boolean>;