@sema-agent/server 7.150.0 → 7.152.0

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

@@ -14,7 +14,7 @@
  * SQL 孪生的文件里;它住这里,SQL 孪生经一条点名的已知欠边借它 —— 这一条边就是阶段三搬家时「服务特有面」的清单(向引擎请托的候选,只列不发)。
  * 这里零 SQL:SQL 文本、列读法与行投影仍在 SQL 孪生里。
  */
-import { type Checkpoint, type CheckpointGate, type CheckpointRowVerdict, type CheckpointSummary, type GateOutcome, type ResolvedOutcome, type RiskDescriptor, type ToolApprovalCard } from "@sema-agent/core";
+import { type Checkpoint, type CheckpointGate, type CheckpointRowVerdict, type CheckpointSummary, type GateOutcome, type ResolvedOutcome, type RiskDescriptor, type RuleOffer, type ToolApprovalCard } from "@sema-agent/core";
 import { type ParkRowFacts, type RuleOfferProjection, type SkillCardFacts } from "../approval-card.js";
 import { StoreCorruptError } from "./sql-json-column.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
@@ -94,7 +94,7 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
      * 与 `/v1/approvals/stream` 的 `pending` 帧;停驻收件 `GET /v1/assistant/inbox` 的 `inbox[]`)共用的 **join 键**,也是 409 载体 A
      * `pendingGate.checkpointId` / `terminal.paused.checkpointId` 的同一个值。**在场就是可信的那一个值,缺席就是缺席**:读法唯一 = `checkpoint-identity.ts` 的
      * `durableRowIdentity`(过信任边界 —— 不含 token、有界),没有它的行(core 5.42.0 之前停驻的老行 / 没过边界的值)**照列**、键缺席(这一行没有可 join 的身份)、
-     * 每行计一次 `server.approvals.durable-row-checkpoint-id-missing`。两只店各读自己手里的那一份(SQL 孪生读 `checkpoint` 列的成员,LOCAL 孪生读 blob)。
+     * 每行计一次 `server.approvals.durable-row-checkpoint-id-missing`。两只店同读引擎对这一行字节投的摘要({@link buildQueueActionFacts});摘要读不动的行没有这一格(缺席 + 计数)。
      */
     checkpointId?: string;
     scope: string;
@@ -124,9 +124,14 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
      * 两者都没有(同步 / workflow 委派子代、终局后的纯停驻)⇒ `null`。
      */
     taskId: string | null;
-    /** The pending tool call's args (post-hook), redacted + bounded — for tool_approval the write payload, for a
-     *  durable AskUserQuestion the question itself. Lets the approval card render WITHOUT an N+1 trace.turns
-     *  fetch. `null` for pre-migration rows (suspended before the column existed) ⇒ consumer falls back. */
+    /**
+     * 这一行待决调用的入参(钩子之后那一份)—— **读时投影,不是一列**:两孪生都从停驻快照 `tool_approval` 寄存臂的 `args`(续跑执行的同一份字节、同一次解码,{@link buildQueueActionFacts})读,
+     * 读法唯一 = {@link boundedToolInput}(`human-facing-args.ts`;与活卡 `args` 同一只判定):
+     * 问 / 计划卡 ⇒ 恒是**整份**的脱敏入参(停驻的 AskUserQuestion = 整只 `{ questions }`,题干与每个选项都在,审批人据它带答 decide);
+     * 其余动作卡与无卡的行 ⇒ 脱敏后 JSON 不超 `HUMAN_FACING_ARGS_BYTES`(32768 UTF-8 字节)时整份,超了 ⇒ 折叠标记 `{ truncated: true, bytes }`
+     * (`bytes` = 脱敏后 JSON 的 UTF-8 字节数;整份换标记,不带保留部分 —— 保留部分在 `riskDescriptor`);没有工具入参(非工具门)/ 入参序列化不出 /
+     * 快照的待决动作读不出(这样的行续跑也读不出它)⇒ `null`。卡片据它渲染,不必再 N+1 读 trace.turns。
+     */
     input: unknown;
     /**
      * 建行时刻(epoch ms)。SQL 孪生恒在场(本服务在存储体之外握着的建行时刻列)。LOCAL 孪生读引擎对这一行投的摘要(core `CheckpointSummary.createdAt`,同一可选性):
@@ -147,7 +152,8 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
      * whole-string exact `single` 在场时恒 index 0、`batch` 恒末位,core 契约基数 ≤2 —— server 侧执法帽
      * 是 `MAX_RULE_OFFERS`=4 的容忍余量,两个数的分工见该常量顶注)。
      *
-     * 🔴 **本腿的下标不是 core 的 offer index,别把它当选择键**(5.58 复审 F-3,与契约文同批改准)。
+     * 🔴 **下标 = 唯一读者读出的那份数组的下标**(兑付读的规则记录同一只读者、同一份数组 ⇒ `batchOfferIndex` 选的就是记录里那一只;以下是历史段落,留作「为什么不能
+     * 各读各的」的证据 —— 此前本腿另有一只读者,下面那条硬条款就是它的代价)。原文:**本腿的下标不是 core 的 offer index,别把它当选择键**(5.58 复审 F-3)。
      * core 的契约原话是:丢掉不认识的成员时**必须保住每个留下来成员的原始 wire 下标**,做不到的消费端
      * 「must suppress its persistence actions entirely (fail toward asking)」。本腿走的是**后者** ——
      * {@link boundedRuleOffers} 对形不合的 offer 是**逐条丢弃并压紧**的(一条坏 offer 不该让另一条真 offer
@@ -171,10 +177,8 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
      * 同一条 wire 纪律([ref]②「absent nullable field is OMITTED, not null」)。存量行(本列存在之前
      * park 的)读回同样是缺席,与「这只 ask 没有候选」在消费端读法一致:本卡无此选项。
      *
-     * 🔴 **展示用,永不参与 resume**:core 侧同款定性(「never read by the resume path, and never a rule by
-     * itself」)。本仓耐久腿今天也没有兑付口(`/v1/approvals/:id/decide` 的体不带规则位),所以它是**分诊
-     * 材料**不是承诺 —— 消费端渲这一格时要按「同副本活卡腿才兑得动」读(同 `ApprovalCardSchema.ruleOffers`
-     * 顶注那条射程说明)。
+     * 🔴 **永不参与 resume**(core 侧同款定性:「never read by the resume path, and never a rule by itself」)—— 兑它的是运维队列决断口
+     * `POST /v1/approvals/:sessionId/decide` 的 `persistRule`(唯一兑付函数,在续跑腿结清点,对着这张卡铸时的记录;有问行的停驻卡队列行投的是问行上那一份)。
      */
     ruleOffers?: readonly RuleOfferProjection[];
     /**
@@ -182,16 +186,12 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
      * 执行载荷里含至少一个 DIRECTIONAL 格式控制符(人眼读到的顺序与真正执行的字节顺序可能不同)。
      *
      * 值**完全由 core 供**:park mint 时 core 写在 `pendingAction`(tool_approval 臂)上的那一位
-     * (`PendingAction.hasBidiControls`,core [ref]),`put()` 在铸行
-     * 这一刻反范式成 `checkpoint.has_bidi_controls` 列(同行 `tool_input` / `bound_input_hash` / `gate_kind` /
-     * `risk_descriptor` / `rule_suggestions` 五列同一条「铸行时一格、读口零 blob」先例),server 不重算。
-     * ([ref] 起本读口**确实**逐行读 blob —— 只为 {@link ParkRowFacts} 那几位,且是按「本仓不发 ALTER TABLE、
-     * 加列 = 删库丢在飞 park」裁出来的代价,见 `listPending` 那一段;本位与五列的「铸行时一格」形不变。)
+     * (`PendingAction.hasBidiControls`,core [ref]),两孪生在读时经引擎派生 `checkpointIndexFacts` 从同一次整行解码取({@link buildQueueActionFacts}),server 不重算、不落列。
      *
      * 🔴 `true` **或缺席,恒不写 `false`/`null`**(core d.ts 的 OMIT 契约逐字点名 BFF:「never null, never
      * present-but-undefined, never false」):缺席 = **没检出**(干净 / core 的有界扫描没够着 / 本列诞生前
      * park 的老行),消费端**禁**读成「已确认干净」。与 `/v1/assistant/inbox` 那面的同名键同一份语义
-     * (那面由 `summarizeCheckpoint` 对老行做投影期回填;本面读列不读 blob,老行恒缺席 —— 两面的缺席
+     * (那面由 `summarizeCheckpoint` 对老行做投影期回填;本面读寄存行上那一位,老行恒缺席 —— 两面的缺席
      * 集合因此不完全相等,但两面对「缺席」的读法逐字相同)。同步腿(`tool_approval` 帧 / `approval_request`
      * 卡)的对应键是 `inputHasBidi`(E-14),名字刻意不同:那一位是 server 对帧自身序列化后的 args 算的。
      *
@@ -209,14 +209,14 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
     approvalCard?: ToolApprovalCard;
     /**
      * 这一行**本引擎续不续得了** —— core 判官 `judgeCheckpointRow` 对这一行盘上字节的判决(core 7.62.0 [ref];与助手收件箱行的 `rowVerdict`、
-     * 续跑在第一级读到的拒同一个读者、同一答),逐字投、本服务不重算不筛。判官要整行:SQL 孪生按 (库内算的 `checkpoint` 文本 sha256, 引擎构建)
-     * 记忆({@link StoredRowProjectionMemo}),未命中才按令牌批读整行;LOCAL 孪生取 core 店摘要上的同一位。
+     * 续跑在第一级读到的拒同一个读者、同一答),逐字投、本服务不重算不筛。与这一行的其余动作事实同一次整行解码({@link buildQueueActionFacts}):
+     * SQL 孪生按 (库内算的 `checkpoint` 文本 sha256, 引擎构建) 记忆整份动作事实,未命中才按令牌批读整行;LOCAL 孪生取 core 店摘要上的同一位。
      * 盘上字节读不成一只检查点的行(体是 `{}`、缺 `state`、JSON 字面 `null` / 标量 / 数组 / 非 JSON)同样判:判官对任何值都答,这种行答 `damaged`,
      * 行照列(计 `server.approvals.park-row-blob-unreadable`)—— 一行坏字节只坏它自己那一行,见 {@link SqlCheckpointStore.readStoredRow}。
-     * **在场 ⇔ 这一次列表判过这一行**:缺席只在 SQL 孪生上出现 —— 两次读之间行已离开待决,或两次读之间行的字节变了(判过的是另一份,
-     * 不拼到这一行上;下一次列表即带)。缺席**不是** `ok`。非 `ok` 的行照列(人要看到它停在哪)。
+     * **恒在场**:列出的每一行都在这一次列表里判过(SQL 孪生两次读之间行已离开待决 ⇒ 不列;字节变了 ⇒ 判的就是批读那一版,行的全部动作事实同出这一版)。
+     * 非 `ok` 的行照列(人要看到它停在哪)。
      */
-    rowVerdict?: CheckpointRowVerdict;
+    rowVerdict: CheckpointRowVerdict;
 }
 /**
  * 🔴 [ref] —— 停驻行 {@link PendingCheckpoint.taskId} 的**唯一写者**:停在这道门上的那条腿以哪个 task 在跑。
@@ -231,6 +231,62 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
  * 记录读不成非空串(数 / 对象 / 空串 —— 被改过的行)⇒ 与没记同答:方向是少一个路由键,不放宽任何判;那一行续不续得了由它的 `rowVerdict` 另说。
  */
 export declare function parkedLegTaskId(recorded: unknown, claimHolder: string | null): string | null;
+/**
+ * 🔴 **运维队列行的律:行 = 行址 + 动作事实**(两孪生同一条律、同一只投影)。
+ *
+ *  · **行址**(会话 / scope / 门型 / 建行时刻 / 截止 / 归属 run 的认领)取决断口找行用的那一处 —— SQL 孪生 = 列,LOCAL 孪生 = 引擎对这一行投的摘要({@link QueueRowAddress});
+ *  · **动作事实**(工具名、调用 id、绑定两键、入参、卡、风险描述、规则候选、bidi 位、park 行事实、`checkpointId`、引擎记下的 `rowTaskId`、技能卡两位、判决)**只出自续跑执行读的那一次
+ *    整行解码**({@link buildQueueActionFacts});解不出(字节读不成检查点 / 引擎摘要读不动)⇒ 动作事实 `null` / 缺席,判决非 `ok`。
+ *
+ * 于是「队列显示什么」与「续跑执行什么」按构造是同一份字节的同一次 `JSON.parse`:没有第二只 parser(引擎内的成员提取),也没有第二份存储(展示用的派生列)——
+ * 带外改过一格列、或原文带重复键(MariaDB 文本承载上引擎内提取取先到者、`JSON.parse` 取后到者)的行,队列显示的就是将执行的那一份。
+ */
+export interface StoredRowReading {
+    /** 判官对这一行字节的判决(读不成检查点的字节判官对原样文本作答;摘要读得动时 = 摘要上的那一位)。 */
+    readonly rowVerdict: CheckpointRowVerdict;
+    /** 字节解出的那一只对象(解不出 ⇒ 缺席)。 */
+    readonly cp?: Checkpoint;
+    /** 引擎对它投的摘要(没投成 ⇒ 缺席;「读不动」那一形由 {@link isUnreadableSummaryForm} 认)。 */
+    readonly summary?: CheckpointSummary;
+}
+/** 队列行上原样展开的动作事实键(型取自行形 {@link PendingCheckpoint},不另写一份)。 */
+export type QueueRowActionFacts = Pick<PendingCheckpoint, "toolName" | "toolCallId" | "boundCallId" | "boundInputHash" | "input" | "riskDescriptor" | "ruleOffers" | "hasBidiControls" | "approvalCard" | "rowVerdict" | keyof ParkRowFacts | keyof SkillCardFacts>;
+/**
+ * 一份停驻行字节的动作事实({@link buildQueueActionFacts} 的产物;纯数据,SQL 孪生按字节记忆它)。`checkpointId` / `recordedTaskId` 是**原值**:
+ * 前者每次列表过信任边界(`durableRowIdentity`,判据含行址上的令牌),后者每次列表与认领合成 `taskId`({@link parkedLegTaskId})—— 两者都在 {@link buildQueueRow} 里。
+ */
+export interface QueueActionFacts {
+    readonly row: QueueRowActionFacts;
+    /** 引擎摘要上的 `checkpointId`(摘要读不动 / 没投成 ⇒ `undefined`:两孪生只读摘要,不另写形检)。 */
+    readonly checkpointId: unknown;
+    /** 引擎记下的那条腿的登记行(`state.rowTaskId` 原值;字节解不出 ⇒ `undefined`)。好行与摘要读不动的行同读(判据在 {@link parkedLegTaskId})。 */
+    readonly recordedTaskId: unknown;
+}
+/**
+ * 一份停驻行字节 → 它的**动作事实**(两孪生同调这一只;律见 {@link StoredRowReading})。纯数据:同一份字节、同一引擎构建答同一份(计数臂除外)。
+ *  · 工具名 / 调用 id / 绑定 / bidi 位 / 描述 —— 引擎的派生 `checkpointIndexFacts`(写口落列用过的同一只;工具位只在 `tool_approval` 寄存臂上);
+ *  · 入参 —— 同一只寄存臂的 `args` 交 {@link boundedToolInput}(卡 = 门上那一格,{@link parkedApprovalCard});规则候选 —— {@link boundedRuleOffers}(脱敏照跑、照计数);
+ *  · park 行事实 —— {@link parkRowFacts};技能卡两位 —— 摘要上的 {@link skillCardFacts};`checkpointId` —— 摘要上的那一格。
+ * 摘要没投成或是「读不动」那一形 ⇒ 只给判决,四只可空格 `null`、其余动作事实缺席(不回存储体取任何一格);记下的 `rowTaskId` 照读解出的对象。
+ */
+export declare function buildQueueActionFacts(read: StoredRowReading): QueueActionFacts;
+/** 队列行的**行址**(两孪生各从决断口找行的那一处读:SQL = 列,LOCAL = 引擎摘要)。`token` 只进 join 键的信任边界判,**永不**上行投影。 */
+export interface QueueRowAddress {
+    readonly token: string;
+    readonly sessionId: string;
+    readonly scope: string;
+    readonly gateKind: CheckpointGate["kind"];
+    /** 读得出有限数才在场(LOCAL 读摘要;SQL 列恒在)。 */
+    readonly createdAt?: number;
+    readonly deadline: number | null;
+    /** 持着这张卡所属 run 会话认领的那条 run(SQL = `task_active` 联结,LOCAL = 文件 run 店);没有 ⇒ `null`。 */
+    readonly claimHolder: string | null;
+}
+/**
+ * 行址 + 动作事实 → 运维队列行(两孪生同调;键序与修前同)。每个键**一个写者**:插在行址之间的五只动作事实键(工具名、调用 id、绑定两键、入参)在键序位上写一次,
+ * 其余动作事实({@link QueueRowActionFacts} 去掉这五只)整体接在行址之后 —— 同一键不再先写一遍、再被展开覆写一遍(值同出 `facts.row`,覆写只是第二个写者)。
+ */
+export declare function buildQueueRow(address: QueueRowAddress, facts: QueueActionFacts): PendingCheckpoint;
 /**
  * [ref]([ref] / DEBTS [ref]):session 键读口(`findPendingTokenBySession` / `peekPendingScope`)的**行绑定**。
  *
@@ -302,43 +358,43 @@ export declare function pendingRowPrecedes(a: {
     token: string;
 }, pick?: "newest" | "oldest"): boolean;
 /**
- * `pendingAction.ruleOffers` 的**铸行侧**投影(mint 面,与 {@link boundedToolInput} 同位同待遇)。
- *
- * 四件事,一件都不能少:
- *  1. **读**(宪法 [ref] 边界必判形 / 禁裸 as-cast):blob 里的这一格是 `unknown`(旧 core / 坏行 / 未来加字段都可能)。读者只有一只 =
- *     core `readRuleOffers`(经 `approval-card.ts` 的 {@link readRuleOfferList};core 7.55.0 [ref] P1 阶段二起,修前本仓自己一份 zod 形):读不出的**整条丢弃**
- *     (不是整只丢弃)——一条坏 offer 不该让另一条真 offer 消失;多余键逐级剥、不拒收(上游 additive 加一键是 core 的常规做法,拒收会把「有供给」静默变成「无供给」);
- *     丢弃**响亮**(`server.rule-offers.offer-dropped`,修前这一腿静默)。
- *  2. **脱敏**:offer 文本是从**命令原文**铸出来的(`Bash(curl -H "Authorization: Bearer …")` 这种 exact
- *     形拼得出秘密),而 `GET /v1/approvals` 是**跨租户可见**的运维队列。落列前过 `redactSecrets` ——
- *     与同行 `tool_input` 在 mint 就 `redactDeep` 是**同一条**纪律(秘密从此连**落库**都不落,不是落了库再在两条读面各洗一遍)。
- *  3. **脱敏之后**才截长(codex 交叉复审 [medium],验真后修):`redactSecrets` 会**变长**,先按限长校验
- *     原文再脱敏会产出超限文本,而 SQL 腿有**回读**(列 → 本函数再跑一遍)、LOCAL 腿没有 ⇒ 同一份素材
- *     两个后端给出不同卡面。顺序反过来之后本函数对自己的输出**幂等**,两条腿同形。
- *  4. **限基数**:core 契约今天 ≤2,这里按 {@link MAX_RULE_OFFERS}(=4,server 侧容忍帽,两个数的
- *     分工逐字见该常量顶注)截;`batch.rules` 成员另按 {@link MAX_RULE_OFFER_BATCH_MEMBERS}(=8)截 ——
- *     一条被改坏/未来放宽的上游不该把运维队列的一行撑爆。两个截都是**前缀截**(保序)。
- *     ⚠️ **但本函数整体不保原始下标**:第 1 条的「坏的逐条丢」会压紧数组 ⇒ 中间剔除后下标前移。
- *     本腿因此是**纯展示腿**,下标不得当选择键 —— 硬条款与它站得住的理由逐字见
- *     {@link PendingCheckpoint.ruleOffers} 顶注(同步腿相反:那侧零逐条丢弃,下标恒等于 core 的 offer index)。
- *     🔴 **成员帽扣在读之前**(5.58 复审 F-2):见 {@link preboundBatchMembers} —— offer 条数那一维由
- *     {@link MAX_RULE_OFFER_SCAN} 管,成员那一维在那之前是**无界**的。
- *     🔴 **扣预算在读出之后**(合并码重扫):旧序先 `slice` 再判形,于是 ≥MAX 条坏 offer 能把唯一的真
- *     offer 挤出预算,读数是 `undefined` —— 与上面第 1 条自证的不变量(坏的丢、好的照投)正相反。扫描窗
- *     {@link MAX_RULE_OFFER_SCAN} 仍是有界的:一条被改坏成上万条的行不该让每 3s 一拍的读路径去逐条判形。
- *
- * 🔴 `opts.countRedactions`:**两条腿都照常脱敏,只有回读腿不计数**(合并码重扫;codex 复审第一轮
- * 指出「回读不脱敏」会把纵深防御一起关掉,验真后按这条收)。`redactSecrets` 对自己的输出是**值幂等、
- * 计数不幂等**(URL-userinfo / JSON 秘密字段两条 pattern 会命中自己的输出并再计一次),而回读腿正是
- * `/v1/approvals/stream` 每 3s 一拍的热路径 ⇒ 每条订阅每行每拍给 `redactions_applied_total` +1,把那个
- * 用来识别「过度脱敏 / pattern 从不触发」的指标灌成不可读。关掉的是**计数**:重扫仍在,手改过的行 /
- * 将来某条写路径漏了脱敏,读面照样兜住(运维队列跨租户可见,少脱一次的代价永远不能省)。
+ * 「不再询问」规则 project root 的**铸卡快照席**(两只 checkpoint 店的写口 `put` 在停驻那一刻读一次,落列 `card_scope_root` / local 的快照索引)。
+ * 读法 = 跑这条 run 的副本的会话 cwd 登记(与活卡铸点 `ruleScopeRootFor` 同一只函数,boot 第 6 段经后端的 `bindCardScopeRoot` 绑一次)。未绑 / 答不出 ⇒ `undefined`
+ * ⇒ 列 NULL ⇒ 兑付不铸 scope(core 答 `scope-unresolved`:只会拒,不会放宽)。scope 从不在兑付时重推(被拒的提交也能改写会话的 cwd 登记,重推出的 root 可能比快照宽)。
+ */
+export interface CardScopeRootSeat {
+    of(sessionId: string): string | undefined;
+    bind(read: (sessionId: string) => string | undefined): void;
+}
+export declare function createCardScopeRootSeat(): CardScopeRootSeat;
+/**
+ * 一只候选的**展示变换**(逐条、1:1 保位、只改字):offer 文本是从命令原文铸出来的(`Bash(curl -H "Authorization: Bearer …")` 这种 exact 形拼得出秘密),
+ * 而 `GET /v1/approvals` 是跨租户可见的运维队列 ⇒ 落列 / 投影前过 `redactSecrets`,**脱敏之后**才截长(`redactSecrets` 会变长;顺序反过来本变换对自己的输出不幂等,
+ * SQL 腿有回读、LOCAL 腿没有 ⇒ 同一份素材两个后端两种卡面)。`observe:false` = 回读腿只脱敏不计数(`/v1/approvals/stream` 每 3 s 一拍的热路径;
+ * `redactSecrets` 对自己的输出值幂等、计数不幂等)。batch 成员按 {@link MAX_RULE_OFFER_BATCH_MEMBERS} 前缀截(选择键在 offer 上,成员截不动选择键)。
+ */
+export declare function displayRuleOfferText(text: string, observe: boolean): string;
+/** 一张卡候选数组的展示形(逐条 {@link displayRuleOffer},1:1 保位 ⇒ 下标与读出的那份数组同一个空间)。空 ⇒ `undefined`(无供给:键不落列、不投)。 */
+export declare function displayRuleOffers(offers: readonly RuleOffer[], opts?: {
+    countRedactions?: boolean;
+}): RuleOfferProjection[] | undefined;
+/**
+ * 停驻行 `pendingAction.ruleOffers` 的**投影**(铸行 / 回读 / LOCAL 孪生三条腿同调)= 唯一读者 {@link readCardRuleOffers} 读出的那份数组 × 展示变换 {@link displayRuleOffers}。
+ * 读法不在这里(此前这里另有一只读者:超尺截长、不判派生事实 ⇒ 一只展示成目录授权、规则文本却是 Bash 放行的 offer 能在队列行上出现,同一张停驻卡的重放帧与队列行
+ * 下标对不上);这里只做展示。`cardTool` = 这张卡的工具(停驻行 `pendingAction.toolName` / 列 `tool_name`):派生事实一致性判「是不是这张卡的工具与卡形」要它。
+ * 下标:投影与停驻行的规则记录读者(`tool-approval.ts`)读的是同一只读者的同一份输出 ⇒ `batchOfferIndex` 选的就是记录里那一只。
+ * 回读腿(SQL 列 `rule_suggestions` 落的是展示形)不走本函数,走 {@link storedRuleOfferProjection}:读者在铸行时已跑过,列是它的输出的展示形。
  *
- * 返回 `undefined` = **无供给**(键不落列):core 没给、给了空数组、或整只读不出。
+ * 返回 `undefined` = **无供给**(键不落列):core 没给、给了空数组、整条撤回或全被丢光。
  */
-export declare function boundedRuleOffers(raw: unknown, opts?: {
+export declare function boundedRuleOffers(raw: unknown, cardTool: string, opts?: {
     countRedactions?: boolean;
 }): RuleOfferProjection[] | undefined;
+/**
+ * SQL 腿回读列 `checkpoint.rule_suggestions` 的投影:列上躺的是铸行时 {@link boundedRuleOffers} 的输出 ⇒ 只解码({@link decodeRuleOfferProjection})+ 再过一遍展示变换
+ * (纵深防御:手改过的行也不许把凭证投上跨租户队列;回读腿不计数 —— 值幂等、计数不幂等,热路径)。对铸行输出恒等(钉在 `durable-ask-attribution-keys`)。
+ */
+export declare function storedRuleOfferProjection(raw: unknown): RuleOfferProjection[] | undefined;
 /**
  * {@link SqlCheckpointStore.get} 读到的 `checkpoint` 列字节读不成一只检查点(JSON 字面 `null` / 标量 / 数组 / 非 JSON)时抛的拒 —— 就是店的拒绝契约类
  * {@link StoreCorruptError}(`kind:"corrupt"` + 坐标,所有认它的读口原样认它),外加**引擎判官对这一格原样字节的判决**:列表面对同一格答的就是它
@@ -361,9 +417,9 @@ export declare class UnreadableCheckpointRowError extends StoreCorruptError {
 export declare function queueRowGateKind(kind: unknown): CheckpointGate["kind"] | undefined;
 export declare function isUnreadableSummaryForm(summary: CheckpointSummary): boolean;
 /**
- * 运维队列行 `riskDescriptor` 那一格的**形读者**(两孪生同调这一只):SQL 孪生对 `risk_descriptor` 列解出来的体(`decodeJsonColumn`)、LOCAL 孪生对存储体里门上的
- * `gate.riskDescriptor`。判到「是不是一只对象」为止 —— 描述符的键表属主在 core,core 没有导出它的验证器,手写一份就是第二份键集。读不出 ⇒ 这一行的描述符 `null` +
- * 计 `server.approvals.risk-descriptor-cell-unreadable`(两孪生同一个 tag、同一失败方向;放行理由见登记表)。
+ * 运维队列行 `riskDescriptor` 那一格的**形读者**:两孪生经 {@link buildQueueActionFacts} 对门上的描述符(引擎派生 `checkpointIndexFacts` 那一格)调这一只。
+ * 判到「是不是一只对象」为止 —— 描述符的键表属主在 core,core 没有导出它的验证器,手写一份就是第二份键集。读不出 ⇒ 这一行的描述符 `null` +
+ * 计 `server.approvals.risk-descriptor-cell-unreadable`(放行理由见登记表)。
  */
 export declare const readRiskDescriptorBody: import("./sql-json-column.js").JsonColumnReader<RiskDescriptor>;
 /** 分诊序读的两格(运维队列行 = 描述符里的严重度;收件箱行 = 引擎摘要的严重度)。 */
@@ -378,10 +434,12 @@ export interface TriageKeys {
 export declare function pendingTriageOrder(a: TriageKeys, b: TriageKeys): number;
 /** 运维队列行的分诊序 = {@link pendingTriageOrder} 读行上描述符的严重度(两孪生的 `listPending` 同调)。 */
 export declare function queueTriageOrder(a: PendingCheckpoint, b: PendingCheckpoint): number;
-/** Redact + size-bound a pending tool call's args for persistence/serving. JSON-roundtrips so the stored shape
- *  matches what the operator queue serves; oversized payloads collapse to a marker rather than bloating the row.
- *  Exported for the LOCAL twin (local-checkpoint-store.ts) so the operator-queue projection can't drift. */
-export declare function boundedToolInput(args: unknown): unknown;
+/**
+ * 停驻行 `input` 的投影({@link PendingCheckpoint.input})—— 两孪生经 {@link buildQueueActionFacts} 在**读时**调这一只,入参取同一次整行解码的 `tool_approval` 寄存臂 `args`,
+ * 卡 = 门上那一格(`parkedApprovalCard`)。判定 = `human-facing-args.ts` 的 `humanFacingArgs`
+ * (与活卡 `args` 同一只):整份 ⇒ 脱敏后的入参;折叠 ⇒ `{ truncated: true, bytes }`;没有工具入参 / 序列化不出 ⇒ `null`。
+ */
+export declare function boundedToolInput(args: unknown, card: ToolApprovalCard | undefined): unknown;
 /**
  * 🔴 [ref] 车5 §9 C4:`findCheckpointCandidatesForAsk` 的 typed 候选行。刻意只有对账收敛器判据 1 真需要的
  * 五件——**没有 token 之外的任何凭据面**,`token` 本身是 resume 凭据、只在服务端内部流转(同

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

@@ -1,15 +1,89 @@
-import { isGateKind, judgeCheckpointRow, MAX_RULE_TEXT_CHARS, } from "@sema-agent/core";
-import { redactDeep, redactSecrets } from "../trace/redact.js";
-import { MAX_RULE_OFFERS, MAX_RULE_OFFER_BATCH_MEMBERS, readRuleOfferList } from "../approval-card.js";
+import { checkpointIndexFacts, isGateKind, judgeCheckpointRow, MAX_RULE_TEXT_CHARS, } from "@sema-agent/core";
+import { redactSecrets } from "../trace/redact.js";
+import { humanFacingArgs } from "../human-facing-args.js";
+import { MAX_RULE_OFFER_BATCH_MEMBERS, parkRowFacts, skillCardFacts } from "../approval-card.js";
+import { decodeRuleOfferProjection, readCardRuleOffers } from "../card-rule-offers.js";
+import { parkedApprovalCard } from "../approval-content-kind.js";
+import { durableRowIdentity } from "../checkpoint-identity.js";
 import { createObjectColumnReader, StoreCorruptError } from "./sql-json-column.js";
 import { recordFailOpen } from "../observability/fail-open.js";
-const MAX_TOOL_INPUT_CHARS = 8192;
 export const TERMINAL_BACKSTOP_MS = Math.max(60_000, (Number.isFinite(Number(process.env.APPROVAL_TERMINAL_BACKSTOP_MS)) ? Number(process.env.APPROVAL_TERMINAL_BACKSTOP_MS) : 0) || 30 * 86_400_000);
 export const TERMINAL_GRACE_MS = 3_600_000;
 export const DENY_SWEEP_PAGE_ROWS = 100;
 export function parkedLegTaskId(recorded, claimHolder) {
     return typeof recorded === "string" && recorded.length > 0 ? recorded : claimHolder;
 }
+function queueRiskDescriptorOf(raw) {
+    if (raw === undefined || raw === null)
+        return null;
+    const shape = readRiskDescriptorBody(raw);
+    if (shape.problem === undefined)
+        return shape.value;
+    recordFailOpen("server.approvals.risk-descriptor-cell-unreadable");
+    return null;
+}
+export function buildQueueActionFacts(read) {
+    return immutableData(projectQueueActionFacts(read));
+}
+function immutableData(value) {
+    const freeze = (v) => {
+        if (typeof v !== "object" || v === null || Object.isFrozen(v))
+            return;
+        Object.freeze(v);
+        for (const k of Object.keys(v))
+            freeze(v[k]);
+    };
+    const copy = structuredClone(value);
+    freeze(copy);
+    return copy;
+}
+function projectQueueActionFacts(read) {
+    const recordedTaskId = read.cp?.state?.rowTaskId;
+    const { cp, summary } = read;
+    if (cp === undefined || summary === undefined || isUnreadableSummaryForm(summary)) {
+        return { row: { toolName: null, toolCallId: null, input: null, riskDescriptor: null, rowVerdict: read.rowVerdict }, checkpointId: undefined, recordedTaskId };
+    }
+    const indexed = checkpointIndexFacts(cp);
+    const tool = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction : undefined;
+    const card = parkedApprovalCard(cp.gate);
+    const ruleOffers = typeof tool?.toolName === "string" ? boundedRuleOffers(tool.ruleOffers, tool.toolName) : undefined;
+    return {
+        row: {
+            toolName: indexed.toolName,
+            toolCallId: indexed.toolCallId,
+            ...(indexed.toolCallId !== null ? { boundCallId: indexed.toolCallId } : {}),
+            ...(indexed.boundInputHash !== null ? { boundInputHash: indexed.boundInputHash } : {}),
+            input: boundedToolInput(tool?.args, card),
+            riskDescriptor: queueRiskDescriptorOf(indexed.riskDescriptor),
+            ...(ruleOffers !== undefined ? { ruleOffers } : {}),
+            ...(indexed.hasBidiControls === true ? { hasBidiControls: true } : {}),
+            ...(card !== undefined ? { approvalCard: card } : {}),
+            ...parkRowFacts(cp.pendingAction),
+            ...skillCardFacts(summary),
+            rowVerdict: read.rowVerdict,
+        },
+        checkpointId: summary.checkpointId,
+        recordedTaskId,
+    };
+}
+export function buildQueueRow(address, facts) {
+    const { toolName, toolCallId, boundCallId, boundInputHash, input, ...rest } = facts.row;
+    return {
+        sessionId: address.sessionId,
+        ...durableRowIdentity("approvals-queue", facts.checkpointId, address.token),
+        scope: address.scope,
+        toolName,
+        toolCallId,
+        ...(boundCallId !== undefined ? { boundCallId } : {}),
+        ...(boundInputHash !== undefined ? { boundInputHash } : {}),
+        gateKind: address.gateKind,
+        taskId: parkedLegTaskId(facts.recordedTaskId, address.claimHolder),
+        input,
+        ...(address.createdAt !== undefined ? { createdAt: address.createdAt } : {}),
+        deadline: address.deadline,
+        ...rest,
+    };
+}
 const GATE_KIND_IS_LIVE_RUN_PARK = {
     human: true,
     irreversible_ask: true,
@@ -25,52 +99,53 @@ export function pendingRowPrecedes(a, b, pick) {
         return a.createdAt < b.createdAt || (a.createdAt === b.createdAt && a.token < b.token);
     return a.createdAt > b.createdAt || (a.createdAt === b.createdAt && a.token > b.token);
 }
-const MAX_RULE_OFFER_SCAN = 32;
-function preboundBatchMembers(item) {
-    if (typeof item !== "object" || item === null)
-        return item;
-    const candidate = item;
-    if (candidate.kind !== "batch" || !Array.isArray(candidate.rules) || candidate.rules.length <= MAX_RULE_OFFER_BATCH_MEMBERS)
-        return item;
-    return { ...candidate, rules: candidate.rules.slice(0, MAX_RULE_OFFER_BATCH_MEMBERS) };
+export function createCardScopeRootSeat() {
+    let read;
+    return {
+        of: (sessionId) => read?.(sessionId),
+        bind: (r) => {
+            read = r;
+        },
+    };
 }
-function boundedReaderInput(raw) {
-    return Array.isArray(raw) ? raw.slice(0, MAX_RULE_OFFER_SCAN).map(preboundBatchMembers) : raw;
+export function displayRuleOfferText(text, observe) {
+    return redactSecrets(text, { observe }).slice(0, MAX_RULE_TEXT_CHARS);
 }
-export function boundedRuleOffers(raw, opts = {}) {
-    const observe = opts.countRedactions ?? true;
-    const scrub = (text) => redactSecrets(text, { observe }).slice(0, MAX_RULE_TEXT_CHARS);
-    const read = readRuleOfferList(boundedReaderInput(raw));
-    const out = [];
-    for (const { offer } of read) {
-        if (out.length >= MAX_RULE_OFFERS)
-            break;
-        switch (offer.kind) {
-            case "single":
-                out.push({ kind: "single", rule: scrub(offer.rule), match: offer.match, command: scrub(offer.command) });
-                break;
-            case "batch":
-                out.push({
-                    kind: "batch",
-                    rules: offer.rules.slice(0, MAX_RULE_OFFER_BATCH_MEMBERS).map((r) => {
-                        switch (r.kind) {
-                            case "command":
-                                return { kind: "command", rule: scrub(r.rule), match: r.match, command: scrub(r.command), segment: scrub(r.segment) };
-                            case "directoryRead":
-                                return { kind: "directoryRead", rule: scrub(r.rule), directory: scrub(r.directory), segment: scrub(r.segment) };
-                            default:
-                                throw new Error(`unknown rule-offer batch member kind: ${JSON.stringify(r)}`);
-                        }
-                    }),
-                    uncoveredSegments: offer.uncoveredSegments,
-                    ...(offer.uncoveredDetail !== undefined ? { uncoveredDetail: offer.uncoveredDetail.map((d) => ({ segment: scrub(d.segment), reason: d.reason })) } : {}),
-                });
-                break;
-            default:
-                throw new Error(`unknown rule-offer kind: ${JSON.stringify(offer)}`);
-        }
+function displayRuleOffer(offer, observe) {
+    const scrub = (text) => displayRuleOfferText(text, observe);
+    switch (offer.kind) {
+        case "single":
+            return { kind: "single", rule: scrub(offer.rule), match: offer.match, command: scrub(offer.command) };
+        case "batch":
+            return {
+                kind: "batch",
+                rules: offer.rules.slice(0, MAX_RULE_OFFER_BATCH_MEMBERS).map((r) => {
+                    switch (r.kind) {
+                        case "command":
+                            return { kind: "command", rule: scrub(r.rule), match: r.match, command: scrub(r.command), segment: scrub(r.segment) };
+                        case "directoryRead":
+                            return { kind: "directoryRead", rule: scrub(r.rule), directory: scrub(r.directory), segment: scrub(r.segment) };
+                        default:
+                            throw new Error(`unknown rule-offer batch member kind: ${JSON.stringify(r)}`);
+                    }
+                }),
+                uncoveredSegments: offer.uncoveredSegments,
+                ...(offer.uncoveredDetail !== undefined ? { uncoveredDetail: offer.uncoveredDetail.map((d) => ({ segment: scrub(d.segment), reason: d.reason })) } : {}),
+            };
+        default:
+            throw new Error(`unknown rule-offer kind: ${JSON.stringify(offer)}`);
     }
-    return out.length > 0 ? out : undefined;
+}
+export function displayRuleOffers(offers, opts = {}) {
+    const observe = opts.countRedactions ?? true;
+    return offers.length > 0 ? offers.map((o) => displayRuleOffer(o, observe)) : undefined;
+}
+export function boundedRuleOffers(raw, cardTool, opts = {}) {
+    const offers = readCardRuleOffers(raw, cardTool);
+    return offers === undefined ? undefined : displayRuleOffers(offers, opts);
+}
+export function storedRuleOfferProjection(raw) {
+    return displayRuleOffers(decodeRuleOfferProjection(raw), { countRedactions: false });
 }
 export class UnreadableCheckpointRowError extends StoreCorruptError {
     rowVerdict;
@@ -98,16 +173,20 @@ export function pendingTriageOrder(a, b) {
 export function queueTriageOrder(a, b) {
     return pendingTriageOrder({ severity: a.riskDescriptor?.severity, createdAt: a.createdAt }, { severity: b.riskDescriptor?.severity, createdAt: b.createdAt });
 }
-export function boundedToolInput(args) {
+export function boundedToolInput(args, card) {
     if (args === undefined)
         return null;
-    const redacted = redactDeep(args);
-    const json = JSON.stringify(redacted);
-    if (json === undefined)
-        return null;
-    if (json.length > MAX_TOOL_INPUT_CHARS)
-        return { truncated: true, bytes: json.length };
-    return redacted;
+    const shown = humanFacingArgs(args, card);
+    switch (shown.kind) {
+        case "whole":
+            return shown.value;
+        case "omitted":
+            return shown.bytes === null ? null : { truncated: true, bytes: shown.bytes };
+        default: {
+            const unreachable = shown;
+            throw new Error(`unhandled human-facing args reading: ${JSON.stringify(unreachable)}`);
+        }
+    }
 }
 export const DECIDED_REPLAY_SCAN_CAP = 8;
 export function approvalDecisionOfWinner(winner, boundCallId) {

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

@@ -5,6 +5,7 @@ import { WRITABLE, boundDeviceOf, settledDeviceBindOutcome, settledDeviceRebindO
 import { bindDeviceStatement, countDeviceBindingsOn, lockRootAndReadClaim, placeWriterStatement, readPlacementOn, rebindDeviceStatement, rowsOnSqlExec, writeCellOn } from "./execution-placement-sql.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn } from "./sql-json-column.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const DEVICES_TABLE = "device";
 export const DEVICE_ENROLL_TOKENS_TABLE = "device_enroll_token";
 export const DEVICE_AUDIT_TABLE = "device_audit";
@@ -616,6 +617,11 @@ export class SqlDeviceStore {
         return rows.map(mapAuditRow);
     }
 }
+sealStoreClass(SqlDeviceStore, "sql-device-store", {
+    issueEnrollToken: "exit", getEnrollToken: "exit", consumeEnrollToken: "exit", readDeviceForAdmission: "exit", getDeviceUnscoped: "exit",
+    listDevicesByOwner: "exit", listDevicesUnscoped: "exit", revokeDevice: "exit", acquireConnection: "exit", heartbeatConnection: "exit",
+    releaseConnection: "exit", placeDeviceExecution: "exit", rebindDeviceExecution: "exit", countDeviceBindings: "exit", appendAudit: "exit", listAudit: "exit",
+});
 export class TiDBDeviceStore extends SqlDeviceStore {
     constructor(pool) {
         super(mysqlDriver(pool));

package/dist/plugins/error-origin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * **错误出身记号** —— 「这只错是谁交出来的」这件事的唯一属主(叶:零 import)。词是闭集两只({@link ErrorOrigin}),读者一只:店边界 `terminal.ts` 的 `storeBoundaryFault`。
+ *  · `driver` —— 数据库驱动交出的错。写者两只、都是池座,都只**记**(不改错误对象、不记日志、不改控制流):
+ *    MySQL 协议 `sql-driver.ts` 的 `createCloseAwarePool`(借连接、池上其余返回承诺的成员)与守卫租约 `leaseOf`(语句与事务动词);
+ *    PostgreSQL `pg-pool.ts` 的 `createPgPool` 拦截层(`pool.query` / `pool.connect` 与借出 client 的 `query`)。
+ *    边界沿 `cause` 链查它 —— 与词法扳机(码出了本仓词法)是边界的两条扳机;它补的是词法看不见的那一类:驱动交出的**无码**错。
+ *  · `caller` —— 调用方自己的抛出物,店把它原样还给调用方(店在自己的体里已经把它与库错分开了:记忆补丁落地的 `confirm` 钩抛出物)。
+ *    边界见它即同一引用放行:它不是店的失败,它的类、码、身份都是调用方的(码长什么样都不换句)。写者 = 店里分开调用方抛出物的那一处(`memory-engine-sql-apply.ts`)。
+ *
+ * 为什么记号住在这只叶子里:边界函数在 `terminal.ts`,`sql-driver.ts` 的连接初始化拒句要先读边界(`terminal.ts` → `sql-driver.ts` 再反向就成环,
+ * 运行时值图零环由 `test/module-cycle-gate.test.ts` 守);池座、店与边界都只依赖这一张表。
+ */
+export type ErrorOrigin = "driver" | "caller";
+/** 打记号(原样交回,便于 `throw markErrorOrigin(err, "driver")`);非对象的抛出值记不了,原样交回。先打的词为准(同一只错不改出身)。 */
+export declare function markErrorOrigin<E>(err: E, origin: ErrorOrigin): E;
+/** 这一只对象的出身词(只看它本身;沿 `cause` 链查是读者的事);没记过 ⇒ `undefined`。 */
+export declare function errorOriginOf(err: unknown): ErrorOrigin | undefined;
+//# sourceMappingURL=error-origin.d.ts.map

package/dist/plugins/error-origin.js

@@ -0,0 +1,10 @@
+const ORIGIN = new WeakMap();
+export function markErrorOrigin(err, origin) {
+    if (typeof err === "object" && err !== null && !ORIGIN.has(err))
+        ORIGIN.set(err, origin);
+    return err;
+}
+export function errorOriginOf(err) {
+    return typeof err === "object" && err !== null ? ORIGIN.get(err) : undefined;
+}
+//# sourceMappingURL=error-origin.js.map

package/dist/plugins/execution-placement-sql.js

@@ -3,12 +3,13 @@ import { retiredExecutionLaneHintM40 } from "./execution-lane-rename-m40.js";
 import { sessionFaceFromRow } from "../session-incarnation.js";
 import { toIso } from "./sql-row-helpers.js";
 import { SESSION_EXT_TABLE, ensureSessionExtRowStatement, ensureSessionExtRowsStatement } from "./session-ext-table.js";
+import { lockSessionRootOn } from "./session-row-sql.js";
 import { WRITABLE, assertPlaceableLane, boundDeviceOf, settledMirrorOutcome, settledPlaceOutcome, } from "../execution-placement.js";
+import { sealStoreObject } from "./store-boundary.js";
 const WRITER = "writer";
 const MIRROR = "mirror";
 const NOT_WRITER = "(execution_role IS NULL OR execution_role <> 'writer')";
 const EXECUTION_CELL_COLUMNS = "execution_role, execution_lane, execution_device_id, execution_device_owner_tenant, execution_device_owner_subject, execution_placed_at, execution_rev";
-const OCCUPANT_COLUMNS = "owner, incarnation, placement_kind";
 const READING_COLUMNS = `sm.owner, sm.incarnation, sm.placement_kind, ${EXECUTION_CELL_COLUMNS.split(", ").map((c) => `se.${c}`).join(", ")}`;
 function binder(dialect) {
     const values = [];
@@ -174,9 +175,8 @@ export function placementReadingFromRow(root, row) {
 export function rowsOnSqlExec(exec) {
     return async (sql, values) => (await exec.query(sql, [...values])).rows;
 }
-async function lockRootOn(conn, dialect, root) {
-    const ph = dialect === "pg" ? "$1" : "?";
-    return (await conn(`SELECT ${OCCUPANT_COLUMNS} FROM session_meta WHERE session_id = ${ph} FOR UPDATE`, [root]))[0];
+function lockRootOn(conn, dialect, root) {
+    return lockSessionRootOn(conn, dialect, root);
 }
 export async function readClaimOn(conn, dialect, root) {
     const ph = dialect === "pg" ? "$1" : "?";
@@ -214,7 +214,7 @@ export function createSqlExecutionPlacementSeat(db) {
         const s = readPlacementRowStatement(db.dialect, root);
         return placementReadingFromRow(root, (await db.query(s.text, [...s.values])).rows[0]);
     };
-    return {
+    return sealStoreObject({
         read,
         async place(root, occupant, cell) {
             assertPlaceableLane(root, cell);
@@ -269,6 +269,6 @@ export function createSqlExecutionPlacementSeat(db) {
                 conn.release();
             }
         },
-    };
+    }, "sql-execution-placement-seat", { read: "exit", place: "exit", markMirror: "exit" });
 }
 //# sourceMappingURL=execution-placement-sql.js.map

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

@@ -7,6 +7,7 @@ import { decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, jsonColumnT
 import {} from "./store-contracts.js";
 import { isDupKeyError } from "./sql-errors.js";
 import { ensureIndexes } from "./ensure-index.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const PG_IMAGE_BAKE_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS image_bake (
      bake_id          VARCHAR(64) COLLATE "C"  NOT NULL,
@@ -521,6 +522,11 @@ export class SqlImageBake {
         }
     }
 }
+sealStoreClass(SqlImageBake, "sql-image-bake", {
+    createBake: "exit", createBakeIfIdle: "exit", getBake: "exit", getBakeByIdem: "exit", findActiveByArgv: "exit", findActiveAny: "exit",
+    findNextQueuedId: "exit", claimBake: "exit", appendEvent: "exit", maxSeq: "exit", getEvents: "exit", setStatus: "exit", setState: "exit", setTerminal: "exit",
+    setIndexId: "exit", heartbeatLease: "exit", requestCancel: "exit", isCancelRequested: "exit", reapStaleBakes: "exit",
+});
 export class TiDBImageBake extends SqlImageBake {
     constructor(pool, poolName = "standard") {
         super(mysqlDriver(pool), poolName);