@sema-agent/server 7.144.0 → 7.146.0

package/dist/boot/exit-boundary.js

@@ -4,6 +4,21 @@ import { liveHostForegroundChildCount, reapHostForegroundChildren } from "../plu
 import { liveEphemeralHostWorkspaceCount, reapEphemeralHostWorkspaces } from "../plugins/host-workspace-registry.js";
 import { seatText } from "../trace/exit-seat.js";
 const PROCESS_EXIT_INCLUDES_RETAINED = false;
+export function countShellsExitWouldKill(opts) {
+    const registry = opts.registry ?? defaultTaskRegistry;
+    try {
+        return registry.countRunningBackgroundShells({ includeRetained: PROCESS_EXIT_INCLUDES_RETAINED });
+    }
+    catch (err) {
+        try {
+            opts.onUnreadable(err);
+        }
+        catch (reportErr) {
+            console.error("engine_handover_shell_count_report_threw", reportErr);
+        }
+        return 1;
+    }
+}
 export function installProcessExitBoundary({ logger }) {
     const reapOwnChildProcesses = () => {
         let backgroundSoftStopped = 0;
@@ -81,8 +96,25 @@ export function installProcessExitBoundary({ logger }) {
     };
     process.once("exit", onProcessExit);
     let disposed = false;
+    let shellCountUnreadableReported = false;
+    const shellsExitWouldKill = () => countShellsExitWouldKill({
+        onUnreadable: (err) => {
+            if (shellCountUnreadableReported)
+                return;
+            shellCountUnreadableReported = true;
+            let text;
+            try {
+                text = String(err);
+            }
+            catch {
+                text = Object.prototype.toString.call(err);
+            }
+            logger.warn("engine_handover_shell_count_unreadable", { counted: 1, err: seatText("operator-log-text", text) });
+        },
+    });
     return {
         reapChildProcessesEarly: reapOwnChildProcesses,
+        shellsExitWouldKill,
         dispose: () => {
             if (disposed)
                 return;

package/dist/boot/exit-last.d.ts

@@ -1,10 +1,18 @@
 import { z } from "zod";
+/** 本构建写的格式号([ref] 抬到 2;[ref] 抬到 3:必填 `lane`,退 `orphan` / `firstAttachWindowExpired`)。格式 1 = 无 `format` 键的旧形。 */
+export declare const EXIT_LAST_FORMAT = 3;
 /** 读回 schema(宪法 [ref] §2:边界读一律 safeParse,不裸铸)。写侧同形。 */
 declare const ExitLastSchema: z.ZodObject<{
+    format: z.ZodLiteral<3>;
     at: z.ZodString;
     version: z.ZodString;
     pid: z.ZodNumber;
-    orphan: z.ZodBoolean;
+    lane: z.ZodEnum<{
+        orphan: "orphan";
+        handover: "handover";
+        awaitingFirstAttach: "awaitingFirstAttach";
+        owned: "owned";
+    }>;
     reason: z.ZodString;
     idleForMs: z.ZodNumber;
     attached: z.ZodNumber;
@@ -15,9 +23,17 @@ declare const ExitLastSchema: z.ZodObject<{
 export type ExitLastInfo = z.infer<typeof ExitLastSchema>;
 export declare function exitLastPath(dataRoot: string): string;
 /** 自退那一刻写留痕(同步;自身绝不抛 —— 留痕写失败不得阻塞停机)。 */
-export declare function writeExitLast(dataRoot: string, info: Omit<ExitLastInfo, "at" | "pid">): void;
-/** boot 读回:在场读回、缺席/坏字节/坏形回 `undefined`(绝不抛 —— 留痕坏了不能挡启动)。 */
-export declare function readExitLast(dataRoot: string): ExitLastInfo | undefined;
+export declare function writeExitLast(dataRoot: string, info: Omit<ExitLastInfo, "format" | "at" | "pid">): void;
+/** {@link readExitLast} 的读数:本构建格式读成了 ⇒ `found`;文件格式号不是 {@link EXIT_LAST_FORMAT} ⇒ `formatMismatch`(契约 6)。 */
+export type ExitLastReading = {
+    readonly kind: "found";
+    readonly info: ExitLastInfo;
+} | {
+    readonly kind: "formatMismatch";
+    readonly fileFormat: number;
+};
+/** boot 读回:本构建格式读回 `found`、别的格式号回 `formatMismatch`;缺席/坏字节/本格式坏形回 `undefined`(绝不抛 —— 留痕坏了不能挡启动)。 */
+export declare function readExitLast(dataRoot: string): ExitLastReading | undefined;
 /** 读回并报过之后即清(幂等,缺席零抛):在场 ⇔ **上一次**退出是自退。 */
 export declare function clearExitLast(dataRoot: string): void;
 export {};

package/dist/boot/exit-last.js

@@ -1,11 +1,14 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
+import { ENGINE_LANES } from "./engine-lease.js";
+export const EXIT_LAST_FORMAT = 3;
 const ExitLastSchema = z.object({
+    format: z.literal(EXIT_LAST_FORMAT),
     at: z.string(),
     version: z.string(),
     pid: z.number(),
-    orphan: z.boolean(),
+    lane: z.enum(ENGINE_LANES),
     reason: z.string(),
     idleForMs: z.number(),
     attached: z.number(),
@@ -18,19 +21,33 @@ export function exitLastPath(dataRoot) {
 }
 export function writeExitLast(dataRoot, info) {
     try {
-        const body = { at: new Date().toISOString(), pid: process.pid, ...info };
+        const body = { format: EXIT_LAST_FORMAT, at: new Date().toISOString(), pid: process.pid, ...info };
         writeFileSync(exitLastPath(dataRoot), JSON.stringify(body) + "\n");
     }
     catch {
     }
 }
+function fileFormatOf(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return undefined;
+    if (!Object.hasOwn(raw, "format"))
+        return 1;
+    const f = raw.format;
+    return typeof f === "number" && Number.isSafeInteger(f) ? f : undefined;
+}
 export function readExitLast(dataRoot) {
     try {
         const p = exitLastPath(dataRoot);
         if (!existsSync(p))
             return undefined;
-        const parsed = ExitLastSchema.safeParse(JSON.parse(readFileSync(p, "utf8")));
-        return parsed.success ? parsed.data : undefined;
+        const raw = JSON.parse(readFileSync(p, "utf8"));
+        const fileFormat = fileFormatOf(raw);
+        if (fileFormat === undefined)
+            return undefined;
+        if (fileFormat !== EXIT_LAST_FORMAT)
+            return { kind: "formatMismatch", fileFormat };
+        const parsed = ExitLastSchema.safeParse(raw);
+        return parsed.success ? { kind: "found", info: parsed.data } : undefined;
     }
     catch {
         return undefined;

package/dist/boot/governance-seams.js

@@ -54,6 +54,7 @@ const DENY_CONFLICTS = {
     },
     workflows: null,
     org_memory_mount: null,
+    memory_consolidation: null,
 };
 function resolveGovernanceDeclarations(config) {
     return {

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 的解析器,本仓不持第二份。
@@ -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;
 }
 /**
@@ -459,8 +467,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 +514,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,12 @@
 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 +97,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 +112,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 +139,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 +203,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;
@@ -363,6 +373,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 +384,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/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);
@@ -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>;