@sema-agent/server 7.132.0 → 7.134.0

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

@@ -21,6 +21,8 @@ const JOURNAL_OPS = [
     "deferReconcile",
     "resolveProvisional",
     "deleteByTask",
+    "reapSettledAsks",
+    "reapEmptyBatches",
 ];
 const JOURNAL_OP_WORDS = new Set(JOURNAL_OPS);
 export const JOURNAL_OP_TABLE_GATE = true;
@@ -159,6 +161,11 @@ export class FileApprovalAskStore {
             refuse("call record without a clock reading");
         if (probe.op === "claimTerminal" && !JOURNAL_V1_CLAIM_INTENT_WORDS.has(String(raw.intent)))
             refuse("claimTerminal intent outside this build's journal set (a newer server wrote it)");
+        if (probe.op === "reapSettledAsks") {
+            const anchors = raw.keepAnchors;
+            if (!Array.isArray(anchors) || !anchors.every((a) => typeof a === "string"))
+                refuse("reapSettledAsks record without a string-array keepAnchors");
+        }
         const rec = raw;
         this.pinnedNow = rec.t;
         try {
@@ -197,6 +204,10 @@ export class FileApprovalAskStore {
                 return this.core.resolveProvisional(rec.askId, rec.from, rec.to, rec.patch);
             case "deleteByTask":
                 return this.core.deleteByTask(rec.taskId);
+            case "reapSettledAsks":
+                return this.core.reapSettledAsks(rec.cutoffMs, rec.limit, new Set(rec.keepAnchors));
+            case "reapEmptyBatches":
+                return this.core.reapEmptyBatches(rec.cutoffMs, rec.limit);
             default: {
                 const unreachable = rec;
                 throw new Error(`FileApprovalAskStore: unreachable journal op ${JSON.stringify(unreachable)}`);
@@ -244,6 +255,16 @@ export class FileApprovalAskStore {
     async deleteByTask(taskId) {
         return this.write({ op: "deleteByTask", taskId }, (c) => this.core.deleteByTask(c.taskId));
     }
+    async reapSettledAsks(cutoffMs, limit, keepAnchors) {
+        if (this.core.planReapSettledAsks(cutoffMs, limit, keepAnchors).length === 0)
+            return 0;
+        return this.write({ op: "reapSettledAsks", cutoffMs, limit, keepAnchors: [...keepAnchors].sort() }, (c) => this.core.reapSettledAsks(c.cutoffMs, c.limit, new Set(c.keepAnchors)));
+    }
+    async reapEmptyBatches(cutoffMs, limit) {
+        if (this.core.planReapEmptyBatches(cutoffMs, limit).length === 0)
+            return 0;
+        return this.write({ op: "reapEmptyBatches", cutoffMs, limit }, (c) => this.core.reapEmptyBatches(c.cutoffMs, c.limit));
+    }
     listByState(state, limit) {
         return this.core.listByState(state, limit);
     }

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

@@ -6,7 +6,7 @@
  *
  * 🔴 **S-384:本类同时是 `FileApprovalAskStore` 的内核**(local 车道的持久形不再是「第二份手抄」——
  * 它把本类**原样**包起来,每次写前先把**调用本身**落 JSONL、重放时用同一只内核重放同一串调用)。
- * 为此本类多了三件、且**只**多这三件(全是数据面,零转移判定):
+ * 为此本类多了这几件、且**只**多这几件(全是数据面,零转移判定):
  *  · {@link InMemoryApprovalAskStore.constructor} 的可注入钟 `now` —— 五个动词(decideAsk / claimTerminal /
  *    expireAsk / bindBatch / abortBatch)原先直读 `Date.now()`,那是重放路上唯一的不确定源:同一串调用
  *    重放出来的 `updatedAtMs`/`decidedAtMs` 必须与当初**逐字节**相同,否则「重放等价」是假的。
@@ -16,6 +16,8 @@
  *  · {@link InMemoryApprovalAskStore.exportRows} / {@link InMemoryApprovalAskStore.importRows} —— 压实用的
  *    整本快照口(纯搬行,不经任何谓词)。压实要把「一串调用」折成「一串终局行」,没有这一对就只能在
  *    File 形里另写一套「哪些行还算数」的判据 —— 那才是第二份手抄。
+ *  · {@link InMemoryApprovalAskStore.planReapSettledAsks} / {@link InMemoryApprovalAskStore.planReapEmptyBatches} —— 两只留存动词的
+ *    **纯读选择**(删哪些行)。File 形据它判「这一次有没有东西可删」,空的一次不落账本;删除本身仍是接口动词,与选择共用这一只。
  *
  * 行为口径与 `SqlApprovalAskStore` 逐条对齐:
  *  - ensureAsk 幂等 upsert(ask_id 已在 ⇒ 返回既有行,不改写;batch 行若不存在则以 OPEN 补齐）。
@@ -106,6 +108,21 @@ export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     deleteByTask(taskId: string): Promise<void>;
     getBatch(batchId: string): Promise<BatchRow | null>;
+    /**
+     * 留存律的问行半场(谓词见接口注,与 SQL twin 的 `DELETE … LIMIT` 同答)。方法体全同步(零 `await`)⇒ File 形把它当一次落账的调用
+     * 重放时逐字复现(cutoff / limit / 挂靠集都是调用实参,不读钟)。
+     */
+    reapSettledAsks(cutoffMs: number, limit: number, keepAnchors: ReadonlySet<string>): Promise<number>;
+    /** 留存律的批行半场(谓词见接口注,与 SQL twin 同答;同上,全同步)。 */
+    reapEmptyBatches(cutoffMs: number, limit: number): Promise<number>;
+    /**
+     * 两只留存动词会删哪些行(纯读,零写)。File 形据此判「这一次有没有东西可删」—— 空的一次不落账本(否则每次清扫都往账本里写一条什么都
+     * 没做的调用)。与删除共用这一只选择,没有第二份谓词。选哪几只:按 `(updatedAtMs, id)` 升序取前 `limit` 只 —— 确定性只为重放,律本身
+     * 不依赖次序(SQL twin 不排序)。
+     */
+    planReapSettledAsks(cutoffMs: number, limit: number, keepAnchors: ReadonlySet<string>): readonly string[];
+    /** {@link reapEmptyBatches} 的选择(同上)。 */
+    planReapEmptyBatches(cutoffMs: number, limit: number): readonly string[];
 }
 export type { AskDecision, AskState, BatchState };
 //# sourceMappingURL=approval-ask-store-memory.d.ts.map

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

@@ -1,6 +1,6 @@
-import { canAskTransition } from "../approval-ask-machine.js";
+import { ASK_TERMINAL, canAskTransition } from "../approval-ask-machine.js";
 import { APPROVAL_ENDING_CAUSES } from "../approval-deny-reasons.js";
-import { askRowOnCall, assertDecideSettledBy, assertIdempotencyKeyShape, assertIntegralEpochMs, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth } from "./approval-ask-store-sql.js";
+import { askRowOnCall, assertDecideSettledBy, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth } from "./approval-ask-store-sql.js";
 function applyPatch(row, patch) {
     if (patch.decision !== undefined)
         row.decision = patch.decision;
@@ -359,5 +359,37 @@ export class InMemoryApprovalAskStore {
         const b = this.batches.get(batchId);
         return b ? { ...b } : null;
     }
+    async reapSettledAsks(cutoffMs, limit, keepAnchors) {
+        const ids = this.planReapSettledAsks(cutoffMs, limit, keepAnchors);
+        for (const id of ids)
+            this.asks.delete(id);
+        return ids.length;
+    }
+    async reapEmptyBatches(cutoffMs, limit) {
+        const ids = this.planReapEmptyBatches(cutoffMs, limit);
+        for (const id of ids)
+            this.batches.delete(id);
+        return ids.length;
+    }
+    planReapSettledAsks(cutoffMs, limit, keepAnchors) {
+        assertReapBounds(cutoffMs, limit);
+        const anchored = (r) => keepAnchors.has(r.taskId) || keepAnchors.has(r.sessionId) || keepAnchors.has(r.sourceTaskId);
+        return [...this.asks.values()]
+            .filter((r) => ASK_TERMINAL.has(r.state) && !r.provisional && r.updatedAtMs < cutoffMs && !anchored(r))
+            .sort((a, b) => a.updatedAtMs - b.updatedAtMs || (a.askId < b.askId ? -1 : a.askId > b.askId ? 1 : 0))
+            .slice(0, limit)
+            .map((r) => r.askId);
+    }
+    planReapEmptyBatches(cutoffMs, limit) {
+        assertReapBounds(cutoffMs, limit);
+        const occupied = new Set();
+        for (const r of this.asks.values())
+            occupied.add(r.batchId);
+        return [...this.batches.values()]
+            .filter((b) => b.updatedAtMs < cutoffMs && !occupied.has(b.batchId))
+            .sort((a, b) => a.updatedAtMs - b.updatedAtMs || (a.batchId < b.batchId ? -1 : a.batchId > b.batchId ? 1 : 0))
+            .slice(0, limit)
+            .map((b) => b.batchId);
+    }
 }
 //# sourceMappingURL=approval-ask-store-memory.js.map

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

@@ -268,6 +268,8 @@ export type DecideResult = {
  *  隐式截断 —— 两方言不同答;这里改成两方言同一句 TypeError(响亮,点名字段与值),铸点侧(`tool-approval.ts`
  *  的 deadline 铸点)负责给整数,本守卫只拦漏网。 */
 export declare function assertIntegralEpochMs(field: string, value: number): void;
+/** 留存动词两只的入参门(三 twin 同判):cutoff 是整数毫秒、limit 是正整数(limit 在 SQL twin 里内联进语句)。 */
+export declare function assertReapBounds(cutoffMs: number, limit: number): void;
 export declare function assertIdempotencyKeyShape(key: string): void;
 /** `settled_by` 列宽 = 这一格的唯一尺(两方言 DDL 与下面的形门读同一个常量,不手抄第二份)。 */
 export declare const MAX_SETTLED_BY_CHARS = 16;
@@ -510,6 +512,21 @@ export interface ApprovalAskStore {
     getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
     resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     deleteByTask(taskId: string): Promise<void>;
+    /**
+     * **审批账本留存律的问账半场之一:问行**(律、节律与「还能动的 run」一处成文在 `approval-ask-retention.ts`;维护 tick 是唯一调用方)。
+     * 删至多 `limit` 只**结了**的问行 —— `state ∈ ASK_TERMINAL` ∧ `provisional = false`(provisional 行还能被 {@link resolveProvisional} 改判,没结)
+     * ∧ `updatedAtMs < cutoffMs` ∧ 行挂靠的三格(`taskId` / `sessionId` / `sourceTaskId`)都不在 `keepAnchors`(还能动的东西的挂靠集:
+     * 它还会回读这些行 —— 会话授权的争议判据 {@link listByCall} 把「这次调用在腿内没有行」读成可以代答)。非终态行多老都不删(它们归对账器
+     * 与起服收敛)。只删不改。
+     * 一条语句:要么删了并交回删掉的行数,要么一行没删就抛。三形同答(InMemory = 内核;File 形把这次调用照常落成一条账本动词,
+     * 空的一次不落;SQL 两方言 = 一条 `DELETE … LIMIT`,行谓词,多副本同扫只是一方删到零行)。
+     */
+    reapSettledAsks(cutoffMs: number, limit: number, keepAnchors: ReadonlySet<string>): Promise<number>;
+    /**
+     * **问账半场之二:批行**。删至多 `limit` 只批里已经**没有任何问行**、且自己的 `updatedAtMs < cutoffMs` 的批 —— 批是问的容器,问走光了它才走。
+     * 一条语句,同上;三形同答。
+     */
+    reapEmptyBatches(cutoffMs: number, limit: number): Promise<number>;
     /** 🔴 车1 追加(不在设计定稿 §4 的接口字面清单里):设计的 `ApprovalAskStore` 接口本身没有批读方法,
      *  但 §6 测试钉(3/6/7 条)要求断言批行的 state/boundAskId 变化——没有读口就无法验证 store 真做对了
      *  它自己承诺的事。加一个纯观测方法(不改变任何写路径行为),SQL 双方言 + InMemory 三形都实现,
@@ -667,6 +684,14 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     deferReconcile(askId: string, expectedState: AskState, expectedRev: number, nowMs: number): Promise<boolean>;
     resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     deleteByTask(taskId: string): Promise<void>;
+    /**
+     * 留存律的问行半场(谓词见接口注)。一条带 `LIMIT` 的 `DELETE`(PG 无 `DELETE … LIMIT` ⇒ `ctid IN (SELECT … LIMIT)`,与
+     * `permission-rule-store-sql.ts` 的清扫同形);终态闭集从 {@link ASK_TERMINAL} 展开成占位符,不在 SQL 里手抄态名;挂靠集对三格各一句
+     * (MySQL `NOT IN (?, …)` 三次展开、PG 同一只 `text[]` 参数用三次 `<> ALL`),空集不加。`limit` 先过整数门再内联(本仓常量,门只防将来的误用)。
+     */
+    reapSettledAsks(cutoffMs: number, limit: number, keepAnchors: ReadonlySet<string>): Promise<number>;
+    /** 留存律的批行半场(谓词见接口注):一条带 `LIMIT` 的 `DELETE`,批里有没有问 = 对问表的 `NOT EXISTS`。 */
+    reapEmptyBatches(cutoffMs: number, limit: number): Promise<number>;
     getBatch(batchId: string): Promise<BatchRow | null>;
 }
 /** MySQL-protocol(TiDB)绑定。 */

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

@@ -1,5 +1,5 @@
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
-import { canAskTransition } from "../approval-ask-machine.js";
+import { ASK_TERMINAL, canAskTransition } from "../approval-ask-machine.js";
 import { APPROVAL_ENDING_CAUSES, causeOfAskRow } from "../approval-deny-reasons.js";
 import { isDupKeyError, isMissingColumnError } from "./sql-errors.js";
 import { decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn, readTriStateJsonValueColumn } from "./sql-json-column.js";
@@ -9,6 +9,11 @@ export function assertIntegralEpochMs(field, value) {
         throw new TypeError(`approval-ask store: ${field} must be an integer epoch-ms (BIGINT column), got ${String(value)}`);
     }
 }
+export function assertReapBounds(cutoffMs, limit) {
+    assertIntegralEpochMs("cutoffMs", cutoffMs);
+    if (!Number.isSafeInteger(limit) || limit <= 0)
+        throw new Error(`approval-ask-store: reap limit must be a positive integer, got ${String(limit)}`);
+}
 export function assertIdempotencyKeyShape(key) {
     if (key.length === 0 || key.length > 255 || key.trim() !== key) {
         throw new Error(`invalid idempotency key: must be 1-255 chars with no leading/trailing whitespace (got ${JSON.stringify(key.slice(0, 32))}${key.length > 32 ? "…" : ""}, length ${key.length})`);
@@ -722,6 +727,37 @@ export class SqlApprovalAskStore {
         await this.db.query(this.q(`DELETE FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ?`, `DELETE FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1`), [taskId]);
         await this.db.query(this.q(`DELETE FROM ${APPROVAL_BATCH_TABLE} WHERE task_id = ?`, `DELETE FROM ${APPROVAL_BATCH_TABLE} WHERE task_id = $1`), [taskId]);
     }
+    async reapSettledAsks(cutoffMs, limit, keepAnchors) {
+        assertReapBounds(cutoffMs, limit);
+        const terminal = [...ASK_TERMINAL];
+        const keep = [...keepAnchors];
+        const dialect = this.db.dialect;
+        let n = 0;
+        const statePh = terminal.map(() => ph(dialect, ++n)).join(", ");
+        const cutPh = ph(dialect, ++n);
+        const ANCHOR_COLUMNS = ["task_id", "session_id", "source_task_id"];
+        let keepSql = "";
+        let keepParams = [];
+        if (keep.length > 0 && dialect === "tidb") {
+            const list = keep.map(() => "?").join(", ");
+            keepSql = ANCHOR_COLUMNS.map((c) => ` AND ${c} NOT IN (${list})`).join("");
+            keepParams = ANCHOR_COLUMNS.flatMap(() => keep);
+        }
+        else if (keep.length > 0) {
+            const arr = ph(dialect, ++n);
+            keepSql = ANCHOR_COLUMNS.map((c) => ` AND ${c} <> ALL(${arr}::text[])`).join("");
+            keepParams = [keep];
+        }
+        const where = `state IN (${statePh}) AND provisional = 0 AND updated_at_ms < ${cutPh}${keepSql}`;
+        const params = [...terminal, cutoffMs, ...keepParams];
+        const res = await this.db.query(this.q(`DELETE FROM ${APPROVAL_ASK_TABLE} WHERE ${where} LIMIT ${limit}`, `DELETE FROM ${APPROVAL_ASK_TABLE} WHERE ctid IN (SELECT ctid FROM ${APPROVAL_ASK_TABLE} WHERE ${where} LIMIT ${limit})`), params);
+        return res.affected;
+    }
+    async reapEmptyBatches(cutoffMs, limit) {
+        assertReapBounds(cutoffMs, limit);
+        const res = await this.db.query(this.q(`DELETE FROM ${APPROVAL_BATCH_TABLE} WHERE updated_at_ms < ? AND NOT EXISTS (SELECT 1 FROM ${APPROVAL_ASK_TABLE} a WHERE a.batch_id = ${APPROVAL_BATCH_TABLE}.batch_id) LIMIT ${limit}`, `DELETE FROM ${APPROVAL_BATCH_TABLE} WHERE ctid IN (SELECT b.ctid FROM ${APPROVAL_BATCH_TABLE} b WHERE b.updated_at_ms < $1 AND NOT EXISTS (SELECT 1 FROM ${APPROVAL_ASK_TABLE} a WHERE a.batch_id = b.batch_id) LIMIT ${limit})`), [cutoffMs]);
+        return res.affected;
+    }
     async getBatch(batchId) {
         const { rows } = await this.db.query(this.q(`SELECT ${BATCH_COLS} FROM ${APPROVAL_BATCH_TABLE} WHERE batch_id = ?`, `SELECT ${BATCH_COLS} FROM ${APPROVAL_BATCH_TABLE} WHERE batch_id = $1`), [batchId]);
         return rows[0] ? mapBatchRow(rows[0]) : null;

package/dist/plugins/approval-payload-fingerprint.d.ts

@@ -1,5 +1,17 @@
+/** 决议载荷 —— 指纹的输入形(两条车道 + workflow 停驻决定共用一份;成员顺序见 {@link approvalPayloadFingerprint})。 */
+export interface ApprovalPayload {
+    updatedInput?: unknown;
+    answer?: unknown;
+    reason?: string;
+    /** core 7.54.0:人写在卡上的话(引擎逐字记在赢家上,空白也记)。 */
+    feedback?: string;
+}
 /**
- * [ref] 件1(codex R2-[high] 一)—— 决议载荷的比对指纹:`[updatedInput, answer, reason]` 三件的规范串。
+ * [ref] 件1(codex R2-[high] 一)—— 决议载荷的比对指纹:`[updatedInput, answer, reason]` 三件的规范串,其后**按在场追加**后来的成员(今天一员:`feedback`)。
+ *
+ * 🔴 成员律(一条):首发的三件恒占位(缺席折 `null`);之后加进来的成员**只在在场时**追加在尾部 —— workflow 停驻决定的同一性指纹
+ * ({@link parkDecisionFingerprint} 包它)是**落了库**的,新成员若恒占位,存量决定的指纹全部换字节、一次合法的重放被判成「另一个决定」;
+ * 按在场追加 ⇒ 不带新成员的决定字节不变,带了的与不带的不可能撞(串的元素个数不同)。
  *
  * 为什么是指纹而不是把三件原样交出来:`updatedInput` 可能携人写的命令原文/密钥形字节,而本读口的
  * 契约是「窄读、非凭据面」—— 交指纹够比对,也不给任何调用点把它误投上 wire 的机会。
@@ -15,9 +27,5 @@
  * 铸点丢掉的字节行上就没有,请求侧多喂一件会把一次合法重试误判成「不同的决议」。
  * 序列化失败(循环引用/BigInt 等)⇒ `null` = 判别不出,调用方据此拒绝回放(fail-closed)。
  */
-export declare function approvalPayloadFingerprint(v: {
-    updatedInput?: unknown;
-    answer?: unknown;
-    reason?: string;
-}): string | null;
+export declare function approvalPayloadFingerprint(v: ApprovalPayload): string | null;
 //# sourceMappingURL=approval-payload-fingerprint.d.ts.map

package/dist/plugins/approval-payload-fingerprint.js

@@ -12,7 +12,7 @@ function canonicalFingerprintJson(v) {
 }
 export function approvalPayloadFingerprint(v) {
     try {
-        const fp = canonicalFingerprintJson([v.updatedInput ?? null, v.answer ?? null, v.reason ?? null]);
+        const fp = canonicalFingerprintJson([v.updatedInput ?? null, v.answer ?? null, v.reason ?? null, ...(v.feedback !== undefined ? [v.feedback] : [])]);
         return fp;
     }
     catch (e) {

package/dist/plugins/blob-backend.d.ts

@@ -1,29 +1,25 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import { type SqlEngineReading, type SqlWallSource, type SqlWallsReading } from "./sql-driver.js";
+import { type SqlEngineFacts, type SqlEngineReading, type SqlWallSource, type SqlWallsReading } from "./sql-driver.js";
+import { type Logger } from "../observability/logger.js";
 /**
  * 文本协议的 blob 膨胀律 —— mysql2 `query()` 把 Buffer 参数写成 `X'<hex>'`,一字节两个字符,所以承载一个 blob 的语句至少是它的 2 倍。
  * 包墙折成「能装下多大的 blob」只用这一只常量,推导里不手写 `/ 2`。
  */
 export declare const SQL_TEXT_PROTOCOL_BLOB_INFLATION = 2;
 /**
- * 包墙下能装多大的 blob:语句里的载荷量({@link packetWallStatementBytes},与提交体受理口读同一个折算)再按 {@link SQL_TEXT_PROTOCOL_BLOB_INFLATION} 折半。
- * 提交体按原样进语句、没有膨胀,blob 以十六进制字面进语句、有 2× —— 膨胀律是 blob 腿自己的,余量不是。
+ * 包墙下能装多大的 blob:语句里的载荷量({@link packetWallStatementBytes})再按 {@link SQL_TEXT_PROTOCOL_BLOB_INFLATION} 折半。
+ * blob 以十六进制字面进语句、有 2× —— 膨胀律是 blob 腿自己的,余量不是。
  */
 export declare function packetWallBlobCap(maxPacketBytes: number): number;
-/**
- * **事实本身还没建立**时 MySQL 协议方言的缺省帽(池上还没借出过连接,或最近一次连接初始化被拒:`SqlDriver.facts === null`)= 事实缺席时的墙
- * (`sql-driver.ts` `SQL_FACTS_ABSENT_WALLS`,判官 `sqlWallsOf`;提交受理口读同一只)走下面同一个推导 —— 不是第二份落点,只是那个推导在这组墙上的值
- * (今天 = TiDB 缺省行墙走 blob 行的折算 6 MiB − 1 KiB:最矮的包墙缺省 16 MiB 扣语句余量再折半仍近 8 MiB,行腿更矮)。
- */
-export declare const SQL_BLOB_FACTS_ABSENT_CAP_BYTES: number;
 /**
  * SQL 快照 blob 的**缺省**帽(运维没设 `SNAPSHOT_BLOB_SQL_MAX_BYTES` 时)的唯一推导 —— 入参是判官 `sqlWallsOf` 给的墙(不读事实、不判缺席、不看方言),**两堵墙取最小**:
  * 行墙腿(`SqlEngineFacts.maxRowBytes`,TiDB:{@link rowWallPayloadBytes} 的 `blob` = 行墙 − blob 行的余量 1 KiB —— 按这一行的真实形算,不借 JSON 提交体行的 64 KiB)
  * 与包墙腿(`SqlEngineFacts.maxPacketBytes`,InnoDB 与 TiDB 都有:{@link packetWallBlobCap} = ⌊(包墙 − 1 KiB 语句余量) ÷ 2⌋)。余量只在 `sql-driver.ts` 定义一次
  * (墙 × 行的形各一只),提交体受理口(`http/request-guards.ts` `refuseSubmitBody`)读同一张表的 `json` 那一只,不各抄。
- * 墙的 `null` 只表示「这堵墙不存在」;两堵都不存在(PG —— 扩展协议无这两堵墙,事实在不在都一样 —— 或没有 SQL 后端)⇒ `undefined` 不设帽。事实本身缺席时
- * 墙由判官给(MySQL 协议按最保守的墙),走同一个推导 = {@link SQL_BLOB_FACTS_ABSENT_CAP_BYTES}。显式旋钮是运维的策略帽,在本推导之上(见 {@link sqlBlobCapBytes})。
+ * 墙的 `null` 只表示「这堵墙不存在」;两堵都不存在(PG —— 扩展协议无这两堵墙 —— 或没有 SQL 后端)⇒ `undefined` 不设帽。
+ * 「事实本身缺席」不是这里的入参:店的写前判读的是借出连接自己的事实(恒已建立,见 {@link SqlConnectionReading}),缺席的读法只在提交受理口读池级读口时出现(判官 `sqlWallsOf` 给墙)。
+ * 显式旋钮是运维的策略帽,在本推导之上(见 {@link sqlBlobCapBytes})。
  *
  * 两堵墙的真库读数(clay 拍 a+c,2026-07-27;k3s8 tidb-test v7.5.1 默认配置探针):7 MiB / 31 MiB = `entry too large`(行墙,默认 6291456)、
  * 32 MiB = `max_allowed_packet`(包墙,64 MiB ÷ ~2× 文本协议膨胀)。帽=诚实拒绝:超限 blob 在 query 之前 typed 拒(消费面 HTTP 413 / capture warn
@@ -43,15 +39,29 @@ export interface SqlBlobCapReading {
  */
 export declare function sqlBlobDefaultCapOf(walls: SqlWallsReading): SqlBlobCapReading | undefined;
 /**
- * 一个 SQL 快照 blob 此刻的帽 —— **显式旋钮 ?? 判官给的墙走缺省推导**的唯一一只函数。两个读者同调它、各传本池的**引擎读口**(方言与活事实同出一只驱动,
- * 与提交受理口读的是同一种读口):店的写前帽({@link SqlBlobBackend},本池的驱动)与 `PUT /sync/blobs` 的前置 413(`boot/stage-10-http-server.ts` 装配的读口,
- * 按请求调,读 `ServiceDeps.sqlEngine`)。同一池上两个读口读的是同一份池级事实。
+ * 一条**借出连接**的引擎读口:方言(装配事实)+ 它自己那次初始化回读的事实。与 {@link SqlEngineReading} 的差别只有一处 —— `facts` 恒在:连接是借出时才有的,
+ * 借出即已初始化({@link connectJudged} 交给判决的就是借出连接的 `sqlConnectionFacts`),所以「事实缺席」在这条读法上**不可表示**(编译期拒,不是运行期一个没人走的分支)。
+ * 事实缺席(池上还没建立过、或最近一次初始化被拒)只出现在读**池级**读口的地方 —— 提交受理口 —— 那一格的墙由判官 `sqlWallsOf` 给,不经过帽的推导。
  */
-export declare function sqlBlobCapOf(explicitCapBytes: number | undefined, engine: SqlEngineReading): SqlBlobCapReading | undefined;
+export interface SqlConnectionReading {
+    readonly dialect: SqlEngineReading["dialect"];
+    readonly facts: SqlEngineFacts;
+}
+/**
+ * 一个 SQL 快照 blob 此刻的帽 —— **显式旋钮 ?? 判官给的墙走缺省推导**的唯一一只函数。唯一读者 = 店的写前判({@link SqlBlobBackend.putBlob}),传的读口({@link SqlConnectionReading})是
+ * **将要执行写入的那条连接**的(方言 + 它自己那次初始化回读的事实,墙经与提交受理口同一只判官 `sqlWallsOf`):包墙是连接的会话值,所以判决只在写入的那条连接上做,
+ * HTTP 面不替店另算一份帽。
+ */
+export declare function sqlBlobCapOf(explicitCapBytes: number | undefined, connection: SqlConnectionReading): SqlBlobCapReading | undefined;
 /** {@link sqlBlobCapOf} 的字节投影(同一个推导,不另读)。 */
-export declare function sqlBlobCapBytes(explicitCapBytes: number | undefined, engine: SqlEngineReading): number | undefined;
+export declare function sqlBlobCapBytes(explicitCapBytes: number | undefined, connection: SqlConnectionReading): number | undefined;
+/**
+ * 这一拒是不是**那条连接的包墙**定的:帽是缺省推导出的(不是运维旋钮)、那条连接有包墙、且包墙腿的折算恰是这个帽(包墙腿是最矮的一腿,或与行墙腿并列)。
+ * 只有这种拒才值得问「这条连接过时了吗」({@link connectJudged}) —— 旋钮的拒、行墙的拒与连接新旧无关。`walls` = 判出这个帽的那一份墙({@link sqlWallsOf})。
+ */
+export declare function capBoundByPacketWall(cap: SqlBlobCapReading, walls: SqlWallsReading): boolean;
 /**
- * 一次 blob 超帽的拒句 —— **唯一的组句器**(`PUT /sync/blobs` 的前置 413 与店的 typed {@link BlobTooLargeError} 同调它):句子按帽的出处({@link SqlBlobCapReading.source})
+ * 一次 blob 超帽的拒句 —— **唯一的组句器**(店的 typed {@link BlobTooLargeError} 调它;`PUT /sync/blobs` 的 413 原样转出它的句子):句子按帽的出处({@link SqlBlobCapReading.source})
  * 分三形,不把假定说成库的上限、也不把运维的旋钮说成库的上限。
  *  · `operator` —— 帽是运维设的 `SNAPSHOT_BLOB_SQL_MAX_BYTES`;
  *  · `reported` —— 帽由库报的两堵墙推出(单行上限与包墙÷文本协议膨胀的较小者);
@@ -97,21 +107,24 @@ export interface BlobBackend {
 export declare class SqlBlobBackend implements BlobBackend {
     private readonly dialect;
     private readonly pool;
-    /** Explicit per-blob cap (the operator's `SNAPSHOT_BLOB_SQL_MAX_BYTES`); absent ⇒ the derivation in {@link sqlBlobCapBytes} over this pool's live engine facts. */
+    /** Explicit per-blob cap (the operator's `SNAPSHOT_BLOB_SQL_MAX_BYTES`); absent ⇒ the derivation in {@link sqlBlobCapOf} over the walls of the connection each write borrows. */
     private readonly explicitCapBytes;
-    /** This pool's engine reading (dialect + live facts, from the pool's own driver) — the one source the cap's walls are read from. */
-    private readonly engine;
     /** Blob-domain table ([ref] blob 域隔离:file-history 域用自己的表,reap/GC 不跨域)。代码内字面量,非用户输入。 */
     private readonly table;
-    constructor(dialect: "tidb" | "pg", pool: MysqlPool | PgPool, maxBytes?: number, table?: string);
-    /** The cap in force for this write: the explicit one, else the default derived from the pool's engine facts as they
-     *  stand now (the driver refreshes them on each connection initialization). */
-    private cap;
+    /** The write path's connection source: every `putBlob` borrows ONE connection from it (through {@link connectJudged}), judges on that connection's walls, writes on it. */
+    private readonly db;
+    /** Where a stale connection's replacement is logged ({@link connectJudged}); the boot assembly passes the service logger. */
+    private readonly log;
+    constructor(dialect: "tidb" | "pg", pool: MysqlPool | PgPool, maxBytes?: number, table?: string, log?: Pick<Logger, "warn">);
     /** The created_at-refreshing content-addressed upsert — VERBATIM the tidb/pg stores' `putBlobRow`. Refreshes
      *  created_at even on a dedup hit so a re-used/just-written blob is "touched=now" and GC-grace-protected.
      *  (a): an over-cap blob is REJECTED (typed {@link BlobTooLargeError}) BEFORE the driver ever sees the bytes —
      *  the alternative is an inscrutable packet-limit error deep in the driver, and on the HTTP face a 502 that
-     *  invites the peer to retry a blob that can never land. */
+     *  invites the peer to retry a blob that can never land.
+     *  🔴 The cap is judged ON THE CONNECTION THAT WRITES (S-1746): `max_allowed_packet` is a session value, fixed per
+     *  connection, so the write borrows one connection through {@link connectJudged}, which reads ITS walls, judges, and — when
+     *  the refusal is that connection's packet wall and the server's global wall is higher — replaces the stale connection and
+     *  judges once more; the INSERT runs on the connection that passed. Never a pool-level reading, never a bare `pool.query`. */
     putBlob(hash: string, bytes: Uint8Array): Promise<void>;
     /** The bytes for `hash` (undefined if absent) — VERBATIM the tidb/pg stores' getBlob SELECT. A pool/query error
      *  PROPAGATES (a transient DB fault is loud, not a silent "missing blob" — parity with the MinIO backend's throw). */

package/dist/plugins/blob-backend.js

@@ -1,12 +1,12 @@
 import { createHash } from "node:crypto";
 import { presignS3Url, presignS3ListUrl } from "./s3-presign.js";
-import { SQL_FACTS_ABSENT_WALLS, mysqlDriver, packetWallStatementBytes, pgDriver, rowWallPayloadBytes, sqlWallsOf } from "./sql-driver.js";
+import { connectJudged, mysqlDriver, packetWallStatementBytes, pgDriver, rowWallPayloadBytes, sqlWallsOf } from "./sql-driver.js";
+import { createLogger } from "../observability/logger.js";
 const BLOB_GC_GRACE_MS = 3_600_000;
 export const SQL_TEXT_PROTOCOL_BLOB_INFLATION = 2;
 export function packetWallBlobCap(maxPacketBytes) {
     return Math.floor(packetWallStatementBytes(maxPacketBytes) / SQL_TEXT_PROTOCOL_BLOB_INFLATION);
 }
-export const SQL_BLOB_FACTS_ABSENT_CAP_BYTES = sqlBlobDefaultCapBytes(SQL_FACTS_ABSENT_WALLS);
 export function sqlBlobDefaultCapBytes(walls) {
     return sqlBlobDefaultCapOf(walls)?.capBytes;
 }
@@ -18,11 +18,14 @@ export function sqlBlobDefaultCapOf(walls) {
         legs.push({ capBytes: packetWallBlobCap(walls.maxPacketBytes), source: walls.sources.maxPacketBytes });
     return legs.reduce((best, leg) => (best === undefined || leg.capBytes < best.capBytes ? leg : best), undefined);
 }
-export function sqlBlobCapOf(explicitCapBytes, engine) {
-    return explicitCapBytes !== undefined ? { capBytes: explicitCapBytes, source: "operator" } : sqlBlobDefaultCapOf(sqlWallsOf(engine));
+export function sqlBlobCapOf(explicitCapBytes, connection) {
+    return explicitCapBytes !== undefined ? { capBytes: explicitCapBytes, source: "operator" } : sqlBlobDefaultCapOf(sqlWallsOf(connection));
 }
-export function sqlBlobCapBytes(explicitCapBytes, engine) {
-    return sqlBlobCapOf(explicitCapBytes, engine)?.capBytes;
+export function sqlBlobCapBytes(explicitCapBytes, connection) {
+    return sqlBlobCapOf(explicitCapBytes, connection)?.capBytes;
+}
+export function capBoundByPacketWall(cap, walls) {
+    return cap.source !== "operator" && walls.maxPacketBytes !== null && packetWallBlobCap(walls.maxPacketBytes) === cap.capBytes;
 }
 export function sqlBlobCapRefusalText(byteLen, cap) {
     const objectStorage = "configure MinIO object storage (MINIO_ENDPOINT/MINIO_ACCESS_KEY/MINIO_SECRET_KEY) for large snapshot blobs";
@@ -64,27 +67,34 @@ export class SqlBlobBackend {
     dialect;
     pool;
     explicitCapBytes;
-    engine;
     table;
-    constructor(dialect, pool, maxBytes, table = "snapshot_blob") {
+    db;
+    log;
+    constructor(dialect, pool, maxBytes, table = "snapshot_blob", log) {
         this.dialect = dialect;
         this.pool = pool;
         this.explicitCapBytes = maxBytes;
         this.table = table;
-        this.engine = dialect === "tidb" ? mysqlDriver(pool) : pgDriver(pool);
-    }
-    cap() {
-        return sqlBlobCapOf(this.explicitCapBytes, this.engine);
+        this.db = dialect === "tidb" ? mysqlDriver(pool) : pgDriver(pool);
+        this.log = log ?? createLogger();
     }
     async putBlob(hash, bytes) {
-        const cap = this.cap();
-        if (cap !== undefined && bytes.byteLength > cap.capBytes)
-            throw new BlobTooLargeError(bytes.byteLength, cap);
-        if (this.dialect === "tidb") {
-            await this.pool.query(`INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE created_at = VALUES(created_at)`, [hash, bytes.byteLength, Buffer.from(bytes), new Date()]);
+        const judged = await connectJudged(this.db, (facts) => {
+            const connection = { dialect: this.dialect, facts };
+            const cap = sqlBlobCapOf(this.explicitCapBytes, connection);
+            if (cap === undefined || bytes.byteLength <= cap.capBytes)
+                return undefined;
+            return { cap, packetBound: capBoundByPacketWall(cap, sqlWallsOf(connection)) };
+        }, (refusal) => refusal.packetBound, this.log);
+        if (judged.refusal !== undefined)
+            throw new BlobTooLargeError(bytes.byteLength, judged.refusal.cap);
+        try {
+            await judged.conn.query(this.dialect === "tidb"
+                ? `INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE created_at = VALUES(created_at)`
+                : `INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES ($1,$2,$3,$4) ON CONFLICT (blob_hash) DO UPDATE SET created_at = EXCLUDED.created_at`, [hash, bytes.byteLength, Buffer.from(bytes), new Date()]);
         }
-        else {
-            await this.pool.query(`INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES ($1,$2,$3,$4) ON CONFLICT (blob_hash) DO UPDATE SET created_at = EXCLUDED.created_at`, [hash, bytes.byteLength, Buffer.from(bytes), new Date()]);
+        finally {
+            judged.conn.release();
         }
     }
     async getBlob(hash) {

package/dist/plugins/breaker-state-sql.d.ts

@@ -6,7 +6,7 @@
  *
  * core's `createCircuitBreakerBrain` defaults to a per-PROCESS Map → on a multi-replica deployment
  * every replica re-discovers a provider outage independently (slow fleet-wide reaction). This backs
- * the breaker with the shared `circuit_breaker` table so a trip on one replica is learned by the others.
+ * the breaker with the shared `breaker_state` table so a trip on one replica is learned by the others.
  *
  * IMPORTANT — `BreakerState.get/set` are **synchronous** (core calls them on the hot path of every
  * brain invocation; a DB round-trip per call is untenable). So this is a **write-through cache**:
@@ -40,7 +40,7 @@ import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool, PoolClient } from "pg";
 import type { BreakerSnapshot, BreakerState } from "@sema-agent/core";
 import { type SqlDriver } from "./sql-driver.js";
-/** PG translation of the tidb-pool.ts `circuit_breaker` DDL (DATETIME(3)→TIMESTAMPTZ(3)). Disjoint from other
+/** PG translation of the tidb-pool.ts `breaker_state` DDL (DATETIME(3)→TIMESTAMPTZ(3)). Disjoint from other
  *  stores' tables, so a self-contained ensureSchema is safe (no central-schema shadowing). TiDB's DDL lives
  *  centrally in tidb-pool.ts (no PG-side twin needed there — production wires ONE ensureTidbSchema). */
 export declare const PG_BREAKER_STATE_SCHEMA: string[];

package/dist/plugins/breaker-state-sql.js

@@ -1,6 +1,6 @@
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 export const PG_BREAKER_STATE_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS circuit_breaker (
+    `CREATE TABLE IF NOT EXISTS breaker_state (
      breaker_key VARCHAR(190) COLLATE "C"   NOT NULL,
      phase       VARCHAR(16) COLLATE "C"    NOT NULL,
      failures    INTEGER        NOT NULL DEFAULT 0,
@@ -37,8 +37,8 @@ export class SqlBreakerState {
     }
     async writeThrough(key, snap) {
         try {
-            await this.db.query(this.q("INSERT INTO circuit_breaker (breaker_key, phase, failures, opened_at, updated_at) VALUES (?,?,?,?,?) " +
-                "ON DUPLICATE KEY UPDATE phase=VALUES(phase), failures=VALUES(failures), opened_at=VALUES(opened_at), updated_at=VALUES(updated_at)", "INSERT INTO circuit_breaker (breaker_key, phase, failures, opened_at, updated_at) VALUES ($1,$2,$3,$4,$5) " +
+            await this.db.query(this.q("INSERT INTO breaker_state (breaker_key, phase, failures, opened_at, updated_at) VALUES (?,?,?,?,?) " +
+                "ON DUPLICATE KEY UPDATE phase=VALUES(phase), failures=VALUES(failures), opened_at=VALUES(opened_at), updated_at=VALUES(updated_at)", "INSERT INTO breaker_state (breaker_key, phase, failures, opened_at, updated_at) VALUES ($1,$2,$3,$4,$5) " +
                 "ON CONFLICT (breaker_key) DO UPDATE SET phase=EXCLUDED.phase, failures=EXCLUDED.failures, opened_at=EXCLUDED.opened_at, updated_at=EXCLUDED.updated_at"), [key, snap.phase, snap.failures, snap.openedAt != null ? new Date(snap.openedAt) : null, new Date()]);
             this.pending.delete(key);
             if (this.writeFailStreak > 0) {
@@ -60,7 +60,7 @@ export class SqlBreakerState {
         try {
             const pendingAtStart = new Set(this.pending);
             const guarded = (key) => this.pending.has(key) || pendingAtStart.has(key);
-            const { rows } = await this.db.query("SELECT breaker_key, phase, failures, opened_at FROM circuit_breaker");
+            const { rows } = await this.db.query("SELECT breaker_key, phase, failures, opened_at FROM breaker_state");
             const seen = new Set();
             for (const r of rows) {
                 const key = String(r.breaker_key);

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

@@ -1,9 +1,10 @@
-import type { AcquiredSession, PlacedSessionRow, RetentionDeclaration, SessionPlacementRecord, SessionStore, SessionTreeEntry } from "@sema-agent/core";
+import { type AcquiredSession, type PlacedSessionRow, type RetentionDeclaration, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry } from "@sema-agent/core";
 import type { OwnerAwareSessionStore, SessionListItem } from "../security.js";
 import type { StagingHandle } from "../session-sync-kernel.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import type { InstructionSourceStore } from "../instruction-source-notice.js";
 import type { SessionFaceReader } from "../session-incarnation.js";
+import type { OwnerlessClaim } from "../delegated-session-owner.js";
 export interface CachingOptions {
     /** Idle seconds a woken session is kept warm. 0 disables caching (pure passthrough). */
     ttlSec: number;
@@ -59,6 +60,8 @@ export declare class CachingSessionStore implements SessionStore {
      *  (缓存的会话活得比「另一只店删掉又重建了这一行」长)。🔴 必须转发:k8s 工作区空间的每 run 读与起服门读的就是本类。 */
     readonly incarnationOf?: SessionStore["incarnationOf"];
     readonly register?: (sessionId: string, owner: string | null) => Promise<void>;
+    /** S-1770 委派继承律的认领口,纯转发(写的是行上的属主那一格 —— 只 CAS 子行自己,不碰暖缓存里的会话;停驻挂点在默认部署上读的就是本类 —— 与 `placementOf` 同转发同缺:内店记录委派树 ⇒ 两只都在)。 */
+    readonly claimOwnerless?: OwnerlessClaim;
     /** Delegated SessionRepo seam (§0.5) — list/fork/delete operate on the DURABLE tables directly (they bypass the
      *  warm cache by design; a fork/delete must read/write durable state, not a possibly-stale cached view). */
     readonly listSessions?: (opts: {

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

@@ -1,4 +1,5 @@
-import { assertPlacementAdmission } from "./session-placement.js";
+import { admitSessionPlacement } from "@sema-agent/core";
+import { placementCapabilityOf } from "./session-placement.js";
 export class CachingSessionStore {
     inner;
     cache = new Map();
@@ -10,6 +11,7 @@ export class CachingSessionStore {
     sessionFaceOf;
     incarnationOf;
     register;
+    claimOwnerless;
     listSessions;
     fork;
     deleteSession;
@@ -57,6 +59,8 @@ export class CachingSessionStore {
             this.incarnationOf = inner.incarnationOf.bind(inner);
         if (ownerAware.register)
             this.register = ownerAware.register.bind(inner);
+        if (ownerAware.claimOwnerless)
+            this.claimOwnerless = ownerAware.claimOwnerless.bind(inner);
         if (ownerAware.listSessions)
             this.listSessions = ownerAware.listSessions.bind(inner);
         if (ownerAware.sessionSummaryOf)
@@ -141,7 +145,7 @@ export class CachingSessionStore {
         }
         const hit = await this.freshHit(sessionId);
         if (hit && opts?.requireExisting !== true && this.placements !== undefined && this.placementOf !== undefined) {
-            assertPlacementAdmission(sessionId, await this.placementOf(sessionId), opts);
+            admitSessionPlacement(sessionId, await this.placementOf(sessionId), opts ?? {}, placementCapabilityOf(this));
         }
         if (hit) {
             hit.expiresAt = Date.now() + this.ttlMs;
@@ -156,7 +160,7 @@ export class CachingSessionStore {
         if (inflight) {
             const acquired = await inflight;
             if (this.placements !== undefined && this.placementOf !== undefined) {
-                assertPlacementAdmission(sessionId, await this.placementOf(sessionId), opts);
+                admitSessionPlacement(sessionId, await this.placementOf(sessionId), opts ?? {}, placementCapabilityOf(this));
             }
             return acquired;
         }