@sema-agent/server 7.54.0 → 7.56.0

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

@@ -241,6 +241,58 @@ export interface ExpireResult {
     won: boolean;
     voidedSiblings: string[];
 }
+/**
+ * [ref](DEBTS [ref]-R1 终局;core [ref] §4.4「@server 对表键形」,黑板 [ref] 认领):终局 claim 的
+ * 意图。ask 行的 TERMINAL 对儿只有两员 —— `expire`(窗到期 / emit 全灭共用:STREAM_PENDING→PARKING +
+ * 批转投递面 + 兄弟撤卡,与 `expireAsk` 同一台 CAS 机器)与 `cancel`(取消臂:STREAM_PENDING→VOID)。
+ * **人答臂(decide)不入本枚举**:`decideAsk` 带决议载荷与回决幂等键,其失败臂本就携行读数(384 §4.4
+ * 表「decideAsk(人答臂)」格的「视现有 CAS 形」裁定)——三 verb 的「一台机器义务」(384 §4.3-2)由共享
+ * WHERE 谓词 {@link pendingClaimWhere} 兑现,不是把三个不同 verb 塞进一个函数。
+ */
+export type AskTerminalClaimIntent = "expire" | "cancel";
+/**
+ * 败方读数:行上终局相关列的一致投影(status 词表 = 行自己的 `AskState`,零新值域 —— 384 §4.2 的
+ * 「reuse the row's own vocabulary」)。
+ *  · `state:"absent"` = 行不在,**或 scope(batchId)不匹配** —— 错 scope 的 claim 必须输且不得读出
+ *    他 scope 行的真相(读谓词与 CAS 谓词是同一份 scope WHERE;多租户隔离,384 §4.2 absent 臂原话)。
+ *  · **绝无 `STREAM_PENDING` 臂**:server 的 ask 店 CAS 谓词是 status 门(STREAM_PENDING→终态),无
+ *    rev/OCC 期望语义 ⇒ core 表的 `pending`(rev 失配)臂在本形结构不可达,如实缺席不硬造([ref]
+ *    补充确认①)。输 = 行在 claim 线性化点上已非 pending,而非 pending 态在状态机上**无回边**
+ *    (`approval-ask-machine.ts`,本域无 reopen)⇒ 败方读数恒 ≥ 那一刻;「CAS 时行不在、读时刚被
+ *    ensureAsk 插入」的编排错序形按线性化点真相投影为 `absent`。
+ *  · 本域无 reopen ⇒ DECIDED 恒不回 pending,败方读数在本域退化为永恒真相;消费仍按快照律
+ *    (384 §4.3-5)写,不依赖此强化([ref] 补充确认②)。
+ */
+export type AskTerminalClaimCurrent = {
+    state: "absent";
+} | {
+    state: Exclude<AskState, "STREAM_PENDING">;
+    rev: number;
+    decision: AskDecision | null;
+    /** [ref] 三态读法照 {@link AskRow.updatedInput}:键缺席 = 没带编辑;`null` 是编辑成 null 的值。 */
+    updatedInput?: unknown;
+};
+/**
+ * 单次原子往返的答案(语义律的唯一规范陈述点 = core `checkpoint-store.ts` `claimTerminal` 契约 JSDoc,
+ * [ref] §4.3;本类型是其 ask 行同位物,不复述七律,只记 server 侧特有形):
+ *  · 赢 ⇒ `{claimed:true}`(expire 意图随赢携兄弟撤卡名单,与 `expireAsk` 同形);
+ *  · 输 ⇒ **同一原子单元**携行真相(律 1)—— 消费方拿到 `claimed:false` 后永不需要第二次读来行动;
+ *  · reject(throw / 超墙钟)⇒ 什么也不证明(律 3 K2)——调用方不得按本地意图宣告终局;**迟到的
+ *    settle 同样自足**:deadline 过后才回来的 `claimed:false` 直接携真决议,臂按真决议 settle 零补读。
+ * server 三臂全为**幂等消费**(按真决议 settle,谁写的无关,律 4)——本店无职责性消费面。
+ */
+export type AskTerminalClaimOutcome = {
+    claimed: true;
+    voidedSiblings: string[];
+} | {
+    claimed: false;
+    current: AskTerminalClaimCurrent;
+};
+/**
+ * 败方读数的投影(三 twin 共用一份,别各自挑列):`null` / 错 scope 由调用方先折成 `null` 传入;
+ * `STREAM_PENDING` 折 `absent` 的理由见 {@link AskTerminalClaimCurrent} 顶注(线性化点真相)。
+ */
+export declare function projectAskTerminalClaimTruth(row: AskRow | null): AskTerminalClaimCurrent;
 export interface BindGateInput {
     gateToken: string;
     gateBoundCallId?: string | null;
@@ -278,6 +330,15 @@ export interface ApprovalAskStore {
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * [ref]:原子终局 claim —— 把「争终局」与「读真相」并成**一次**店往返(胜负判定与败方 `current` 读数
+     * 在同一原子单元内,语义见 {@link AskTerminalClaimOutcome})。[ref]-R1 的病根「CAS 与读真相是两次店
+     * 往返」由本原语从机制上消灭:settle 的答案自足(赢 ⇒ 赢;输 ⇒ 携真相),迟到的答案同样自足。
+     * 律 2「一台机器义务」:`expireAsk` 在本方法之上实现(SQL 双方言)/ 本方法委托给
+     * `expireAsk`/`transitionAsk`(InMemory,单线程天然原子)——两向都成立的判据是**没有第二套谓词**。
+     * 方法**必备**(本仓自有三形全实现,无 core 那侧的 presence 探测问题)。
+     */
+    claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent): Promise<AskTerminalClaimOutcome>;
     expireAsk(askId: string, batchId: string): Promise<ExpireResult>;
     bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;
     abortBatch(batchId: string): Promise<string[]>;
@@ -435,6 +496,27 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * [ref] 原子终局 claim(接口契约见 {@link ApprovalAskStore.claimTerminal};类型语义见
+     * {@link AskTerminalClaimOutcome})。expire 意图 = 既有 `expireAsk` 事务**原体**(步⓪-③ 逐字保留,
+     * `expireAsk` 现在是本方法的薄投影 —— 律 2 的「在 claimTerminal 之上实现」半场);cancel 意图 =
+     * 取消臂的 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 本就等待并返回最新已提交版本。
+     *  · CAS 输(affected=0)⇒ 行在 UPDATE 那一刻已非 STREAM_PENDING(或不在/错 scope),而非 pending 态
+     *    在状态机上无回边 ⇒ 锁定读读到的恒 ≥ 线性化点,且 DECIDED 决议不可变 —— 答案自足。
+     *  · 本事务在输臂上除批行 rev 自增外零写,rollback 无痕。
+     */
+    claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent): Promise<AskTerminalClaimOutcome>;
+    /** [ref] 起 = {@link claimTerminal}(expire 意图)的薄投影 —— 律 2「在 claimTerminal 之上实现」的
+     *  SQL 半场落笔处:谓词/事务/兄弟撤卡全在 claim 里,这里零第二套写路径。败方读数按既有返回形丢弃
+     *  (`ExpireResult` 不携真相 —— 要真相的调用方直接用 claimTerminal;对账收敛器的 orphan 腿输了本就
+     *  只需「不赢」这一位)。 */
     expireAsk(askId: string, batchId: string): Promise<ExpireResult>;
     bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;
     abortBatch(batchId: string): Promise<string[]>;

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

@@ -33,6 +33,16 @@ async function withReadSignal(op, signal, where) {
             signal.removeEventListener("abort", onAbort);
     }
 }
+export function projectAskTerminalClaimTruth(row) {
+    if (row === null || row.state === "STREAM_PENDING")
+        return { state: "absent" };
+    return {
+        state: row.state,
+        rev: row.rev,
+        decision: row.decision,
+        ...(row.updatedInput !== undefined ? { updatedInput: row.updatedInput } : {}),
+    };
+}
 export const APPROVAL_ASK_TABLE = "approval_ask";
 export const APPROVAL_BATCH_TABLE = "approval_batch";
 export const TIDB_APPROVAL_ASK_STATEMENTS = [
@@ -278,6 +288,9 @@ function patchColumns(patch, json) {
 function ph(dialect, n) {
     return dialect === "tidb" ? "?" : `$${n}`;
 }
+function pendingClaimWhere(dialect, firstParam) {
+    return `ask_id = ${ph(dialect, firstParam)} AND batch_id = ${ph(dialect, firstParam + 1)} AND state = 'STREAM_PENDING'`;
+}
 export class SqlApprovalAskStore {
     db;
     constructor(db) {
@@ -366,6 +379,7 @@ export class SqlApprovalAskStore {
         if (decision.idempotencyKey != null)
             assertIdempotencyKeyShape(decision.idempotencyKey);
         const now = Date.now();
+        const dialect = this.db.dialect;
         const conn = await this.db.connect();
         try {
             await conn.begin();
@@ -376,7 +390,7 @@ export class SqlApprovalAskStore {
             }
             let askRes;
             try {
-                askRes = await conn.query(this.q(`UPDATE ${APPROVAL_ASK_TABLE} SET state='DECIDED', decision=?, decision_actor=?, decision_note=?, updated_input=?, decided_at_ms=?, idempotency_key=?, rev=rev+1, updated_at_ms=? WHERE ask_id=? AND state='STREAM_PENDING'`, `UPDATE ${APPROVAL_ASK_TABLE} SET state='DECIDED', decision=$1, decision_actor=$2, decision_note=$3, updated_input=$4, decided_at_ms=$5, idempotency_key=$6, rev=rev+1, updated_at_ms=$7 WHERE ask_id=$8 AND state='STREAM_PENDING'`), [
+                askRes = await conn.query(`UPDATE ${APPROVAL_ASK_TABLE} SET state='DECIDED', decision=${ph(dialect, 1)}, decision_actor=${ph(dialect, 2)}, decision_note=${ph(dialect, 3)}, updated_input=${ph(dialect, 4)}, decided_at_ms=${ph(dialect, 5)}, idempotency_key=${ph(dialect, 6)}, rev=rev+1, updated_at_ms=${ph(dialect, 7)} WHERE ${pendingClaimWhere(dialect, 8)}`, [
                     decision.decision,
                     decision.decisionActor == null ? null : this.json(decision.decisionActor),
                     decision.decisionNote ?? null,
@@ -385,6 +399,7 @@ export class SqlApprovalAskStore {
                     decision.idempotencyKey ?? null,
                     now,
                     askId,
+                    batchId,
                 ]);
             }
             catch (err) {
@@ -416,20 +431,32 @@ export class SqlApprovalAskStore {
             throw new Error(`decideAsk: row vanished after commit (askId=${askId})`);
         return { ok: true, row };
     }
-    async expireAsk(askId, batchId) {
+    async claimTerminal(askId, batchId, intent) {
+        const to = intent === "expire" ? "PARKING" : "VOID";
+        if (!canAskTransition("STREAM_PENDING", to)) {
+            throw new Error(`approval-ask-store.claimTerminal: illegal terminal claim STREAM_PENDING -> ${to} (askId=${askId})`);
+        }
         const now = Date.now();
+        const dialect = this.db.dialect;
         const conn = await this.db.connect();
         try {
-            await conn.begin();
-            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) {
-                await conn.rollback();
-                return { won: false, voidedSiblings: [] };
+            await conn.beginPessimistic();
+            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) {
+                    await conn.rollback();
+                    return { claimed: false, current: { state: "absent" } };
+                }
             }
-            const askRes = await conn.query(this.q(`UPDATE ${APPROVAL_ASK_TABLE} SET state='PARKING', rev=rev+1, updated_at_ms=? WHERE ask_id=? AND state='STREAM_PENDING'`, `UPDATE ${APPROVAL_ASK_TABLE} SET state='PARKING', rev=rev+1, updated_at_ms=$1 WHERE ask_id=$2 AND state='STREAM_PENDING'`), [now, askId]);
+            const askRes = await conn.query(`UPDATE ${APPROVAL_ASK_TABLE} SET state = ${ph(dialect, 1)}, rev = rev + 1, updated_at_ms = ${ph(dialect, 2)} WHERE ${pendingClaimWhere(dialect, 3)}`, [to, now, askId, batchId]);
             if (askRes.affected !== 1) {
+                const sel = await conn.query(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ${ph(dialect, 1)} AND batch_id = ${ph(dialect, 2)} FOR UPDATE`, [askId, batchId]);
                 await conn.rollback();
-                return { won: false, voidedSiblings: [] };
+                return { claimed: false, current: projectAskTerminalClaimTruth(sel.rows[0] ? mapAskRow(sel.rows[0]) : null) };
+            }
+            if (intent === "cancel") {
+                await conn.commit();
+                return { claimed: true, voidedSiblings: [] };
             }
             await conn.query(this.q(`UPDATE ${APPROVAL_BATCH_TABLE} SET state='ROUTING_UNBOUND', rev=rev+1, updated_at_ms=? WHERE batch_id=? AND state='OPEN'`, `UPDATE ${APPROVAL_BATCH_TABLE} SET state='ROUTING_UNBOUND', rev=rev+1, updated_at_ms=$1 WHERE batch_id=$2 AND state='OPEN'`), [now, batchId]);
             let voidedSiblings;
@@ -449,7 +476,7 @@ export class SqlApprovalAskStore {
                 }
             }
             await conn.commit();
-            return { won: true, voidedSiblings };
+            return { claimed: true, voidedSiblings };
         }
         catch (err) {
             try {
@@ -463,6 +490,10 @@ export class SqlApprovalAskStore {
             conn.release();
         }
     }
+    async expireAsk(askId, batchId) {
+        const res = await this.claimTerminal(askId, batchId, "expire");
+        return res.claimed ? { won: true, voidedSiblings: res.voidedSiblings } : { won: false, voidedSiblings: [] };
+    }
     async bindBatch(batchId, askId, gate) {
         const now = Date.now();
         const conn = await this.db.connect();

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

@@ -120,6 +120,18 @@ export interface PendingCheckpoint {
      * 展示/分诊用,永不参与 resume / gate / CAS(core 同款 ECHO-ONLY 定性)。
      */
     hasBidiControls?: true;
+    /**
+     * [ref]([ref]② core 点名 / [ref] 认领):**内容问句分型键** —— `"content_ask"` 当这条 tool_approval
+     * park 门住的是保留工具 AskUserQuestion(问用户的问题,不是副作用工具),消费端(cli/壳审批面)据它
+     * 渲问句 UI 而不用嗅探 `toolName`。词与判据 = core `summarizeCheckpoint` 的同一行规则(行上 core 铸的
+     * `toolName` 的**全函数**派生;词属主 `approval-content-kind.ts`,parity 钉看漂移)——**不是**
+     * `hasBidiControls` 那类「server 不重算」的扫描位:派生 ≠ 重扫。
+     * 🔴 `"content_ask"` 或**缺席**([ref]② OMIT 纪律,恒不铸 `null`/`false`):缺席 = 非内容问句门
+     * (普通工具门 / 非工具 park / toolName 缺席的存量行)。展示/分诊用,永不参与 resume / gate / CAS。
+     * 两条 durable 读面(`GET /v1/approvals` 行 + `/stream` `pending` 帧)经同一投影同时携带;live 腿的
+     * 同名键在 `LivePendingRow.contentKind`(同一词属主)。
+     */
+    contentKind?: "content_ask";
 }
 /**
  * [ref]([ref] / DEBTS [ref]):session 键读口(`findPendingTokenBySession` / `peekPendingScope`)的**行绑定**。

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

@@ -1,3 +1,4 @@
+import { contentKindOf } from "../approval-content-kind.js";
 import { createHash } from "node:crypto";
 import { APPROVAL_GATE_KINDS_SQL_IN } from "../tool-approval.js";
 import { CheckpointError, MAX_RULE_TEXT_CHARS, validatePendingSteer, appendPendingSteer, checkpointVersionOf, winnerFromOutcome, summarizeCheckpoint, MAX_SUPPORTED_CHECKPOINT_VERSION, } from "@sema-agent/core";
@@ -437,6 +438,7 @@ export class SqlCheckpointStore {
             ? await this.db.query(`${base}${this.q(" AND c.scope=?", " AND c.scope=$1")} ORDER BY c.created_at_ms ASC`, [scope])
             : await this.db.query(`${base} ORDER BY c.created_at_ms ASC`);
         const out = rows.map((r) => {
+            const toolName = r.tool_name ?? null;
             const toolCallId = r.tool_call_id ?? null;
             const boundInputHash = r.bound_input_hash ?? null;
             const gateKind = r.gate_kind ?? null;
@@ -444,7 +446,7 @@ export class SqlCheckpointStore {
             return {
                 sessionId: String(r.session_id),
                 scope: String(r.scope),
-                toolName: r.tool_name ?? null,
+                toolName,
                 toolCallId,
                 ...(toolCallId !== null ? { boundCallId: toolCallId } : {}),
                 ...(boundInputHash !== null ? { boundInputHash } : {}),
@@ -456,6 +458,7 @@ export class SqlCheckpointStore {
                 riskDescriptor: readRiskDescriptorCell(r.risk_descriptor),
                 ...(ruleOffers !== undefined ? { ruleOffers } : {}),
                 ...(Number(r.has_bidi_controls) === 1 ? { hasBidiControls: true } : {}),
+                ...(contentKindOf(toolName) !== undefined ? { contentKind: "content_ask" } : {}),
             };
         });
         return out.sort((a, b) => (b.riskDescriptor?.severity ?? 0) - (a.riskDescriptor?.severity ?? 0) || a.createdAt - b.createdAt);

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

@@ -44,7 +44,7 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type SqlDriver } from "./sql-driver.js";
-import { type AcquireConnectionInput, type AcquireConnectionResult, type AppendAuditInput, type BindSessionInput, type BindSessionResult, type ConsumeEnrollTokenInput, type ConsumeEnrollTokenResult, type DeviceAdmissionView, type DeviceAuditRow, type DeviceEnrollTokenRow, type DeviceOwner, type DeviceRow, type DeviceSessionRow, type DeviceStore, type HeartbeatConnectionInput, type IssueEnrollTokenInput, type ListAuditFilter, type RevokeDeviceInput, type RevokeDeviceResult } from "../device-store.js";
+import { type AcquireConnectionInput, type AcquireConnectionResult, type AppendAuditInput, type BindSessionInput, type BindSessionResult, type ConsumeEnrollTokenInput, type ConsumeEnrollTokenResult, type DeviceAdmissionView, type DeviceAuditRow, type DeviceEnrollTokenRow, type DeviceOwner, type DeviceRow, type DeviceSessionRow, type DeviceStore, type HeartbeatConnectionInput, type IssueEnrollTokenInput, type ListAuditFilter, type RebindSessionInput, type RebindSessionResult, type RevokeDeviceInput, type RevokeDeviceResult } from "../device-store.js";
 /**
  * ── 命名(**落库一律单数**,与设计稿的复数形不同)──────────────────────────────────────────────────
  * design v2 §6 的 DDL 写的是 `devices` / `device_sessions` / `device_enrollment_tokens`(复数),但本仓有一条
@@ -62,6 +62,29 @@ export declare const TIDB_DEVICE_STATEMENTS: readonly string[];
 export declare function ensureTiDBDeviceSchema(pool: MySqlPool): Promise<void>;
 type PgQuery = (sql: string, params?: unknown[]) => Promise<unknown>;
 export declare function ensurePgDeviceSchema(q: PgQuery): Promise<void>;
+/**
+ * O4 升级前置探针 —— **拒启,不是 warn**([ref]/[ref]/[ref] `assert*Schema` 族先例):`device_audit` 的
+ * 事件闭集加了第 9 员 `session_rebound`,而 `CREATE TABLE IF NOT EXISTS` 对存量表是空操作 ⇒ 一台没
+ * 重建表就升上来的 **PG** 部署(PG 强制 CHECK;TiDB 默认 `tidb_enable_check_constraint=OFF` 不执行,
+ * 见 AUDIT_EVENT_CHECK 头注的真库实测),每一次换绑赢 CAS 都在**审计 INSERT** 上撞
+ * `ck_device_audit_event` ⇒ 整事务回滚,换绑动词在运行期恒 500 —— 而启动与健康检查全绿。
+ *
+ * 判据 = **能力探测**(begin → 插一行 `session_rebound` → rollback,探针行永不落地),不读
+ * information_schema 元数据(memory `capability-detection-not-impl-names`:判「装没装」用能力面 ——
+ * TiDB 上 CHECK 元数据在而不执行,读元数据会把能写的表误判成不能写)。只有**可证**的 CHECK 拒
+ * ({@link isCheckViolationError})才换成指路;其余错误原样上抛([ref] 两轮收窄的同一条:一句指向
+ * 手工 DDL 的指路比它要挡的缺陷更贵)。
+ *
+ * 🔴 指路刻意**不是** `DROP TABLE`(与兄弟探针不同):`device_audit` 是安全轴审计史,为扩一个词表
+ * 销毁全部审计行不成比例。本仓不发 `ALTER TABLE`(SCHEMA POLICY),但闭集执法的权威本就在应用层
+ * (读侧 `parseDeviceAuditEvent`),CHECK 只是纵深 —— 所以给运维的是**手工**约束级重建语句
+ * (drop + 按当前闭集 add),历史一行不丢,纵深回到当前词表。
+ *
+ * 调用点:`boot/stores.ts`,**只在 device 车道真会装配时探**(`config.remoteExec?.provider ===
+ * "device"`,与 main.ts 的 `createDeviceLane` 谓词同源)——非 device 部署零审计写点,为它拒启是纯误伤
+ * ([ref] round2 的同一条收窄)。
+ */
+export declare function assertDeviceAuditRebindEventSchema(db: SqlDriver): Promise<void>;
 export declare class SqlDeviceStore implements DeviceStore {
     private readonly db;
     constructor(db: SqlDriver);
@@ -82,6 +105,8 @@ export declare class SqlDeviceStore implements DeviceStore {
     readDeviceForAdmission(deviceId: string, owner: DeviceOwner): Promise<DeviceAdmissionView | null>;
     getDeviceUnscoped(deviceId: string): Promise<DeviceRow | null>;
     listDevicesByOwner(owner: DeviceOwner): Promise<DeviceRow[]>;
+    /** O4/S-4 operator 全量(消费点必须先过 explicit operator 门 —— 契约注见 `DeviceStore`)。 */
+    listDevicesUnscoped(): Promise<DeviceRow[]>;
     /**
      * 吊销 = 终态 CAS(`status='active'` 前态)+ **租约作废 + 世代推进**(§8-R4 在途语义):
      * 世代一推,在途连接的每一次带世代谓词的写(心跳/结果帧入账)当场影响 0 行 ⇒ 设备侧立即失权。
@@ -113,6 +138,18 @@ export declare class SqlDeviceStore implements DeviceStore {
      * 输家回读既有行 —— 同 deviceId = 幂等成功,异 deviceId = `conflict`(无未定义态)。
      */
     bindSession(input: BindSessionInput): Promise<BindSessionResult>;
+    /**
+     * O4 显式换绑(2026-08-30 v2 稿 §2)—— **单事务**:目标设备门(当前读)+ 幂等短路 + 前态 CAS +
+     * `session_rebound` 审计行一起提交。三形语义 oracle = `InMemoryDeviceStore.rebindSession`。
+     *
+     * 🔴 `beginPessimistic` + 两次 `FOR UPDATE`(bindSession 的同一条真库红的射程):
+     *  · 设备行必须当前读 —— 快照读会把「与吊销并发的换绑」绑到一台刚被吊销的设备上(double-admit 形);
+     *  · 绑定行必须当前读且**持锁到提交** —— 两个并发换绑(同 expectedRev)在锁上串行:赢家 rev+1 提交,
+     *    输家的锁读看到新 rev ⇒ 走 `rev_conflict` 携当前行(单赢家,无未定义态)。锁读判等之后,CAS
+     *    UPDATE(`rev = ?` 谓词 + `rev+1` 恒变列)在持锁下不可能 0 行 —— 0 行即驱动/引擎异常,响亮抛,
+     *    不折成业务分支([ref]:未知失败不伪装成正常拒绝)。
+     */
+    rebindSession(input: RebindSessionInput): Promise<RebindSessionResult>;
     getSessionBinding(rootSessionId: string): Promise<DeviceSessionRow | null>;
     deleteByRootSession(rootSessionId: string): Promise<number>;
     appendAudit(input: AppendAuditInput): Promise<void>;

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

@@ -1,6 +1,6 @@
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
-import { isDupKeyError } from "./sql-errors.js";
-import { DEVICE_AUDIT_EVENTS, assertAcquireShape, assertDeviceIdShape, assertDeviceOwnerShape, assertEnrollTokenHashShape, assertIssueTokenShape, assertNewDeviceShape, assertRevokeShape, assertRootSessionIdShape, assertWholeSeconds, parseDeviceAuditEvent, parseDevicePlatformOs, parseDeviceStatus, } from "../device-store.js";
+import { isDupKeyError, isCheckViolationError } from "./sql-errors.js";
+import { DEVICE_AUDIT_EVENTS, assertAcquireShape, assertDeviceIdShape, assertDeviceOwnerShape, assertEnrollTokenHashShape, assertIssueTokenShape, assertNewDeviceShape, assertRebindShape, assertRevokeShape, assertRootSessionIdShape, assertWholeSeconds, parseDeviceAuditEvent, parseDevicePlatformOs, parseDeviceStatus, } from "../device-store.js";
 export const DEVICES_TABLE = "device";
 export const DEVICE_ENROLL_TOKENS_TABLE = "device_enroll_token";
 export const DEVICE_SESSIONS_TABLE = "device_session";
@@ -149,6 +149,39 @@ export async function ensurePgDeviceSchema(q) {
     await q(`CREATE INDEX IF NOT EXISTS idx_device_audit_device ON ${DEVICE_AUDIT_TABLE} (device_id, at)`);
     await q(`CREATE INDEX IF NOT EXISTS idx_device_audit_event ON ${DEVICE_AUDIT_TABLE} (event, at)`);
 }
+export async function assertDeviceAuditRebindEventSchema(db) {
+    const conn = await db.connect();
+    try {
+        await conn.begin();
+        try {
+            await conn.query(db.dialect === "tidb"
+                ? `INSERT INTO ${DEVICE_AUDIT_TABLE} (at, event, device_id, owner_tenant, owner_subject, detail) VALUES (NOW(3), ?, NULL, NULL, NULL, NULL)`
+                : `INSERT INTO ${DEVICE_AUDIT_TABLE} (at, event, device_id, owner_tenant, owner_subject, detail) VALUES (now(), $1, NULL, NULL, NULL, NULL)`, ["session_rebound"]);
+        }
+        catch (err) {
+            if (!isCheckViolationError(err, db.dialect))
+                throw err;
+            const remedy = db.dialect === "pg"
+                ? `ALTER TABLE ${DEVICE_AUDIT_TABLE} DROP CONSTRAINT ck_device_audit_event; ALTER TABLE ${DEVICE_AUDIT_TABLE} ADD CONSTRAINT ck_device_audit_event CHECK (event IN (${AUDIT_EVENT_CHECK}));`
+                : `ALTER TABLE ${DEVICE_AUDIT_TABLE} DROP CHECK ck_device_audit_event; ALTER TABLE ${DEVICE_AUDIT_TABLE} ADD CONSTRAINT ck_device_audit_event CHECK (event IN (${AUDIT_EVENT_CHECK}));`;
+            throw new Error(`${DEVICE_AUDIT_TABLE} still carries a pre-O4 event CHECK that rejects 'session_rebound' — refusing to start. ` +
+                "The rebind verb (POST /v1/devices/sessions/:rootSessionId/rebind) writes this audit event in the same transaction " +
+                "as its CAS, so on this table every rebind would fail at runtime after a healthy-looking boot. This repository ships " +
+                "no ALTER TABLE migrations, and dropping an AUDIT table would destroy security-axis history — run the manual " +
+                `constraint rebuild instead (history preserved, defense-in-depth restored to the current closed set): \`${remedy}\` ` +
+                "The application layer remains the enforcing authority for this closed set (parseDeviceAuditEvent). " +
+                `Underlying probe error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await conn.rollback();
+    }
+    catch (err) {
+        await conn.rollback().catch(() => undefined);
+        throw err;
+    }
+    finally {
+        conn.release();
+    }
+}
 const ms = (dialect, col, alias) => dialect === "tidb" ? `ROUND(UNIX_TIMESTAMP(${col}) * 1000) AS ${alias}` : `(EXTRACT(EPOCH FROM ${col}) * 1000)::bigint AS ${alias}`;
 const NOW = (dialect) => (dialect === "tidb" ? "NOW(3)" : "now()");
 const nowPlusSeconds = (dialect, placeholder) => dialect === "tidb" ? `NOW(3) + INTERVAL ${placeholder} SECOND` : `now() + (${placeholder}::double precision * INTERVAL '1 second')`;
@@ -413,6 +446,10 @@ export class SqlDeviceStore {
         const { rows } = await this.db.query(this.q(`SELECT ${deviceCols("tidb")} FROM ${DEVICES_TABLE} WHERE owner_tenant = ? AND owner_subject = ? ORDER BY device_id ASC`, `SELECT ${deviceCols("pg")} FROM ${DEVICES_TABLE} WHERE owner_tenant = $1 AND owner_subject = $2 ORDER BY device_id ASC`), [owner.tenant, owner.subject]);
         return rows.map(mapDeviceRow);
     }
+    async listDevicesUnscoped() {
+        const { rows } = await this.db.query(this.q(`SELECT ${deviceCols("tidb")} FROM ${DEVICES_TABLE} ORDER BY device_id ASC`, `SELECT ${deviceCols("pg")} FROM ${DEVICES_TABLE} ORDER BY device_id ASC`));
+        return rows.map(mapDeviceRow);
+    }
     async revokeDevice(input) {
         assertRevokeShape(input);
         const conn = await this.db.connect();
@@ -515,6 +552,49 @@ export class SqlDeviceStore {
             conn.release();
         }
     }
+    async rebindSession(input) {
+        assertRebindShape(input);
+        const conn = await this.db.connect();
+        try {
+            await conn.beginPessimistic();
+            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();
+                return { outcome: "device_not_found" };
+            }
+            const cur = await conn.query(this.q(`SELECT ${sessionCols("tidb")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = ? AND owner_tenant = ? AND owner_subject = ? FOR UPDATE`, `SELECT ${sessionCols("pg")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = $1 AND owner_tenant = $2 AND owner_subject = $3 FOR UPDATE`), [input.rootSessionId, input.owner.tenant, input.owner.subject]);
+            if (!cur.rows[0]) {
+                await conn.rollback();
+                return { outcome: "binding_not_found" };
+            }
+            const row = mapSessionRow(cur.rows[0]);
+            if (row.deviceId === input.toDeviceId && row.rev === input.expectedRev) {
+                await conn.rollback();
+                return { outcome: "idempotent", row };
+            }
+            if (row.rev !== input.expectedRev) {
+                await conn.rollback();
+                return { outcome: "rev_conflict", row };
+            }
+            const cas = await conn.query(this.q(`UPDATE ${DEVICE_SESSIONS_TABLE} SET device_id = ?, bound_at = NOW(3), rev = rev + 1 WHERE root_session_id = ? AND owner_tenant = ? AND owner_subject = ? AND rev = ?`, `UPDATE ${DEVICE_SESSIONS_TABLE} SET device_id = $1, bound_at = now(), rev = rev + 1 WHERE root_session_id = $2 AND owner_tenant = $3 AND owner_subject = $4 AND rev = $5`), [input.toDeviceId, input.rootSessionId, input.owner.tenant, input.owner.subject, input.expectedRev]);
+            if (cas.affected !== 1) {
+                throw new Error(`device-store: rebind CAS affected ${cas.affected} rows under a held row lock — engine anomaly, refusing to guess`);
+            }
+            await this.insertAuditOn(conn, { event: "session_rebound", deviceId: input.toDeviceId, owner: row.owner, detail: { from: row.deviceId, to: input.toDeviceId, rev: row.rev + 1 } });
+            const { rows } = await conn.query(this.q(`SELECT ${sessionCols("tidb")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = ?`, `SELECT ${sessionCols("pg")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = $1`), [input.rootSessionId]);
+            await conn.commit();
+            if (!rows[0])
+                throw new Error("device-store: rebound session binding vanished inside its own transaction");
+            return { outcome: "rebound", row: mapSessionRow(rows[0]) };
+        }
+        catch (err) {
+            await conn.rollback().catch(() => undefined);
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+    }
     async getSessionBinding(rootSessionId) {
         assertRootSessionIdShape(rootSessionId);
         const { rows } = await this.db.query(this.q(`SELECT ${sessionCols("tidb")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = ?`, `SELECT ${sessionCols("pg")} FROM ${DEVICE_SESSIONS_TABLE} WHERE root_session_id = $1`), [rootSessionId]);

package/dist/plugins/file-run-store.js

@@ -453,6 +453,7 @@ export class FileRunStore {
                 continue;
             const sorted = [...arr].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || (a.taskId < b.taskId ? 1 : a.taskId > b.taskId ? -1 : 0));
             const latest = sorted[0];
+            const latestRunId = latest.result?.runId;
             const times = arr.map((r) => r.createdAt.getTime());
             const last = Math.max(...times);
             const first = Math.min(...times);
@@ -465,6 +466,7 @@ export class FileRunStore {
                 objectivePreview: latest.objectivePreview,
                 lastStatus: latest.status,
                 lastRunId: latest.taskId,
+                ...(typeof latestRunId === "string" && latestRunId !== "" ? { lastTaskRunId: latestRunId } : {}),
                 title: null,
             });
         }

package/dist/plugins/local-checkpoint-store.js

@@ -1,3 +1,4 @@
+import { contentKindOf } from "../approval-content-kind.js";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, renameSync, unlinkSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -160,6 +161,7 @@ export class LocalCheckpointStore {
                     return rs !== undefined ? { ruleOffers: rs } : {};
                 })(),
                 ...(pa?.hasBidiControls === true ? { hasBidiControls: true } : {}),
+                ...(contentKindOf(pa?.toolName ?? null) !== undefined ? { contentKind: "content_ask" } : {}),
             });
         }
         return rows.sort((a, b) => (b.riskDescriptor?.severity ?? 0) - (a.riskDescriptor?.severity ?? 0) || a.createdAt - b.createdAt);

package/dist/plugins/local-session-store.d.ts

@@ -27,6 +27,7 @@ export declare class LocalSessionStore implements SessionStore {
      *  has only TERMINAL runs (no live tail to re-attach), so `lastRunId` falls back to null and the shell uses its
      *  no-anchor path — same posture as the other local degrades here (runCount:0, lastStatus:""). Persisting it would
      *  need a sidecar-format change (the #10 clobber area); deferred until a real local-file-backed need. */
+    /** K-5c/[ref]/[ref]:per-session 最近一次 run 的 {taskId, runId?}(noteTaskRun 席;runId omit ⇒ 清座)。 */
     private readonly lastTaskRun;
     /** 2c P1d-β — live staged-import handles keyed by stagingId, so a local staging's in-memory buffer is readable via
      *  readStagedEntries (the durable twins re-read the staged session_event rows; local has no such rows). */
@@ -173,15 +174,14 @@ export declare class LocalSessionStore implements SessionStore {
     /** K-5c (core 1.155 SessionStore seam): core's Runner calls this at runTask START with the run's taskId, so the
      *  latest run surfaces as `lastRunId` on listSessions even while it is still running/suspended (the local backend
      *  has no runs ledger to derive it from, unlike the TiDB/PG twins). In-memory, last-write-wins per session.
-     *  [ref](core 5.65 增量批,**有意缓议**):core 的第三参 engine runId 在此**尚未消费**——它唯一的
-     *  合法出口是 listSessions 行上的 `lastTaskRunId`,而 `SessionSummary` 是 canonical spec 的**闭集**
-     *  (sema-sdk spec/openapi.yaml `additionalProperties:false`,producer-contract sessionsList 格咬着),
-     *  加键是跨仓 spec 节拍的事。spec 开键那一批再落:map 值扩成 `{taskId, runId?}` + 两座同动清座语义
-     *  (对齐 core TtlSessionStore.noteTaskRun 的 omit⇒clear,session-store.js 亲读)+ 行投影。
-     *  codex 5.65 增量批 R1-[medium] 曾建议「存储先行、投影另批」——**驳**:本店 runId 的唯一读点就是
-     *  行投影,先写不读=黑盒不可测的死状态(红先律无红可铺);清座语义单独存在也无观察面。存储与投影
-     *  必须同批,债主=sessions 列表 wire 键的 spec 节拍批(本注即债的定位锚)。 */
-    noteTaskRun(sessionId: string, taskId: string): void;
+     *  [ref] → [ref]([ref] 兑现;上一版「有意缓议」注即本批债锚,兑现随批撤):第三参 engine runId
+     *  自本批起**消费** —— map 值 {taskId, runId?} + 行投影 `lastTaskRunId` + **两座同动清座**(omit ⇒
+     *  清 runId 座,对齐 core TtlSessionStore.noteTaskRun 的 omit⇒clear 契约,core session.d.ts:204-212
+     *  亲读:旧 run 的 runId 挂在新 task 旁 = 把上一条 run 的身份错标给新 run)。存储与行投影同批落
+     *  (codex 5.65 R1-[medium]「存储先行、投影另批」之驳仍成立:本店 runId 唯一读点即行投影)。
+     *  wire 半场:HTTP 面零投影透传(sessions-list.ts,additive 键随行上 wire);sema-sdk spec
+     *  `SessionSummary` 闭集候 SDK 开键([ref]/.82 班车)——SDK 落键即端到端闭合。 */
+    noteTaskRun(sessionId: string, taskId: string, runId?: string): void;
     /** Synthesize a session's objective preview = the most-recent USER text message (the objective the run last saw).
      *  Reads the session's entries through the repo; any read error degrades to null (never fails the list). */
     private previewOf;

package/dist/plugins/local-session-store.js

@@ -275,6 +275,7 @@ export class LocalSessionStore {
                 continue;
             const firstActivityAt = meta.createdAt || new Date(0).toISOString();
             const lastActivityAt = this.lastActivity.get(meta.id) ?? firstActivityAt;
+            const lastRun = this.lastTaskRun.get(meta.id);
             all.push({
                 sessionId: meta.id,
                 owner,
@@ -283,7 +284,8 @@ export class LocalSessionStore {
                 runCount: 0,
                 objectivePreview: await this.previewOf(meta),
                 lastStatus: "",
-                lastRunId: this.lastTaskRun.get(meta.id) ?? null,
+                lastRunId: lastRun?.taskId ?? null,
+                ...(lastRun?.runId !== undefined ? { lastTaskRunId: lastRun.runId } : {}),
                 title: this.titleState.titles.get(meta.id) ?? null,
             });
         }
@@ -298,8 +300,8 @@ export class LocalSessionStore {
             : filtered;
         return after.slice(0, opts.limit);
     }
-    noteTaskRun(sessionId, taskId) {
-        this.lastTaskRun.set(sessionId, taskId);
+    noteTaskRun(sessionId, taskId, runId) {
+        this.lastTaskRun.set(sessionId, { taskId, ...(runId !== undefined ? { runId } : {}) });
     }
     async previewOf(meta) {
         try {

package/dist/plugins/memory-run-store.js

@@ -186,6 +186,7 @@ export class MemoryRunStore {
                 continue;
             const sorted = [...arr].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || (a.taskId < b.taskId ? 1 : a.taskId > b.taskId ? -1 : 0));
             const latest = sorted[0];
+            const latestRunId = latest.result?.runId;
             const times = arr.map((r) => r.createdAt.getTime());
             const last = Math.max(...times);
             const first = Math.min(...times);
@@ -198,6 +199,7 @@ export class MemoryRunStore {
                 objectivePreview: latest.objectivePreview,
                 lastStatus: latest.status,
                 lastRunId: latest.taskId,
+                ...(typeof latestRunId === "string" && latestRunId !== "" ? { lastTaskRunId: latestRunId } : {}),
                 title: null,
             });
         }

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

@@ -1,5 +1,5 @@
 import { FilePermissionRuleStoreProvider, type RuleApprovalRecord, type RuleApprovalRecordStore, type RuleScope, type StaleRuleApprovalRecord } from "@sema-agent/core";
-import { type RuleImportTicket, type RuleTicketDecisionClock, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./permission-rule-store-sql.js";
+import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./permission-rule-store-sql.js";
 import type { PermissionRuleStoreBundle } from "../rules-consent.js";
 /**
  * `RuleApprovalRecordStore` 的 File 形。
@@ -29,17 +29,34 @@ export declare class FileRuleApprovalRecordStore implements RuleApprovalRecordSt
 /**
  * CC 导入票的 File 形。四条信任边界(principal 绑定 / TTL / 一次性原子消费 / 载荷绑定)与 SQL 形
  * **同语义**;唯一不同的是「原子」由谁保证 —— 那边是引擎行锁,这边是单进程 + 单写者(顶注)。
+ *
+ * 🔴 **每只店对自己那口钟负责**([ref]):SQL 形的 TTL 轴锚在数据库的钟上(多副本共享的唯一一口);
+ * local 形没有那样一口外部钟,它的钟就是本进程的 —— 而进程墙钟**不单调**,一次 NTP 回拨就能让一张
+ * 真实已经走满 TTL 的票复活(codex 对抗复审 r1 [high],验真后修)。所以本形自己带一枚**单调锚**:
+ * 本进程铸的票,判定钟 = `铸票墙钟 + 自铸票起单调钟走过的量`;重启后重放回来的行没有锚,如实退回墙钟。
  */
 export declare class FileRuleImportTicketStore {
     private readonly rows;
     private readonly log;
     private readonly gate;
-    constructor(dir: string, now?: () => number, onError?: (message: string) => void);
+    /** 单调钟(判定用)。与 {@link now}(墙钟,记账用)是两只不同的钟,别混。 */
+    private readonly monotonic;
+    constructor(dir: string, now?: () => number, onError?: (message: string) => void, monotonic?: () => number);
     private readonly now;
     /** 取证/自证用:本面是否因内部损坏而 fail-closed。 */
     get corrupt(): boolean;
     /** 归还本面 eager 持有的日志描述符(理由与姊妹面 {@link FileRuleApprovalRecordStore.close} 逐字同源)。 */
     close(): void;
+    /**
+     * 这一刻的**判定钟**([ref] r1-F1)。
+     *
+     * 本进程铸的票 ⇒ `铸票墙钟 + 自铸票起单调钟走过的量`:墙钟被前拨不会误杀(真实只过了几秒的票还活着),
+     * 被回拨也不会续命(单调钟照走)。重启后重放回来的行没有锚 ⇒ 退回墙钟(单调钟的零点跨进程无意义)。
+     *
+     * **给不了票额外寿命**:投影严格按单调钟前进,真实走满 TTL 必然越过 `expiresAtMs`(负控钉在
+     * `permission-rule-store-file.test.ts` 的 [ref] r1-F1 族)。
+     */
+    private decisionNowMs;
     mint(input: {
         ticketId: string;
         principal: string;
@@ -53,11 +70,11 @@ export declare class FileRuleImportTicketStore {
     }): Promise<RuleImportTicket>;
     /** 一次性**认领**。五条否定项的判序与 SQL 形逐字相同(unknown → wrong-principal → wrong-purpose →
      *  consumed → expired),于是两形的服务端日志归因可比;wire 面把五类折成同一个 404(零存在性 oracle)。 */
-    consume(ticketId: string, principal: string, purpose: RuleTicketPurpose, opts?: RuleTicketDecisionClock): Promise<RuleTicketRedeemResult>;
+    consume(ticketId: string, principal: string, purpose: RuleTicketPurpose): Promise<RuleTicketRedeemResult>;
     /** 把认领**放回去**。`mustRemainValidMs` = 放回之后至少还要能用多久 —— 撑不过就不算放回成功
      *  (理由逐字见 SQL 侧 `release` 的头注:承诺一次必然兑现不了的重试比不承诺更坏)。
      *  `claimId` = A7 的认领围栏(R1-F1):被顶替的旧持有者动不了现持有者的认领。 */
-    release(ticketId: string, principal: string, claimId: string, mustRemainValidMs?: number, opts?: RuleTicketDecisionClock): Promise<boolean>;
+    release(ticketId: string, principal: string, claimId: string, mustRemainValidMs?: number): Promise<boolean>;
     /** [ref] A7 CLAIMED → **SETTLED**。判据与 SQL 孪生逐字同源(持有**这一代**认领 ∧ 未落定;过期
      *  **刻意不设门** —— 理由逐字见 SQL 侧 `settle` 的头注:拒绝记录一件已经发生的事只会把真相丢掉)。 */
     settle(ticketId: string, principal: string, claimId: string, outcome: unknown): Promise<boolean>;
@@ -89,5 +106,6 @@ export interface FilePermissionRuleStores extends PermissionRuleStoreBundle {
 export declare function createFilePermissionRuleStores(root: string, opts?: {
     onError?: (message: string) => void;
     now?: () => number;
+    monotonic?: () => number;
 }): FilePermissionRuleStores;
 //# sourceMappingURL=permission-rule-store-file.d.ts.map