@sema-agent/server 7.59.0 → 7.60.0

package/README.md

@@ -30,7 +30,10 @@ model gateways, and cloud agent execution behind an HTTP/SSE contract.
 - **Stateless by design.** Replicas are cattle: `docker run` starts one, start as many as you need
   behind a load balancer. Durable state — sessions, runs, replayable event logs, checkpoints,
   approvals — lives in an external SQL store (any MySQL-protocol database such as MySQL/TiDB/MariaDB,
-  or PostgreSQL; a file-backed `local` mode covers single-machine use). Any replica can serve any
+  or PostgreSQL; a file-backed `local` mode covers single-machine use). Each pooled connection pins its
+  own session isolation (`REPEATABLE READ` on the MySQL-protocol leg, `READ COMMITTED` on PostgreSQL) and
+  verifies it by reading back; on TiDB the session is switched to pessimistic transaction mode, and boot is
+  refused only when that switch cannot be made or verified — see docs/DEPLOY-PREREQS.md. Any replica can serve any
   run's event stream; a task can suspend on one replica and resume on another.
 - **The full server-side capability surface** (discoverable at `GET /v1/capabilities`):
   asynchronous runs with replayable SSE, durable checkpoints with human-in-the-loop approvals,

package/README.zh-CN.md

@@ -29,7 +29,7 @@
   不进请求体、不进模型、不进沙箱。
 - **无状态设计。** 副本是 cattle:`docker run` 即起一个,挂在负载均衡后想开多少开多少。
   持久化状态 —— 会话、run、可重放事件日志、检查点、审批 —— 全在外部 SQL 存储
-  (任何 MySQL 协议数据库:MySQL/TiDB/MariaDB,或 PostgreSQL;单机场景另有文件持久化的
+  (任何 MySQL 协议数据库:MySQL/TiDB/MariaDB,或 PostgreSQL;每条池连接自钉会话隔离级(MySQL 协议腿 `REPEATABLE READ`、PostgreSQL `READ COMMITTED`)并回读复核,TiDB 上会话切到悲观事务模式、切不成或复核不符才拒启,见 docs/DEPLOY-PREREQS.md;单机场景另有文件持久化的
   `local` 模式)。任意副本都能服务任意 run 的事件流;任务可以在一个副本上挂起、在另一个副本上恢复。
 - **完整的服务端能力面**(可在 `GET /v1/capabilities` 发现):
   异步 run + 可重放 SSE、持久化检查点 + 人工审批(HITL)、会话与长期记忆、

package/USAGE.md

@@ -29,7 +29,14 @@ docker compose up --build
 # 起来后 OA 只认 http://<host>:8090(LB)
 ```
 
-**生产(N worker 集群,需 MySQL 协议库——MySQL/TiDB 均可;支持异步 `/v1/runs` + 断线重连)**
+**生产(N worker 集群,需 MySQL 协议库——MySQL(≥8.0)/ MariaDB(≥10.5)/ TiDB 均可;支持异步 `/v1/runs` + 断线重连)**
+
+> 🔒 7.60.0 起本仓在**每条池连接**上把会话隔离级钉死并**回读复核**:MySQL 协议腿 `REPEATABLE READ`
+> + TiDB 悲观事务模式(设不上就拒启),PG 腿 `READ COMMITTED`(同样是设了再验,不问服务器缺省 ——
+> 把 PG 钉成 RR 或让部署把默认配成 RR/SERIALIZABLE,都会让每条 `FOR UPDATE` 变成 `40001`)。本仓所有
+> `SELECT … FOR UPDATE` 的单赢家判据都以此为前提。运维读面:
+> `GET /v1/diagnostics/wiring` 的 `sqlEngine` 段与 `GET /v1/capabilities` 的 `sql` 位。判据与升级句见
+> `docs/DEPLOY-PREREQS.md`「事务读语义的结构保证」。
 ```bash
 IMAGE_REGISTRY=<registry-namespace> \
 DB_BACKEND=mysql MYSQL_HOST=… MYSQL_USER=… MYSQL_PASSWORD=… MYSQL_DATABASE=sema_server \

package/dist/boot/stores.d.ts

@@ -31,5 +31,6 @@ export declare function openStores(ctx: OpenStoresCtx): Promise<{
     usageWindowStore: import("@sema-agent/core").UsageWindowStore | undefined;
     memoryPosture: import("../memory-posture.js").MemoryPosture;
     taskListLane: import("./task-list-lane.js").TaskListLane;
+    sqlEngineFacts: (() => import("../plugins/sql-driver.js").SqlEngineFacts | null) | undefined;
 }>;
 //# sourceMappingURL=stores.d.ts.map

package/dist/boot/stores.js

@@ -29,6 +29,7 @@ import { assertFileHistorySchema } from "../plugins/file-history-store-sql.js";
 import { resolveStreamApprovalGate } from "../tool-approval.js";
 import { buildMemoryWriteBoundaryAudit, effectiveMemoryPersistenceCapable } from "./memory-boundary.js";
 import { buildMemoryPosture } from "../memory-posture.js";
+import { establishSqlEnginePosture } from "../sql-engine-posture.js";
 const DARK_REASON_PROSE = {
     engine_off: () => "MEMORY_ENGINE=off",
     multi_tenant_file_backend: () => "multi-tenant on the FILE backend (no tenant isolation; set MEMORY_ENGINE_BACKEND=pg|tidb to light up)",
@@ -387,9 +388,11 @@ export async function openStores(ctx) {
             await ensureTiDBTaskListSchema(mysqlPool);
         return createTaskListLane({ mysqlPool, pgPool, logger });
     })();
+    let sqlEngineFacts;
     {
         const mysqlPool = backend?.mysqlPool?.();
         const pgPool = backend?.pgPool?.();
+        sqlEngineFacts = await establishSqlEnginePosture({ mysqlPool, pgPool });
         if (pgPool)
             await ensurePgDeviceSchema(async (text, params) => pgPool.query(text, params));
         if (mysqlPool)
@@ -433,7 +436,7 @@ export async function openStores(ctx) {
     return {
         backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore,
         taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState,
-        usageWindowStore, memoryPosture, taskListLane,
+        usageWindowStore, memoryPosture, taskListLane, sqlEngineFacts,
     };
 }
 //# sourceMappingURL=stores.js.map

package/dist/http/routes/approvals-assistant.js

@@ -177,6 +177,9 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
                     ...(s.spentMicroUsd !== undefined ? { spentMicroUsd: s.spentMicroUsd } : {}),
                     ...(s.deadline !== undefined ? { deadline: s.deadline } : {}),
                     ...(s.hasBidiControls === true ? { hasBidiControls: true } : {}),
+                    ...(s.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
+                    ...(s.denialLimitFallback !== undefined ? { denialLimitFallback: s.denialLimitFallback } : {}),
+                    ...(s.origin !== undefined ? { origin: s.origin } : {}),
                     objective: ctx?.body?.objective ?? null,
                     input,
                 };

package/dist/http/routes/capabilities.js

@@ -9,6 +9,7 @@ import { mcpInjectionHonored } from "../../task-mcp.js";
 import { sendJson, sendError } from "../send.js";
 import { resolveStreamApprovalGate } from "../../tool-approval.js";
 import { projectMemoryEngineCapability } from "../../memory-posture.js";
+import { projectSqlEngineCapability } from "../../sql-engine-posture.js";
 import { workflowModelAllowlistFor, selfOrchestrationDenial } from "../../task-workflow.js";
 import { centerEntitlementSourceWired } from "../../runtime-caps-resolver.js";
 import { judgeAutoModeArming } from "../../auto-mode-face.js";
@@ -76,6 +77,7 @@ async function handleCapabilitiesBody(req, res, url, ctx, miss) {
             memory: false,
             memoryWrite: false,
             memoryEngine: projectMemoryEngineCapability(deps.memoryPosture),
+            sql: projectSqlEngineCapability(deps.sqlEngineFacts?.()),
             sessionBackgroundable: Boolean(deps.runStore),
             runMemoryCaptureOptOut: Boolean(deps.runStore),
             sharedMemory: Boolean(deps.sharedMemoryStore && deps.orgMemoryDirectory),

package/dist/http/routes/diagnostics.js

@@ -86,6 +86,7 @@ async function handleDiagnosticsBody(req, res, url, ctx, miss) {
         sendJson(res, 200, {
             static: deps.staticWiring,
             memoryPosture: deps.memoryPosture ?? null,
+            sqlEngine: deps.sqlEngineFacts?.() ?? null,
             configApply: deps.configApplyState?.() ?? null,
             mcpRevocations: deps.mcpRevocationState?.() ?? null,
             serverGates: buildServerWiringGates({

package/dist/http/server.d.ts

@@ -654,6 +654,12 @@ export interface ServiceDeploymentDeps {
      *  `GET /v1/capabilities` 的 `memoryEngine` 位(窄投影)。缺席 = 这个进程不是由 composition root 装
      *  起来的(测试夹具形)⇒ 诊断面报 null、能力位取诚实下限 false。 */
     memoryPosture?: import("../memory-posture.js").MemoryPosture;
+    /** S-131:SQL 引擎姿态的 **live getter**(`sql-engine-posture.ts` 的单一推导点 —— boot 期借一条池连接
+     *  触发驱动的连接初始化,读的是 `SET` 之后**回读复核**过的真值)。两个读面共用:
+     *  `GET /v1/diagnostics/wiring` 的 `sqlEngine` 段(operator-only,全量含版本)与 `GET /v1/capabilities`
+     *  的 `sql` 位(窄投影)。getter 而不是快照:池重连后驱动会重新初始化并刷新事实,快照会说谎。
+     *  缺席 / 返回 null = 本部署没有 SQL 后端(env-only worker、local 文件后端)—— 诚实缺席,不铸空壳。 */
+    sqlEngineFacts?: () => import("../plugins/sql-driver.js").SqlEngineFacts | null;
     /** ① core ruling — SPLIT: `capabilities.workflows` = the ENGINE-CAN axis, boot-computed from core's own
      *  `workflowsCapability(deps)` (hardened script runner ∧ governance), NOT the `Boolean(workflowRunStore)` store
      *  proxy. Orthogonal to `workflowsList` (the durable-list axis = `workflowRunStore`). Falls back to the store

package/dist/main.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { Runner, InMemoryToolResultStore, TtlSessionStore, uuidv7, defaultTaskRegistry, createAllowDenyPolicy, workflowsCapability, probeSearchBackend, describeStaticWiring, expandTiers, DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
+import { Runner, createPermissionRuleStoreProvider, InMemoryToolResultStore, TtlSessionStore, uuidv7, defaultTaskRegistry, createAllowDenyPolicy, workflowsCapability, probeSearchBackend, describeStaticWiring, expandTiers, DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
 import { createSessionTitler } from "./session-titler.js";
 import { posIntEnv } from "./session-watch.js";
 import { selectEnvironmentTool } from "./capabilities/select-environment-tool.js";
@@ -128,7 +128,7 @@ async function main() {
     }
     const configCenter = await createConfigCenterRuntime({ config, logger, metrics, localRoot });
     await configCenter.applyLocalRemoteExec();
-    const { backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, } = await openStores({ config, logger, metrics, localRoot });
+    const { backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngineFacts, } = await openStores({ config, logger, metrics, localRoot });
     const instanceId = uuidv7();
     const sessionCaptureRecordStore = backend?.sessionCaptureRecords();
     const memoryBundleFaces = memoryEngine ? createMemoryBundleFaces(memoryEngine, { ...(sessionCaptureRecordStore !== undefined ? { captureRecordStore: sessionCaptureRecordStore } : {}) }) : undefined;
@@ -153,7 +153,12 @@ async function main() {
     }
     const { brain, pricing, counterDegradeHook, costQuota, modelUsageTracker, promptManifestTracker, fleetUsage, fleetLease, tracer, sideQueryAccounting, toolResultStore, sessionPolicyStore, fileHistoryStore, } = createBudgetAndTracing({ config, logger, metrics, backend, breakerState });
     const permissionRuleStores = config.permissionRulesEnabled && backend ? backend.permissionRule() : undefined;
-    const ruleConsent = permissionRuleStores ? createRuleConsentLane(permissionRuleStores) : undefined;
+    const permissionRuleProvider = permissionRuleStores
+        ? createPermissionRuleStoreProvider({ durable: permissionRuleStores.durable })
+        : undefined;
+    const ruleConsent = permissionRuleStores && permissionRuleProvider
+        ? createRuleConsentLane({ ...permissionRuleStores, provider: permissionRuleProvider })
+        : undefined;
     if (config.permissionRulesEnabled && permissionRuleStores === undefined) {
         logger.info("permission_rules_lane_unavailable", {
             knob: "PERMISSION_RULES_ENABLED",
@@ -268,7 +273,7 @@ async function main() {
         sessionCaptureRecordStore,
         memorySyncRunner, toolResultStore: runnerOffloadStore, sessionPolicyStore, runtimeCapsResolver, fileHistoryStore,
         legacyRewindBoundaryProbe: backend?.legacyRewindBoundaryProbe ? backend.legacyRewindBoundaryProbe.bind(backend) : undefined,
-        permissionRuleStore: permissionRuleStores?.provider,
+        permissionRuleStore: permissionRuleProvider,
         executionEnvFactory, lspManager, fleetBus, deploymentHooks, workflowRunStore, workflowJournalStore,
         workflowAgentRegistry, workflowNotifyGate, workflowCompletionInbox, deliverWorkflowCompletion, orgMemoryAdmission,
         governanceSeams,
@@ -695,6 +700,7 @@ async function main() {
         workflowModelAllowlist: workflowModelAllowlistSnapshot,
         staticWiring,
         memoryPosture,
+        sqlEngineFacts,
         instanceId,
         capabilities: {
             version: serviceVersion(),

package/dist/plugins/approval-ask-store-sql.d.ts

@@ -14,10 +14,10 @@
  *    (`rev = rev + 1`),这样只要「行在且谓词命中」就必然 affected=1,不会被这个驱动怪癖
  *    误判成「CAS 输了」。本文件每一条 CAS UPDATE 都带 `rev = rev + 1`。
  * 3. 事务:走 `SqlDriver.connect()` → `conn.begin()` → 一串 `conn.query()` → `conn.commit()`,失败
- *    `conn.rollback()`(形照 image-bake-store-sql.ts 的 try/catch/finally 骨架)。本店没有 image-bake
- *    那种「NOT EXISTS 快照读」问题(每条 CAS 都是对已存在主键行的 `UPDATE … WHERE state=?`,MySQL/TiDB
- *    对被更新行本身恒是 current read,不受 REPEATABLE READ 快照影响),所以走普通 `begin()`,不需要
- *    `beginPessimistic()`。
+ *    `conn.rollback()`(形照 image-bake-store-sql.ts 的 try/catch/finally 骨架)。事务动词只有一个;
+ *    读语义(隔离级 / TiDB 悲观模式 / 事务内集合读必须锁读)的判据只有一处:{@link SqlTxConn.begin}
+ *    的 `@contract txn.read-semantics`。本店每条 CAS 都是对已存在主键行的 `UPDATE … WHERE state=?`
+ *    (DML 对被更新行恒是 current read,与快照无关),败方读数则一律 `SELECT … FOR UPDATE`。
  *
  * ── 方言差异(显式写在每个调用点,[ref] A12 doctrine)──────────────────────────────────────────
  *   - `?` 占位符(位置序)vs `$n`(显式编号)——动态列清单(`transitionAsk`/`resolveProvisional`,列集合
@@ -503,11 +503,11 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
      * 取消臂的 STREAM_PENDING→VOID(此前走通用 `transitionAsk`,无败方读数)。
      *
      * **原子性证明(两方言各一句,红先钉在 db-integration 的 [ref] 组)**:
-     *  · 败方读数是**同一事务内**的 `SELECT … FOR UPDATE` —— TiDB 侧本事务显式 `BEGIN PESSIMISTIC`
-     *    (`beginPessimistic()`,不赌部署的 `tidb_txn_mode` 缺省):悲观锁定读是 CURRENT read,读到的是
-     *    并发赢家**已提交**的最新版本(乐观模式下 FOR UPDATE 读 start_ts 快照,会把赢家终局读旧 ——
-     *    正是 bindBatch 失败臂注记的那类方言分歧,这里用显式事务模式把它结构性关死);PG 侧
-     *    `beginPessimistic()` = 普通 `BEGIN`,READ COMMITTED 下 FOR UPDATE 本就等待并返回最新已提交版本。
+     *  · 败方读数是**同一事务内**的 `SELECT … FOR UPDATE` —— TiDB 侧的悲观锁定读是 CURRENT read,读到的是
+     *    并发赢家**已提交**的最新版本(乐观模式下 FOR UPDATE 读 start_ts 快照,会把赢家终局读旧 —— 正是
+     *    bindBatch 失败臂注记的那类方言分歧)。悲观模式**不赌部署的 `tidb_txn_mode` 缺省**:它是连接初始化
+     *    的结构保证,设不上就拒启({@link SqlTxConn.begin} 的 @contract txn.read-semantics)。PG 侧
+     *    `BEGIN` = READ COMMITTED,FOR UPDATE 本就等待并返回最新已提交版本。
      *  · CAS 输(affected=0)⇒ 行在 UPDATE 那一刻已非 STREAM_PENDING(或不在/错 scope),而非 pending 态
      *    在状态机上无回边 ⇒ 锁定读读到的恒 ≥ 线性化点,且 DECIDED 决议不可变 —— 答案自足。
      *  · 本事务在输臂上除批行 rev 自增外零写,rollback 无痕。

package/dist/plugins/approval-ask-store-sql.js

@@ -440,7 +440,7 @@ export class SqlApprovalAskStore {
         const dialect = this.db.dialect;
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             if (intent === "expire") {
                 const lockRes = await conn.query(this.q(`UPDATE ${APPROVAL_BATCH_TABLE} SET rev=rev+1 WHERE batch_id=?`, `UPDATE ${APPROVAL_BATCH_TABLE} SET rev=rev+1 WHERE batch_id=$1`), [batchId]);
                 if (lockRes.affected !== 1) {

package/dist/plugins/device-store-sql.d.ts

@@ -18,9 +18,11 @@
  *    ——**所有** CAS UPDATE 因此必须带一个恒变列(`rev = rev + 1`)。本文件每一条 CAS UPDATE 都带。
  *    在本店这条尤其致命:心跳续租在「同一毫秒内重复心跳」时 SET 的值可能与当前值相同,没有 rev
  *    就会被判成「本连接已失权」⇒ 设备被自己的心跳踢下线。
- * 3. 事务:`SqlDriver.connect()` → `begin()`/`beginPessimistic()` → `query()` → `commit()`,失败
- *    `rollback()`。**失败臂的回读必须走当前这条 `conn`**(approval 店复审 F1 的真缺陷:走池级 query
- *    会与自己持有的连接死锁),且**先 rollback 再读**(读到最新已提交视图)。
+ * 3. 事务:`SqlDriver.connect()` → `begin()` → `query()` → `commit()`,失败 `rollback()`。读语义
+ *    (隔离级 / TiDB 悲观模式 / 事务内集合读必须锁读)的判据只有一处:`sql-driver.ts` 头注的
+ *    {@link SqlTxConn.begin} `@contract txn.read-semantics`。**失败臂的回读必须走当前这条 `conn`**
+ *    (approval 店复审 F1 的真缺陷:走池级 query 会与自己持有的连接死锁),且**先 rollback 再读**
+ *    (回滚后本连接回到 autocommit,那条 SELECT 自成事务 ⇒ 读到最新已提交视图)。
  *
  * ── 方言差异(A12 doctrine:每处显式写在调用点)────────────────────────────────────────────────────
  *   - `?`(位置序) vs `$n`(显式编号);动态 WHERE(`listAudit`)靠 `ph(dialect, n)` 生成。
@@ -131,9 +133,10 @@ export declare class SqlDeviceStore implements DeviceStore {
     /**
      * §4.3.2 首绑写协议 —— **单事务**:设备校验(active ∧ owner)与首绑 CAS 插入在一个事务里。
      *
-     * 🔴 `beginPessimistic` + `FOR UPDATE`(设备行):设备行必须是**当前读**。快照读下,一次与吊销并发的
-     * 绑定会读到「还 active」的旧版本,于是把 session 绑到一台**刚被吊销**的设备上(sql-driver.ts 头注点名
-     * 的 double-admit 形)。这把锁在 `devices` 表上,与下面被插入的 `device_session` 行不是同一行。
+     * 🔴 `FOR UPDATE`(设备行):设备行必须是**当前读**。普通读下,一次与吊销并发的绑定会读到「还 active」
+     * 的旧版本,于是把 session 绑到一台**刚被吊销**的设备上(double-admit 形)。锁读在两引擎都是当前读 ——
+     * 前提写在 {@link SqlTxConn.begin} 的 @contract txn.read-semantics。这把锁在 `devices` 表上,与下面
+     * 被插入的 `device_session` 行不是同一行。
      *
      * 🔴 形 B · cas-insert(S-127 / B-013)—— 本站点是全仓 `INSERT IGNORE` 的**正当用法**:
      * `INSERT IGNORE` / `ON CONFLICT DO NOTHING` 的 affected(1/0)是引擎对「谁赢」的**权威**回答,而
@@ -166,7 +169,8 @@ export declare class SqlDeviceStore implements DeviceStore {
      * O4 显式换绑(2026-08-30 v2 稿 §2)—— **单事务**:目标设备门(当前读)+ 幂等短路 + 前态 CAS +
      * `session_rebound` 审计行一起提交。三形语义 oracle = `InMemoryDeviceStore.rebindSession`。
      *
-     * 🔴 `beginPessimistic` + 两次 `FOR UPDATE`(bindSession 的同一条真库红的射程):
+     * 🔴 两次 `FOR UPDATE`(bindSession 的同一条真库红的射程;当前读的前提见
+     * {@link SqlTxConn.begin} 的 @contract txn.read-semantics):
      *  · 设备行必须当前读 —— 快照读会把「与吊销并发的换绑」绑到一台刚被吊销的设备上(double-admit 形);
      *  · 绑定行必须当前读且**持锁到提交** —— 两个并发换绑(同 expectedRev)在锁上串行:赢家 rev+1 提交,
      *    输家的锁读看到新 rev ⇒ 走 `rev_conflict` 携当前行(单赢家,无未定义态)。锁读判等之后,CAS

package/dist/plugins/device-store-sql.js

@@ -367,7 +367,7 @@ export class SqlDeviceStore {
         }
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             const cas = await conn.query(this.q(`UPDATE ${DEVICE_ENROLL_TOKENS_TABLE} SET consumed_at = NOW(3), consumed_device_id = ?, consumed_pubkey = ?, rev = rev + 1
             WHERE token_hash = ? AND consumed_at IS NULL AND expires_at > NOW(3) AND target_tenant = ? AND target_subject = ?`, `UPDATE ${DEVICE_ENROLL_TOKENS_TABLE} SET consumed_at = now(), consumed_device_id = $1, consumed_pubkey = $2, rev = rev + 1
             WHERE token_hash = $3 AND consumed_at IS NULL AND expires_at > now() AND target_tenant = $4 AND target_subject = $5`), [input.device.deviceId, input.device.pubkey, input.tokenHash, input.requester.tenant, input.requester.subject]);
@@ -454,7 +454,7 @@ export class SqlDeviceStore {
         assertRevokeShape(input);
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             const cas = await conn.query(this.q(`UPDATE ${DEVICES_TABLE} SET status = 'revoked', revoked_at = NOW(3), revoked_by = ?, revoke_reason = ?, lease_expires_at = NULL, conn_generation = conn_generation + 1, rev = rev + 1
             WHERE device_id = ? AND owner_tenant = ? AND owner_subject = ? AND status = 'active'`, `UPDATE ${DEVICES_TABLE} SET status = 'revoked', revoked_at = now(), revoked_by = $1, revoke_reason = $2, lease_expires_at = NULL, conn_generation = conn_generation + 1, rev = rev + 1
             WHERE device_id = $3 AND owner_tenant = $4 AND owner_subject = $5 AND status = 'active'`), [input.revokedBy, input.reason ?? null, input.deviceId, input.owner.tenant, input.owner.subject]);
@@ -484,7 +484,7 @@ export class SqlDeviceStore {
         assertAcquireShape(input);
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             const cas = await conn.query(this.q(`UPDATE ${DEVICES_TABLE} SET conn_generation = conn_generation + 1, conn_epoch = ?, replica_id = ?, lease_expires_at = ${nowPlusSeconds("tidb", "?")}, connected_at = NOW(3), last_seen_at = NOW(3), rev = rev + 1
             WHERE device_id = ? AND owner_tenant = ? AND owner_subject = ? AND status = 'active' AND (lease_expires_at IS NULL OR lease_expires_at <= NOW(3))`, `UPDATE ${DEVICES_TABLE} SET conn_generation = conn_generation + 1, conn_epoch = $1, replica_id = $2, lease_expires_at = ${nowPlusSeconds("pg", "$3")}, connected_at = now(), last_seen_at = now(), rev = rev + 1
             WHERE device_id = $4 AND owner_tenant = $5 AND owner_subject = $6 AND status = 'active' AND (lease_expires_at IS NULL OR lease_expires_at <= now())`), [input.connEpoch, input.replicaId, input.leaseSeconds, input.deviceId, input.owner.tenant, input.owner.subject]);
@@ -523,7 +523,7 @@ export class SqlDeviceStore {
         assertDeviceOwnerShape(input.owner);
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             const dev = await conn.query(this.q(`SELECT status FROM ${DEVICES_TABLE} WHERE device_id = ? AND owner_tenant = ? AND owner_subject = ? FOR UPDATE`, `SELECT status FROM ${DEVICES_TABLE} WHERE device_id = $1 AND owner_tenant = $2 AND owner_subject = $3 FOR UPDATE`), [input.deviceId, input.owner.tenant, input.owner.subject]);
             if (!dev.rows[0]) {
                 await conn.rollback();
@@ -554,7 +554,7 @@ export class SqlDeviceStore {
     async observeLostBind(input) {
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             const { rows } = await conn.query(this.q(`SELECT ${sessionCols("tidb")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = ? FOR UPDATE`, `SELECT ${sessionCols("pg")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = $1 FOR UPDATE`), [input.rootSessionId]);
             await conn.commit();
             const row = rows[0] ? mapSessionRow(rows[0]) : null;
@@ -575,7 +575,7 @@ export class SqlDeviceStore {
         assertRebindShape(input);
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             const dev = await conn.query(this.q(`SELECT status FROM ${DEVICES_TABLE} WHERE device_id = ? AND owner_tenant = ? AND owner_subject = ? FOR UPDATE`, `SELECT status FROM ${DEVICES_TABLE} WHERE device_id = $1 AND owner_tenant = $2 AND owner_subject = $3 FOR UPDATE`), [input.toDeviceId, input.owner.tenant, input.owner.subject]);
             if (!dev.rows[0] || parseDeviceStatus(bufToStr(dev.rows[0].status)) !== "active") {
                 await conn.rollback();

package/dist/plugins/file-history-store-sql.d.ts

@@ -79,7 +79,11 @@ export declare class SqlFileHistoryStore implements FileHistoryStore {
         env: ExecutionEnv;
         signal?: AbortSignal;
     }): Promise<FileHistoryResult>;
+    /** `forUpdate` = the {@link SqlTxConn.begin} `@contract txn.read-semantics` ③ arm: a collection read that
+     *  runs inside a transaction must be a LOCKING read (a plain SELECT is pinned to the transaction's start on
+     *  TiDB, so the lock-wait window's commits are invisible — B-022). Pool-level callers pass nothing. */
     private loadTracked;
+    /** `forUpdate` — see {@link loadTracked}: inside a transaction this is a collection read, so it locks. */
     private loadVersions;
     /** [ref] twin 保留条款:这个 entry 的键是否**已花掉**(被 reap 剪过)。台账 `file_history_reaped_entry`。
      *  `forUpdate`(r3-①连带):发布 tx 内的复核必须是**锁定读**——TiDB 悲观事务的普通 SELECT 按文档读
@@ -109,14 +113,18 @@ export declare class SqlFileHistoryStore implements FileHistoryStore {
     /** PROTECTED RACE SEAM (test-only override): runs inside `restore` between the boundary-header check and
      *  the mapping read. Production body is empty. */
     protected duringRestorePlan(_scope: string, _entryId: string): Promise<void>;
-    /** PROTECTED RACE SEAM (test-only override): runs inside the publish tx AFTER `beginPessimistic` and
-     *  BEFORE the scope lock — the window where another replica's publish can commit while this tx's
-     *  snapshot is already pinned (TiDB snapshot-reads plain SELECTs, D2). Production body is empty. */
+    /** PROTECTED RACE SEAM (test-only override): runs inside the publish tx AFTER `begin()` and BEFORE
+     *  the scope lock — the window where another replica's publish can commit while this tx's snapshot is
+     *  already pinned. That window is exactly what B-022 rode: a plain SELECT taken after the lock is still
+     *  pinned to the transaction's start, so this tx's collection reads are LOCKING reads
+     *  ({@link SqlTxConn.begin} → `@contract txn.read-semantics`). Production body is empty. */
     protected beforePublishLock(_scope: string): Promise<void>;
     /** PROTECTED RACE SEAM (test-only override): runs inside `exportOf` between the boundary-header read and
      *  the mapping read. Production body is empty. */
     protected duringExportGraph(_scope: string): Promise<void>;
     private applyBoundaryRetention;
+    /** `forUpdate` — see {@link loadTracked}: the in-transaction re-check must be a LOCKING read, or it just
+     *  replays the pool-level pre-check's snapshot and its documented `null` arm becomes unreachable. */
     private boundaryExists;
     snapshot(scope: string, entryId: string, env: ExecutionEnv, root: string, signal?: AbortSignal): Promise<FileHistoryResult>;
     restore(scope: string, entryId: string, env: ExecutionEnv, root: string, signal?: AbortSignal): Promise<FileHistoryRestoreResult>;
@@ -146,6 +154,10 @@ export declare class SqlFileHistoryStore implements FileHistoryStore {
     hasBlobs(hashes: string[]): Promise<Set<string>>;
     adoptScope(fromScope: string, toScope: string): Promise<FileHistoryResult>;
     private scopeEmpty;
+    /** `forUpdate` — see {@link loadTracked}. Every in-transaction caller passes `true`: the four reads are
+     *  one graph, and a graph materialized from a start-of-transaction snapshot disagrees with the LOCKING
+     *  emptiness probe that decided to materialize it (that disagreement answered a legal idempotent
+     *  re-import as `conflict` — B-022). */
     private exportOf;
     exportHistory(scope: string): Promise<FileHistoryExport | null>;
     importHistory(scope: string, data: FileHistoryExport, srcGetBlob: (hash: string) => Promise<Uint8Array | undefined>): Promise<FileHistoryResult>;

package/dist/plugins/file-history-store-sql.js

@@ -92,7 +92,7 @@ export class SqlFileHistoryStore {
                 const conn = await this.db.connect();
                 let minted = false;
                 try {
-                    await conn.beginPessimistic();
+                    await conn.begin();
                     await this.lockScope(conn, scope);
                     const ins = await conn.query(this.q("INSERT IGNORE INTO file_history_tracked (scope, key_hash, track_key, key_kind, key_family, base_available, observed_later, created_at_ms) VALUES (?,?,?,?,?,?,0,?)", "INSERT INTO file_history_tracked (scope, key_hash, track_key, key_kind, key_family, base_available, observed_later, created_at_ms) VALUES ($1,$2,$3,$4,$5,$6,FALSE,$7) ON CONFLICT (scope, key_hash) DO NOTHING"), [scope, keyHash, key, keyDesc.kind, keyDesc.family, this.bool(baseAvailable), Date.now()]);
                     minted = ins.affected === 1;
@@ -159,7 +159,7 @@ export class SqlFileHistoryStore {
             }
             const conn = await this.db.connect();
             try {
-                await conn.beginPessimistic();
+                await conn.begin();
                 await this.lockScope(conn, scope);
                 const del = await conn.query(this.q(`DELETE FROM file_history_tracked WHERE scope = ? AND key_hash = ? AND observed_later = 0
                AND NOT EXISTS (SELECT 1 FROM file_history_boundary_file bf WHERE bf.scope = ? AND bf.key_hash = ?)
@@ -202,8 +202,9 @@ export class SqlFileHistoryStore {
             baseAvailable: truthy(row.base_available),
         }));
     }
-    async loadVersions(exec, scope) {
-        const r = await exec.query(this.q("SELECT key_hash, version, blob_hash, mode, parent_ident, backup_time FROM file_history_version WHERE scope = ? ORDER BY version", "SELECT key_hash, version, blob_hash, mode, parent_ident, backup_time FROM file_history_version WHERE scope = $1 ORDER BY version"), [scope]);
+    async loadVersions(exec, scope, forUpdate = false) {
+        const suffix = forUpdate ? " FOR UPDATE" : "";
+        const r = await exec.query(this.q(`SELECT key_hash, version, blob_hash, mode, parent_ident, backup_time FROM file_history_version WHERE scope = ? ORDER BY version${suffix}`, `SELECT key_hash, version, blob_hash, mode, parent_ident, backup_time FROM file_history_version WHERE scope = $1 ORDER BY version${suffix}`), [scope]);
         const out = new Map();
         for (const row of r.rows) {
             const kh = String(row.key_hash);
@@ -240,9 +241,9 @@ export class SqlFileHistoryStore {
             await this.beforeRetentionPass(scope);
             const conn = await this.db.connect();
             try {
-                await conn.beginPessimistic();
+                await conn.begin();
                 await this.lockScope(conn, scope);
-                const { rows } = await conn.query(this.q("SELECT entry_id, publish_seq FROM file_history_boundary WHERE scope = ? ORDER BY publish_seq ASC", "SELECT entry_id, publish_seq FROM file_history_boundary WHERE scope = $1 ORDER BY publish_seq ASC"), [scope]);
+                const { rows } = await conn.query(this.q("SELECT entry_id, publish_seq FROM file_history_boundary WHERE scope = ? ORDER BY publish_seq ASC FOR UPDATE", "SELECT entry_id, publish_seq FROM file_history_boundary WHERE scope = $1 ORDER BY publish_seq ASC FOR UPDATE"), [scope]);
                 const ordered = rows.map((r) => ({ id: String(r.entry_id), seq: Number(r.publish_seq) }));
                 if (ordered.length === 0) {
                     await conn.rollback();
@@ -275,8 +276,9 @@ export class SqlFileHistoryStore {
             recordFailOpen("server.file-history.retention-trim-failed", `scope=${scope} entry=${justCommitted}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    async boundaryExists(exec, scope, entryId) {
-        const r = await exec.query(this.q("SELECT 1 FROM file_history_boundary WHERE scope = ? AND entry_id = ? LIMIT 1", "SELECT 1 FROM file_history_boundary WHERE scope = $1 AND entry_id = $2 LIMIT 1"), [scope, entryId]);
+    async boundaryExists(exec, scope, entryId, forUpdate = false) {
+        const suffix = forUpdate ? " FOR UPDATE" : "";
+        const r = await exec.query(this.q(`SELECT 1 FROM file_history_boundary WHERE scope = ? AND entry_id = ? LIMIT 1${suffix}`, `SELECT 1 FROM file_history_boundary WHERE scope = $1 AND entry_id = $2 LIMIT 1${suffix}`), [scope, entryId]);
         return Boolean(r.rows[0]);
     }
     async snapshot(scope, entryId, env, root, signal) {
@@ -344,7 +346,7 @@ export class SqlFileHistoryStore {
             await this.beforePublish(scope);
             const conn = await this.db.connect();
             try {
-                await conn.beginPessimistic();
+                await conn.begin();
                 await this.beforePublishLock(scope);
                 await this.lockScope(conn, scope);
                 if (signal?.aborted) {
@@ -356,7 +358,7 @@ export class SqlFileHistoryStore {
                     await conn.rollback();
                     return reapedEntryRefusal(entryId);
                 }
-                const seqRow = await conn.query(this.q("SELECT publish_seq FROM file_history_boundary WHERE scope = ? ORDER BY publish_seq DESC LIMIT 1 FOR UPDATE", "SELECT publish_seq FROM file_history_boundary WHERE scope = $1 ORDER BY publish_seq DESC LIMIT 1"), [scope]);
+                const seqRow = await conn.query(this.q("SELECT publish_seq FROM file_history_boundary WHERE scope = ? ORDER BY publish_seq DESC LIMIT 1 FOR UPDATE", "SELECT publish_seq FROM file_history_boundary WHERE scope = $1 ORDER BY publish_seq DESC LIMIT 1 FOR UPDATE"), [scope]);
                 const publishSeq = (seqRow.rows[0] !== undefined ? Number(seqRow.rows[0].publish_seq) : 0) + 1;
                 const priorWinner = await conn.query(this.q("SELECT 1 FROM file_history_boundary WHERE scope = ? AND entry_id = ? FOR UPDATE", "SELECT 1 FROM file_history_boundary WHERE scope = $1 AND entry_id = $2 FOR UPDATE"), [scope, entryId]);
                 if (priorWinner.rows[0]) {
@@ -496,16 +498,16 @@ export class SqlFileHistoryStore {
     async restorePlan(scope, entryId) {
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             await this.lockScope(conn, scope);
-            if (!(await this.boundaryExists(conn, scope, entryId))) {
+            if (!(await this.boundaryExists(conn, scope, entryId, true))) {
                 await conn.rollback();
                 return null;
             }
             await this.duringRestorePlan(scope, entryId);
-            const tracked = (await this.loadTracked(conn, scope)).sort((a, b) => (a.trackKey < b.trackKey ? -1 : a.trackKey > b.trackKey ? 1 : 0));
-            const versions = await this.loadVersions(conn, scope);
-            const mapRows = await conn.query(this.q("SELECT key_hash, version FROM file_history_boundary_file WHERE scope = ? AND entry_id = ?", "SELECT key_hash, version FROM file_history_boundary_file WHERE scope = $1 AND entry_id = $2"), [scope, entryId]);
+            const tracked = (await this.loadTracked(conn, scope, true)).sort((a, b) => (a.trackKey < b.trackKey ? -1 : a.trackKey > b.trackKey ? 1 : 0));
+            const versions = await this.loadVersions(conn, scope, true);
+            const mapRows = await conn.query(this.q("SELECT key_hash, version FROM file_history_boundary_file WHERE scope = ? AND entry_id = ? FOR UPDATE", "SELECT key_hash, version FROM file_history_boundary_file WHERE scope = $1 AND entry_id = $2 FOR UPDATE"), [scope, entryId]);
             const boundary = new Map(mapRows.rows.map((r) => [String(r.key_hash), Number(r.version)]));
             await conn.commit();
             return { tracked, versions, boundary };
@@ -524,9 +526,9 @@ export class SqlFileHistoryStore {
     async reap(scope, keepEntryIds) {
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             await this.lockScope(conn, scope);
-            const ids = await conn.query(this.q("SELECT entry_id FROM file_history_boundary WHERE scope = ?", "SELECT entry_id FROM file_history_boundary WHERE scope = $1"), [scope]);
+            const ids = await conn.query(this.q("SELECT entry_id FROM file_history_boundary WHERE scope = ? FOR UPDATE", "SELECT entry_id FROM file_history_boundary WHERE scope = $1 FOR UPDATE"), [scope]);
             const dropped = await this.reapWithin(conn, scope, new Set(keepEntryIds), ids.rows.map((r) => String(r.entry_id)));
             await conn.commit();
             return dropped;
@@ -557,7 +559,7 @@ export class SqlFileHistoryStore {
     async deleteBySession(scope) {
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             await this.lockScope(conn, scope);
             let total = 0;
             for (const table of ["file_history_boundary_file", "file_history_boundary", "file_history_reaped_entry", "file_history_version", "file_history_tracked", "file_history_scope"]) {
@@ -606,13 +608,13 @@ export class SqlFileHistoryStore {
                 return { ok: true };
             const conn = await this.db.connect();
             try {
-                await conn.beginPessimistic();
+                await conn.begin();
                 await this.lockScope(conn, fromScope, toScope);
                 if (!(await this.scopeEmpty(conn, toScope, true))) {
                     await conn.rollback();
                     return { ok: false, error: { code: "conflict", message: `adoptScope target "${toScope}" already has history of its own — adoption is legal only onto an EMPTY scope (the fork/resume boundary before the new session's first turn)` } };
                 }
-                if (await this.scopeEmpty(conn, fromScope)) {
+                if (await this.scopeEmpty(conn, fromScope, true)) {
                     await this.copyReapedEntries(conn, fromScope, toScope);
                     await conn.commit();
                     return { ok: true };
@@ -645,14 +647,15 @@ export class SqlFileHistoryStore {
         const b = await exec.query(this.q(`SELECT 1 FROM file_history_boundary WHERE scope = ? LIMIT 1${suffix}`, `SELECT 1 FROM file_history_boundary WHERE scope = $1 LIMIT 1${suffix}`), [scope]);
         return !b.rows[0];
     }
-    async exportOf(exec, scope) {
-        const tracked = await this.loadTracked(exec, scope);
-        const versions = await this.loadVersions(exec, scope);
-        const headers = await exec.query(this.q("SELECT entry_id FROM file_history_boundary WHERE scope = ?", "SELECT entry_id FROM file_history_boundary WHERE scope = $1"), [scope]);
+    async exportOf(exec, scope, forUpdate = false) {
+        const suffix = forUpdate ? " FOR UPDATE" : "";
+        const tracked = await this.loadTracked(exec, scope, forUpdate);
+        const versions = await this.loadVersions(exec, scope, forUpdate);
+        const headers = await exec.query(this.q(`SELECT entry_id FROM file_history_boundary WHERE scope = ?${suffix}`, `SELECT entry_id FROM file_history_boundary WHERE scope = $1${suffix}`), [scope]);
         if (tracked.length === 0 && headers.rows.length === 0)
             return null;
         await this.duringExportGraph(scope);
-        const files = await exec.query(this.q("SELECT entry_id, key_hash, version FROM file_history_boundary_file WHERE scope = ?", "SELECT entry_id, key_hash, version FROM file_history_boundary_file WHERE scope = $1"), [scope]);
+        const files = await exec.query(this.q(`SELECT entry_id, key_hash, version FROM file_history_boundary_file WHERE scope = ?${suffix}`, `SELECT entry_id, key_hash, version FROM file_history_boundary_file WHERE scope = $1${suffix}`), [scope]);
         const keyOfHash = new Map(tracked.map((t) => [t.keyHash, t.trackKey]));
         const byEntry = new Map();
         for (const row of files.rows) {
@@ -688,9 +691,9 @@ export class SqlFileHistoryStore {
     async exportHistory(scope) {
         const conn = await this.db.connect();
         try {
-            await conn.beginPessimistic();
+            await conn.begin();
             await this.lockScope(conn, scope);
-            const out = await this.exportOf(conn, scope);
+            const out = await this.exportOf(conn, scope, true);
             await conn.commit();
             return out;
         }
@@ -743,10 +746,10 @@ export class SqlFileHistoryStore {
             }
             const conn = await this.db.connect();
             try {
-                await conn.beginPessimistic();
+                await conn.begin();
                 await this.lockScope(conn, scope);
                 if (!(await this.scopeEmpty(conn, scope, true))) {
-                    const now = await this.exportOf(conn, scope);
+                    const now = await this.exportOf(conn, scope, true);
                     if (now !== null && fileHistoryExportDigest(now) === fileHistoryExportDigest(data)) {
                         await conn.commit();
                         return { ok: true };

package/dist/plugins/image-bake-store-sql.js

@@ -139,7 +139,7 @@ export class SqlImageBake {
         let inserted = false;
         try {
             if (this.db.dialect === "tidb") {
-                await conn.beginPessimistic();
+                await conn.begin();
                 await conn.query("INSERT INTO image_bake_admit (pool) VALUES (?) ON DUPLICATE KEY UPDATE pool = pool", [this.poolName]);
                 await conn.query("SELECT pool FROM image_bake_admit WHERE pool = ? FOR UPDATE", [this.poolName]);
                 const busy = await conn.query("SELECT 1 FROM image_bake WHERE status IN ('queued','running') AND dry_run = 0 LIMIT 1 FOR UPDATE");

package/dist/plugins/permission-rule-store-file.d.ts

@@ -1,4 +1,4 @@
-import { FilePermissionRuleStoreProvider, type RuleApprovalRecord, type RuleApprovalRecordStore, type RuleScope, type StaleRuleApprovalRecord } from "@sema-agent/core";
+import { FileDurableRulePartitionProvider, type RuleApprovalRecord, type RuleApprovalRecordStore, type RuleScope, type StaleRuleApprovalRecord } from "@sema-agent/core";
 import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./permission-rule-store-sql.js";
 import type { PermissionRuleStoreBundle } from "../rules-consent.js";
 /**
@@ -84,9 +84,9 @@ export declare class FileRuleImportTicketStore {
      *  那一条:过期只挡开始一次兑付,不挡做完一次已经开始的)。抢到之后**换一代认领**。 */
     reclaim(ticketId: string, principal: string, purpose: RuleTicketPurpose, minClaimAgeMs: number): Promise<RuleTicketReclaimResult>;
 }
-/** local 车道的三面束 + 生命周期。`dispose()` 释放 core File provider 的写锁(见 {@link createFilePermissionRuleStores})。 */
+/** local 车道的三面束 + 生命周期。`dispose()` 释放 core File durable 分区 provider 的写锁(见 {@link createFilePermissionRuleStores})。 */
 export interface FilePermissionRuleStores extends PermissionRuleStoreBundle {
-    provider: FilePermissionRuleStoreProvider;
+    durable: FileDurableRulePartitionProvider;
     approvals: FileRuleApprovalRecordStore;
     tickets: FileRuleImportTicketStore;
     dispose(): void;
@@ -94,7 +94,7 @@ export interface FilePermissionRuleStores extends PermissionRuleStoreBundle {
 /**
  * 装配 local 三面束。
  *
- * 🔴 `provider` 必须是**单例**(F1):core 的 `FilePermissionRuleStoreProvider` 在第一次取写面时对规则
+ * 🔴 `durable` 必须是**单例**(F1):core 的 `FileDurableRulePartitionProvider` 在第一次取写面时对规则
  * 目录取一把进程级写锁,每次 `new` 一个就是第二个持有者 —— 而它对第二个持有者是**响亮拒绝**,不是
  * 排队。所以束在 `LocalBackend` 上按字段持有,`LocalBackend.close()` 调 `dispose()` 释放
  * (不释放 ⇒ 一次优雅重启会被自己上一条命留下的锁挡在门外,与数据根 `root/LOCK` 同一个病)。

package/dist/plugins/permission-rule-store-file.js

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { readdirSync } from "node:fs";
 import { performance } from "node:perf_hooks";
-import { FilePermissionRuleStoreProvider, AppendLog, ensureDir, readJsonlRecords, } from "@sema-agent/core";
+import { FileDurableRulePartitionProvider, AppendLog, ensureDir, readJsonlRecords, } from "@sema-agent/core";
 import { z } from "zod";
 import { buildRulePayloadHash } from "./permission-rule-store-sql.js";
 import { EDITED_RULE_BREADTH_WARNING_CODES, RULE_APPROVAL_RECORD_SCHEMA, UNCOVERED_SEGMENT_REASONS } from "../permission-rule-vocab.js";
@@ -341,18 +341,18 @@ export class FileRuleImportTicketStore {
 export function createFilePermissionRuleStores(root, opts) {
     const dir = join(root, "permission-rules");
     ensureDir(dir);
-    const provider = opts?.onError ? new FilePermissionRuleStoreProvider(dir, opts.onError) : new FilePermissionRuleStoreProvider(dir);
+    const durable = opts?.onError ? new FileDurableRulePartitionProvider(dir, opts.onError) : new FileDurableRulePartitionProvider(dir);
     const approvals = new FileRuleApprovalRecordStore(dir, opts?.onError);
     const tickets = new FileRuleImportTicketStore(dir, opts?.now, opts?.onError, opts?.monotonic);
     return {
-        provider,
+        durable,
         approvals,
         tickets,
         countBuckets: async () => readdirSync(dir).filter((n) => n === "local-owner.json" || /^[0-9a-f]{64}\.json$/.test(n)).length,
         dispose: () => {
             approvals.close();
             tickets.close();
-            provider.dispose();
+            durable.dispose();
         },
     };
 }