@sema-agent/server 7.146.0 → 7.147.0

package/dist/plugins/store-contracts.d.ts

@@ -37,13 +37,19 @@ import type { SessionUnreadable } from "../session-error-wire.js";
  * F1 [high] 实测:`DB_BACKEND` 未设时坏账本 ⇒ `{backend: undefined, degraded: true}`,不是拒启)。
  * 收法:**一个基类,一条重抛**。新 File 店的拒启只要 `extends StoreBootRefusalError` 就自动落在正确的
  * 一侧;忘了继承是**可见**的(它是一个必须显式选择的父类),而忘了往 if 链里加一行是不可见的。
- * (core 的 `AdoptionError` 不在本仓,改不了它的继承链 ⇒ 降级臂保留它那一条 `instanceof`,共两条。)
+ * (core 的 `AdoptionError` 不在本族:它的标记住在数据根里,而降级臂只对**空 / 不存在**的数据根开(`openStoreBackendWithFallback` 的数据根判据),
+ * 它到不了降级那一步 ⇒ 降级臂不为它单开一条。local 形上本族同样先被那条判据兜住;族规仍在,管的是拒句的属主与 SQL 族。)
  *
  * 族的含义是「**确定的拒启表态**」,不限 File 店:SQL `ensureSchema()` 里库带着已退役 schema 的拒启(`RetiredSchemaPresentError`)也属此族。三处读它,读法一致 ——
  * 降级臂不吞(穿过 `mayFallback`)、SQL 开库的等待窗不重试它(`store-open-wait.ts`:再等也等不来另一个答案)、「库打不开」的拒句不改写它(它自己的拒句才是真话)。
  */
 export declare class StoreBootRefusalError extends Error {
 }
+/**
+ * 起服对账一族的拒启码(机读;附录 A / 拒启码表的登记名)。含义 = 「本构建读不出 / 建不出的持久形,开始服务之前判」:SQL 列册对账与退役 schema 两道(`schema-consistency.ts`)、
+ * 会话部署格旁表建不出(`session-ext-table.ts`)、local 数据根的严格边档对账(`local-session-store.ts`)。码住在族基类旁边:读它的几只模块彼此不必互相 import。
+ */
+export declare const SCHEMA_MISMATCH_ERROR_CODE = "config.schema_mismatch";
 /**
  * 取消便签里的**大脑相位**快照 —— core `BrainStatus` 帧经 `brainStatusEventData` 投影后的五键子集。
  *
@@ -545,7 +551,8 @@ export interface SessionRunRollupSource {
 }
 /**
  * 会话**此刻的 run 认领**(单活槽)的窄读面 —— run 店的 `getActiveTaskId`,同一个问题在 SQL 孪生里是写事务内对 `task_active` 的锁定读。
- * local 会话店的执行席在 `markMirror` 的写锁内读它,判序与 SQL 孪生同(行不在 / 住客不同 / writer / mirror 先判,认领只拦「absent → mirror」这一笔写)。
+ * local 会话店在写锁内读它:执行席的 `markMirror`(判序与 SQL 孪生同:行不在 / 住客不同 / writer / mirror 先判,认领只拦「absent → mirror」这一笔写),
+ * 与导入三写口(整段 `importEntries` / `replaceEntries` / 暂存提交;判官 `judgeImportWrite` 与 SQL 事务内钩的 `import` 臂同一只:先认领后本处写者)。
  */
 export interface SessionRunClaimSource {
     getActiveTaskId(sessionId: string): Promise<string | undefined>;

package/dist/plugins/store-contracts.js

@@ -1,5 +1,6 @@
 export class StoreBootRefusalError extends Error {
 }
+export const SCHEMA_MISMATCH_ERROR_CODE = "config.schema_mismatch";
 export const ABORT_CAUSES = ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb"];
 export const RUN_STALLED_ERROR = "run stalled (instance lost?)";
 export const RUN_ORPHANED_ERROR = "run orphaned by engine restart";

package/dist/plugins/task-attachment-store.d.ts

@@ -2,7 +2,7 @@
  * TaskAttachmentStore —— D-1 通用文件上传的**独立附件 store**(clay 拍 2026-07-27:不复用 fileSnapshot
  * 的 content-addressed blob 面,新建)。TiDB/PG 双方言 + local 文件店(local-task-attachment-store.ts)。
  *
- * 为什么独立而不是骑 SqlBlobBackend/snapshot_blob:那套的引用追踪=「本域 manifest 里没有的即 orphan」,
+ * 为什么独立而不是骑快照 blob 的索引(snapshot_blob):那套的引用追踪=「本域 manifest 里没有的即 orphan」,
  * 附件不在任何一域的 manifest 里 ⇒ 会被孤儿扫在 1h grace 后误收。生命周期也不同:
  * snapshot blob 跟 session 的工作树;**附件跟 task/session 的绑定**(上传先行、提交时绑定、E21 随会话
  * 级联删、未绑定的按 TTL 收割)。
@@ -11,8 +11,8 @@
  *  - `owner` = auth principal ?? "default"(单库 tenant 轴;无 principal 部署全 default = 单用户语义)。
  *    读/删门在 SQL WHERE 完成(filter-before-reduce,roster 语义条 1 同姿)——他人行连结果集都不进。
  *  - **字节本体在对象存储(clay 裁 2026-07-27:云形态对象存储必配,「现在就接」)**:SQL 只存 meta
- *    (索引/owner 门/生命周期),bytes 走 {@link AttachmentBytesStore}(生产=既有 MinioBlobBackend,
- *    读侧内建 sha 校验)。对象键=**sha256**(同内容天然去重;跨 owner 共享对象 ⇒ 对象删除必须过
+ *    (索引/owner 门/生命周期),bytes 走 {@link AttachmentBytesStore}(字节口 {@link BlobBackend} —— 生产 = 对象存储
+ *    MinioBlobBackend;读侧的 sha 校验是本店作为索引属主的事:{@link readAtAddress})。对象键=**sha256**(同内容天然去重;跨 owner 共享对象 ⇒ 对象删除必须过
  *    零引用检查)+ **附件专属 keyPrefix**(与快照 blob 命名空间隔离——同 sha 不同生命周期,混用会互删)。
  *    删除次序:meta 先(E21 purge 永不被 MinIO 网络抖动卡死,blob-backend 异步删裁定同旨),对象删
  *    =零引用检查后 best-effort(失败只 log:无 meta 的对象经 API 不可达;彻底清收敛作 follow-up 记账)。
@@ -32,6 +32,7 @@ import type { Pool } from "mysql2/promise";
 import type { PgQueryFn } from "./pg-query.js";
 import type { Pool as PgPool } from "pg";
 import { type IndexSpec } from "./ensure-index.js";
+import { type BlobBackend } from "./blob-backend.js";
 /**
  * 一条附件 meta 的**形属主**(整仓唯一那份键集)。
  *
@@ -79,12 +80,9 @@ export interface TaskAttachmentStore {
     sweepOrphanObjects?(graceMs: number, nowMs?: number): Promise<number>;
 }
 export declare const TASK_ATTACHMENT_TABLE = "task_attachment";
-/** 字节面 seam —— MinioBlobBackend 的结构子集(hash 键控;读侧 sha 校验在实现内)。`listObjects` 可选
+/** 字节面 = 字节口 {@link BlobBackend}(sha256 键控;读侧 sha 校验在本店,{@link readAtAddress})+ 对象存储的两只可选读面。`listObjects` 可选
  *  (D-1 孤儿对象 GC 的列举面;测试桩/无列举后端缺席=sweep 诚实 0,不装作扫过)。 */
-export interface AttachmentBytesStore {
-    putBlob(hash: string, bytes: Uint8Array): Promise<void>;
-    getBlob(hash: string): Promise<Uint8Array | undefined>;
-    deleteBlobs(hashes: string[]): Promise<number>;
+export interface AttachmentBytesStore extends BlobBackend {
     listObjects?(): AsyncGenerator<{
         hash: string;
         lastModifiedMs: number;

package/dist/plugins/task-attachment-store.js

@@ -4,6 +4,7 @@ import { createHash } from "node:crypto";
 import { attachmentKindOf, PROJECT_BUNDLE_MIME } from "../project-bundle.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isDupKeyError, retryOnDeadlock } from "./sql-errors.js";
+import { readAtAddress } from "./blob-backend.js";
 export const TaskAttachmentRecordSchema = z.object({
     id: z.string(),
     owner: z.string(),
@@ -301,7 +302,7 @@ export class TiDBTaskAttachmentStore {
         this.db = mysqlDriver(pool);
     }
     async put(rec) {
-        await this.bytes.putBlob(rec.sha256, rec.content);
+        await this.bytes.put(rec.sha256, rec.content);
         await this.pool.execute(`INSERT INTO ${TASK_ATTACHMENT_TABLE} (${COLS}) VALUES (?,?,?,?,?,?,?,?,?)`, [rec.id, rec.owner, rec.name, rec.mime, rec.sha256, rec.sizeBytes, rec.sessionId ?? null, rec.createdAtMs, rec.boundAtMs ?? null]);
     }
     async get(owner, id) {
@@ -312,7 +313,7 @@ export class TiDBTaskAttachmentStore {
         const meta = await this.get(owner, id);
         if (!meta)
             return null;
-        const b = await this.bytes.getBlob(meta.sha256);
+        const b = await readAtAddress(this.bytes, meta.sha256);
         return b && b.byteLength === meta.sizeBytes ? b : null;
     }
     async deleteBytesIfUnreferenced(shas) {
@@ -320,7 +321,7 @@ export class TiDBTaskAttachmentStore {
             try {
                 const [cnt] = await this.pool.query(`SELECT COUNT(*) AS n FROM ${TASK_ATTACHMENT_TABLE} WHERE sha256 = ?`, [sha]);
                 if (Number(cnt[0].n) === 0)
-                    await this.bytes.deleteBlobs([sha]);
+                    await this.bytes.delete([sha]);
             }
             catch {
             }
@@ -367,8 +368,10 @@ export class TiDBTaskAttachmentStore {
             const referenced = await this.referencedShas(batch);
             const orphans = batch.filter((h) => !referenced.has(h));
             const safe = await this.filterStillOrphan(orphans, graceMs, nowMs);
-            if (safe.length > 0)
-                removed += await this.bytes.deleteBlobs(safe);
+            if (safe.length > 0) {
+                await this.bytes.delete(safe);
+                removed += safe.length;
+            }
             batch = [];
         };
         for await (const o of lister.listObjects()) {
@@ -417,7 +420,7 @@ export class PgTaskAttachmentStore {
         this.q = async (text, params) => ({ rows: (await pool.query(text, params)).rows });
     }
     async put(rec) {
-        await this.bytes.putBlob(rec.sha256, rec.content);
+        await this.bytes.put(rec.sha256, rec.content);
         await this.q(`INSERT INTO ${TASK_ATTACHMENT_TABLE} (${COLS}) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`, [rec.id, rec.owner, rec.name, rec.mime, rec.sha256, rec.sizeBytes, rec.sessionId ?? null, rec.createdAtMs, rec.boundAtMs ?? null]);
     }
     async get(owner, id) {
@@ -428,7 +431,7 @@ export class PgTaskAttachmentStore {
         const meta = await this.get(owner, id);
         if (!meta)
             return null;
-        const b = await this.bytes.getBlob(meta.sha256);
+        const b = await readAtAddress(this.bytes, meta.sha256);
         return b && b.byteLength === meta.sizeBytes ? b : null;
     }
     async deleteBytesIfUnreferenced(shas) {
@@ -436,7 +439,7 @@ export class PgTaskAttachmentStore {
             try {
                 const res = await this.q(`SELECT COUNT(*) AS n FROM ${TASK_ATTACHMENT_TABLE} WHERE sha256 = $1`, [sha]);
                 if (Number(res.rows[0].n) === 0)
-                    await this.bytes.deleteBlobs([sha]);
+                    await this.bytes.delete([sha]);
             }
             catch {
             }
@@ -478,8 +481,10 @@ export class PgTaskAttachmentStore {
             const referenced = await this.referencedShas(batch);
             const orphans = batch.filter((h) => !referenced.has(h));
             const safe = await this.filterStillOrphan(orphans, graceMs, nowMs);
-            if (safe.length > 0)
-                removed += await this.bytes.deleteBlobs(safe);
+            if (safe.length > 0) {
+                await this.bytes.delete(safe);
+                removed += safe.length;
+            }
             batch = [];
         };
         for await (const o of lister.listObjects()) {

package/dist/plugins/task-list-store-sql.d.ts

@@ -22,7 +22,7 @@ export declare const TASK_LIST_ITEM_TABLE = "task_list_item";
  * 同族先例 = `env-facts.ts` 的 `scratchpadSessionSegment`(文件名面)——刻意**不**复用彼此的实现:
  * 一个键空间改了算法不该把另一个键空间的存量行全孤儿化。
  *
- * 🔴 属主在**本文件**(而不是消费它的 boot 车道):留存腿(`retention-store-sql.ts`)按同一派生式
+ * 🔴 属主在**本文件**(而不是消费它的 boot 车道):留存腿(`retention-deployment.ts`)按同一派生式
  * 批量删本表的行,两个消费点必须读同一个函数 —— 键派生有两份就是「在线删除删得掉、留存腿删不掉」。
  */
 export declare function taskListKeyFor(sessionId: string): string;

package/dist/plugins/text-column-capacity.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 中央 DDL 用到的**文本列类型的容量**(UTF-8 字节),按方言各一张 —— 「这一列装得下多少字节」这件事实的唯一一处。
+ *
+ * MySQL 协议(TiDB / MySQL)的 `TEXT` 上限 65,535 字节:严格模式下超长写入抛 `Data too long`,非严格模式静默截断(截断后的 JSON 读侧 parse 失败)。
+ * PG 的 `TEXT` 没有每型宽(只有 1 GB 的通用字段上限,不是列型的事实)⇒ 记作无穷。
+ *
+ * 读者:列属主按自己的类型词查这张表得到列容量(`inbox-payload-column.ts` 的收件 `payload` 预算、`checkpoint-index-columns.ts` 的卡词列容量)。
+ * 只登本仓 DDL 真用的类型词:列属主换一个类型词而这里没有 ⇒ tsc 红,由人把那个类型的容量写进来(不在读者那里另抄一个数)。
+ */
+import type { SqlDialect } from "./sql-driver.js";
+export declare const TEXT_COLUMN_TYPE_MAX_BYTES: {
+    readonly mysql: {
+        readonly TEXT: 65535;
+    };
+    readonly pg: {
+        readonly TEXT: number;
+    };
+};
+/** 某方言下登记过的文本列类型词。 */
+export type TextColumnType<D extends SqlDialect> = keyof (typeof TEXT_COLUMN_TYPE_MAX_BYTES)[D];
+//# sourceMappingURL=text-column-capacity.d.ts.map

package/dist/plugins/text-column-capacity.js

@@ -0,0 +1,5 @@
+export const TEXT_COLUMN_TYPE_MAX_BYTES = {
+    mysql: { TEXT: 65_535 },
+    pg: { TEXT: Number.POSITIVE_INFINITY },
+};
+//# sourceMappingURL=text-column-capacity.js.map

package/dist/plugins/tidb-pool.d.ts

@@ -51,8 +51,9 @@ export declare function createTidbPool(config: ServiceConfig): Pool;
  *  3. 生成的全集 SQL 基线导出到 `docs/schema/baseline-mysql.sql`(由本数组机器生成;它是**产物**,不是真源
  *     —— 冲突时以本文件为准并重新生成)。
  *
- * 注意:`ensureSchema` 仍然保留(建表 + advisory lock + image_bake_admit 种子行),只是语句数组现在是纯
- * CREATE,不再有 information_schema 探针。
+ * 注意:`ensureSchema` 仍然保留(建表 + advisory lock + image_bake_admit 种子行),语句数组是纯 CREATE。数组之外只有一只只读探针:会话部署格旁表
+ * `session_ext` 的外键列要抄被引列 `session_meta.session_id` 的字符集 / 排序规则(MySQL 外键两侧必须相同,而存量库上它随建库年代不同),建它之前读一次
+ * `information_schema.COLUMNS`(`session-ext-table.ts` 的 `ensureSessionExtTableMysql`;探针只读、不导出任何 ALTER)。
  */
 export declare const SCHEMA_STATEMENTS: readonly string[];
 /** Named MySQL/TiDB advisory lock that serializes the whole `ensureSchema` DDL run (see below). */

package/dist/plugins/tidb-pool.js

@@ -5,17 +5,17 @@ import { TIDB_SESSION_CAPTURE_OPTOUT_STATEMENTS } from "./session-capture-record
 import { TIDB_LEADER_RUN_STATEMENTS } from "./leader-run-store-sql.js";
 import { TIDB_ADOPTION_LOG_STATEMENTS } from "./adoption-log-sql.js";
 import { TIDB_PERMISSION_RULE_STATEMENTS } from "./permission-rule-store-sql.js";
-import { TIDB_RETENTION_STATEMENTS } from "./retention-store-sql.js";
+import { TIDB_RETENTION_TOMBSTONE_STATEMENTS } from "../stores-sql/retention-store-sql.js";
+import { TIDB_RETENTION_LANE_STATEMENTS } from "./retention-lane-store-sql.js";
 import { SESSION_META_INCARNATION_COLUMN } from "../session-incarnation.js";
-import { sessionMetaPlacementColumnsDdl } from "./execution-placement-sql.js";
-import { SESSION_META_WORKSPACE_COLUMN } from "./session-workspace-cell.js";
+import { ensureSessionExtTableMysql } from "./session-ext-table.js";
 import { RUN_IDENTITY_COLUMNS } from "../identity-source.js";
 import { SESSION_RULES_COLUMN } from "./session-rules-column.js";
-import { SESSION_TITLE_MAX_CHARS } from "../session-row.js";
+import { INBOX_PAYLOAD_COLUMN } from "./inbox-payload-column.js";
 import { PRINCIPAL_MAX_UTF8_BYTES } from "../security.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { CENTRAL_SCHEMA_INDEXES } from "./schema-indexes.js";
-import { SESSION_INDEXES } from "./pg-session-storage.js";
+import { SESSION_INDEXES } from "../stores-sql/pg-session-storage.js";
 import { TOOL_RESULT_INDEXES } from "../stores-sql/tool-result-store-sql.js";
 import { COST_QUOTA_INDEXES } from "./pg-cost-quota.js";
 import { RATE_LIMIT_INDEXES } from "./pg-rate-limiter.js";
@@ -25,7 +25,8 @@ import { IMAGE_BAKE_INDEXES } from "./image-bake-store-sql.js";
 import { APPROVAL_ASK_INDEXES } from "./approval-ask-store-sql.js";
 import { ADOPTION_LOG_INDEXES } from "./adoption-log-sql.js";
 import { PERMISSION_RULE_INDEXES } from "./permission-rule-store-sql.js";
-import { RETENTION_INDEXES } from "./retention-store-sql.js";
+import { RETENTION_TOMBSTONE_INDEXES } from "../stores-sql/retention-store-sql.js";
+import { RETENTION_LANE_INDEXES } from "./retention-lane-store-sql.js";
 import { LEADER_RUN_INDEXES } from "./leader-run-store-sql.js";
 import { pollUntilLocked } from "./ensure-schema-lock-policy.js";
 import { createCloseAwarePool } from "./sql-driver.js";
@@ -63,23 +64,8 @@ export const SCHEMA_STATEMENTS = [
      updated_at  DATETIME(3)  NOT NULL,
      leaf_id     VARCHAR(64)  NULL,
      leaf_seq    BIGINT       NOT NULL DEFAULT 0,
-     -- title: ONE column, two writers, one law (src/session-row.ts): the user's write (PATCH /v1/sessions/:id →
-     -- writeSessionRowCells, unconditional unless the PATCH carries expectedRowTag; null = cleared back to the automatic title) and the auto-titler (cheap-model
-     -- one-liner on a submit that finds it NULL; setTitleIfNull, fills NULL only) — a user-set title is never overwritten,
-     -- a cleared one is filled again. Width = SESSION_TITLE_MAX_CHARS (the wire bound).
-     title       VARCHAR(${SESSION_TITLE_MAX_CHARS}) NULL,
-     -- pinned: the user's pin (PATCH /v1/sessions/:id → writeSessionRowCells); every list row carries it, false by default.
-     pinned      BOOLEAN      NOT NULL DEFAULT FALSE,
-     -- instruction_source(S-690):本会话**上一次 run** 选中的项目指令文件 = 换源通告(instructions.source_changed)
-     -- 的基线。NULL = 还没有任何 run 记过(首 run 只写不发);'' = 记过、那一次没有项目指令文件;其余 = 链成员相对路径
-     -- (CLAUDE.md / .claude/CLAUDE.md / AGENTS.md / .claude/AGENTS.md)。服务端元数据:不进模型上下文、不进 wire
-     -- 会话面;住在会话行上 ⇒ 随会话删除 / 留存清扫一起消失,fork 出的新行为 NULL(新会话首 run 同样只写不发)。
-     instruction_source VARCHAR(64) NULL,
-     -- workspace:本会话上一条腿**自己的**最后一帧 workspace_changed(引擎 7.58.0 的整份快照:cwd / root / entered / project / remote)。
-     -- NULL = 还没有任何腿记过;唯一写者 = 腿的记录座(src/session-workspace.ts),列属主 = src/plugins/session-workspace-cell.ts
-     -- (列定义、形读者、编解码;存量库缺这一列 ⇒ 起服列册对账拒启,拒句里给出 ALTER)。下一条腿的 TaskSpec.projectId 读它的 project.id。
-     -- 服务端元数据:不进 wire 会话面、不进模型上下文;住在会话行上 ⇒ 随会话删除 / 留存清扫一起消失,fork 出的新行为 NULL。
-     ${SESSION_META_WORKSPACE_COLUMN.mysql},
+     -- 本服务记在会话上的格(标题 / 置顶 / 换源通告基线 / 位置与项目 / 执行放置那一格 / fork 键)不住这张引擎座表:旁表 session_ext
+     -- (下一条语句;建表 / 列 / 外键级联的唯一属主 = src/plugins/session-ext-table.ts,一会话一行,随本行删除级联)。
      -- #292 C18(core 5.48.0 design/323)subagent 转录持久化 —— placement 元组,**创建时一次落行、
      -- first-write 不可变**(register 的 ON DUPLICATE 臂永不重写这六列)。判别位 = placement_kind:
      -- 在场 ⇒ 该会话住在 placement 分区里(不上宿主枚举、claim 形 acquire 恒拒、release=真删除、
@@ -97,11 +83,6 @@ export const SCHEMA_STATEMENTS = [
      -- src/session-incarnation.ts 的 SESSION_META_INCARNATION_COLUMN(存量库缺这一列 ⇒ 起服列册对账拒启,拒句里的 ALTER 由本建表语句生成)。
      -- 不上 wire、不进模型上下文、日志只打前 8 位。
      ${SESSION_META_INCARNATION_COLUMN.mysql},
-     -- 执行放置:根会话行上**这一位住客**的一格 —— execution_role('writer' | 'mirror' | NULL = absent)、execution_lane、device 车道的设备与绑定属主、
-     -- 放下时刻、换绑序号;写只按住客谓词 (session_id, incarnation, owner) ∧ placement_kind IS NULL(换了住客 = 这一格不在)。fork_key = 建这一行的那次
-     -- fork 请求的键(只由 fork 创建点写,此后每个写携带)。规则在 src/execution-placement.ts,列定义与语句的唯一属主 = src/plugins/execution-placement-sql.ts
-     -- (存量库缺这些列 ⇒ 起服列册对账拒启;加列只由一次性迁移做)。
-     ${sessionMetaPlacementColumnsDdl("mysql")},
      PRIMARY KEY (session_id),
      KEY idx_session_meta_owner (owner),
      -- listPlaced 的检索腿(kind + 租户 + 年龄升序);普通会话这三列全 NULL ⇒ 不占索引选择性。
@@ -634,7 +615,8 @@ export const SCHEMA_STATEMENTS = [
      -- payload: bounded + redacted JSON extras of the entry's kind. task_notification: task_type / result / …;
      -- workflow_complete: at most {"completionId": …, "diagnostics": …} (the engine's own correlation id, verbatim; the engine's diagnostic
      -- teaching text, redacted + bounded at enqueue; each key absent when the engine minted none, NULL when neither).
-     payload        TEXT         NULL,
+     -- Column definition owner = inbox-payload-column.ts (INBOX_PAYLOAD_COLUMN); the entry byte budget derives from the same type word.
+     ${INBOX_PAYLOAD_COLUMN.mysql},
      PRIMARY KEY (session_id, run_id),
      UNIQUE KEY uq_wfinbox_seq (seq),
      KEY idx_wfinbox_session_seq (session_id, seq)
@@ -816,7 +798,8 @@ export const SCHEMA_STATEMENTS = [
    ) COLLATE utf8mb4_bin`,
     ...TIDB_ADOPTION_LOG_STATEMENTS,
     ...TIDB_PERMISSION_RULE_STATEMENTS,
-    ...TIDB_RETENTION_STATEMENTS,
+    ...TIDB_RETENTION_LANE_STATEMENTS,
+    ...TIDB_RETENTION_TOMBSTONE_STATEMENTS,
 ];
 export const ENSURE_SCHEMA_LOCK = "sema_ensure_schema";
 export async function acquireEnsureSchemaLock(conn, tag = "ensureSchema") {
@@ -845,7 +828,8 @@ export const SCHEMA_INDEXES = [
     ...APPROVAL_ASK_INDEXES,
     ...ADOPTION_LOG_INDEXES,
     ...PERMISSION_RULE_INDEXES,
-    ...RETENTION_INDEXES,
+    ...RETENTION_LANE_INDEXES,
+    ...RETENTION_TOMBSTONE_INDEXES,
     ...LEADER_RUN_INDEXES,
 ];
 export async function ensureSchema(pool) {
@@ -857,6 +841,10 @@ export async function ensureSchema(pool) {
         for (const stmt of SCHEMA_STATEMENTS) {
             await conn.query(stmt);
         }
+        await ensureSessionExtTableMysql(async (sql) => {
+            const [rows] = await conn.query(sql);
+            return Array.isArray(rows) ? rows : [];
+        });
         await conn.query("INSERT IGNORE INTO image_bake_admit (pool) VALUES ('standard')");
         await ensureIndexes((text, params) => conn.query(text, params), "mysql", SCHEMA_INDEXES);
     }

package/dist/plugins/user-input-ledger-sql.d.ts

@@ -15,7 +15,7 @@
  *
  * ## 会话树删除([ref])
  * `deleteBySession` = `DELETE … WHERE session_id = ?`(真删行;File 孪生是一行会话级墓碑,同义)。两条删会话树的级联各有一臂:在线删除协调器
- * 经本动词;托管留存的事务化孪生(`retention-store-sql.ts` `purgeSessionTrees` ④)在**自己的事务**里对本表发同一只谓词(`session_id` 单键,
+ * 经本动词;托管留存的事务化孪生(`retention-deployment.ts` `deleteDeploymentSessionRows` ④,执行器的 `beforeDelete` 钩)在**自己的事务**里对本表发同一只谓词(`session_id` 单键,
  * 多值集合按方言)—— 它不调店,理由见该文件顶注的布局裁定(一个事务 ⇒ 一条连接 ⇒ 一个属主)。谓词走 `(session_id, state, accepted_at_ms)` 索引的前缀。
  *
  * ## 读不出的行([ref] L6):逐行跳过,游标按原始行推进

package/dist/read-face-posture.d.ts

@@ -36,7 +36,7 @@
  * 本模块的定界不变:并列的那一侧开着哪几档,是那张表自己的缺省说了算。core 的 `config.read_face_deployment_clamped`
  * (只读挂载钳制)同样不受本件影响。
  */
-import { type LaneReadFaceDefault, type RemoteExecProvider } from "./execution-lane-caps.js";
+import { type ExecutionLane, type LaneReadFaceDefault } from "./execution-lane-caps.js";
 import { type PostureSource } from "./posture-source.js";
 /**
  * 档位来源的闭集词表 —— **[ref] 起转 `posture-source.ts` 的共享件**(本模块只是给这一档取个本地名字,
@@ -63,14 +63,14 @@ export declare function readFaceDefaultFor(input: {
 export interface ReadFaceDeploymentSeat {
     readFace?: "open" | "roots" | undefined;
     readFaceSource: ReadFaceSource;
-    remoteExec?: {
-        readonly provider: RemoteExecProvider;
-    } | undefined;
+    readonly remoteExec: {
+        readonly provider: ExecutionLane;
+    };
 }
 /**
  * 把**派生的**读面缺省按这台部署**最终生效的车道**落到配置上(显式 env / center 发布的值与来源原样不动)。返回值 = 这一次有没有改动。
- * 两个调用点,同一只函数:`loadConfig` 装配完 `remoteExec` 之后(env 三元链定的车道);车道合成步在 local 形文件覆写之后
- * (`config.d/remote-exec.json` 能把车道换成 `host` / `local-docker`,读面缺省随最终车道重派 —— 否则它停在已作废的车道上)。
+ * 一个调用点:执行车道合成步,在判点(最终车道来自显式声明)通过之后 —— 车道到那一步才定形(local 形 `config.d/remote-exec.json` 也能声明),
+ * 合成前的 raw 配置上车道可以缺席,派生不在那里做(否则会把缺席折成某条车道的缺省)。
  * 幂等:同一份配置再调一次不改。值与来源**同一处写**(`readFace` 缺席 ⟺ 来源 `engine-default`)。
  */
 export declare function settleDerivedReadFace(seat: ReadFaceDeploymentSeat, singleUserTurnkey: boolean): boolean;

package/dist/read-face-posture.js

@@ -1,4 +1,4 @@
-import { LANE_OPEN_READ_FACE_CAUTION, executionLaneOf, laneReadFaceDefault } from "./execution-lane-caps.js";
+import { LANE_OPEN_READ_FACE_CAUTION, laneReadFaceDefault } from "./execution-lane-caps.js";
 import { POSTURE_SOURCE_WORDS, postureSourceNote } from "./posture-source.js";
 export const READ_FACE_SOURCE_WORDS = POSTURE_SOURCE_WORDS;
 function readFaceForPosture(singleUserTurnkey) {
@@ -21,7 +21,7 @@ function isDerivedSource(source) {
 export function settleDerivedReadFace(seat, singleUserTurnkey) {
     if (!isDerivedSource(seat.readFaceSource))
         return false;
-    const next = readFaceDefaultFor({ laneDefault: laneReadFaceDefault(executionLaneOf(seat.remoteExec?.provider)), singleUserTurnkey });
+    const next = readFaceDefaultFor({ laneDefault: laneReadFaceDefault(seat.remoteExec.provider), singleUserTurnkey });
     if (next.readFace === seat.readFace && next.readFaceSource === seat.readFaceSource)
         return false;
     if (next.readFace === undefined)

package/dist/request-value-closure.d.ts

@@ -119,17 +119,17 @@ export type TaskInheritEnv = (typeof INHERIT_ENV_WORDS)[number];
 export declare const INHERIT_ENV_VALUE_MESSAGE: string;
 /**
  * `inheritEnv` 的 `request.field_invalid` 400 的机读 `reason`([ref];闭集,**一种拒因一个词**,读者穷举读)—— 拒体另带 `field: "inheritEnv"` 与它,
- * 壳靠这两位认「这条 400 真是 `inheritEnv` 的」,不猜句子。同一个键的**三只** 400 是一类,词表一张:
+ * 壳靠这两位认「这条 400 真是 `inheritEnv` 的」,不猜句子。同一个键的**两类** 400(值形 / 车道)是一类,词表一张:
  *  · `unknown_word` —— 值形:是字符串,但不在受理词表(`"ALL"` · `"everything"` · `""`);
  *  · `not_a_string` —— 值形:根本不是字符串(名单形 `string[]` · 布尔 · 数字 · `null` · 对象);
- *  · `lane_not_host` —— `"all"` 落在非 host 车道(只有 host 工厂消费这一位,别的车道没有消费点);
- *  · `no_authorizer_session` —— `"all"` 而部署不接 authorizer(绑定按会话键控,没有会话就没有地方兑现)。
- * 前两词的判官是 {@link inheritEnvFieldIssue}(只看体);后两词的判官在 `boot/resolve-spec.ts`(要读部署事实,两腿同过)。
+ *  · `lane_not_host` —— `"all"` 落在非 host 车道(只有 host 工厂消费这一位,别的车道没有消费点)。
+ * 前两词的判官是 {@link inheritEnvFieldIssue}(只看体);`lane_not_host` 的判官在 `boot/resolve-spec.ts`(要读部署事实,两腿同过)。
+ * 没有「无会话」一词:绑定按会话键控,而一次提交的根会话由 authorizer 必填席解析、经执行上下文交进装配器(根恒在),不存在「部署不接 authorizer」的形。
  * 不在这组的:`422 request.host_posture_refused`(托管部署不兑现 `"all"`)—— 那不是这个键的值写错,而是部署姿态拒,码与写容纳面那条腿共用,按 `errorCode` 认(契约 §18)。
  * 加一种拒因 ⇒ 这里加一个词(并在判官处给它一个分支);词与因一一对应,没有一因两词、也没有一词两因。
  * 词的铸点只有 {@link inheritEnvFacts} 一处:受理门与 resolveSpec 只经它出机读位,不手拼 `field` / `reason`。
  */
-export declare const INHERIT_ENV_REFUSAL_REASONS: readonly ["unknown_word", "not_a_string", "lane_not_host", "no_authorizer_session"];
+export declare const INHERIT_ENV_REFUSAL_REASONS: readonly ["unknown_word", "not_a_string", "lane_not_host"];
 export type InheritEnvRefusalReason = (typeof INHERIT_ENV_REFUSAL_REASONS)[number];
 /** 拒体上的机读位(加性键:直接当 `request.field_invalid` 的附加键用;型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用)。 */
 export type InheritEnvFacts = {

package/dist/request-value-closure.js

@@ -35,7 +35,7 @@ export const INHERIT_ENV_WORDS = ["all", "scrub"];
 export const INHERIT_ENV_VALUE_MESSAGE = `inheritEnv must be one of ${INHERIT_ENV_WORDS.map((w) => JSON.stringify(w)).join(" | ")} when present ` +
     `("all" = the model-driven host shell inherits this machine's whole environment except this deployment's own credentials (its configuration directory's secret-typed names), honored only on a single-user host-lane deployment; ` +
     `"scrub" = the default scrub of credential-shaped variables, accepted on every lane; absent = "scrub") — a name list is not a request value`;
-export const INHERIT_ENV_REFUSAL_REASONS = ["unknown_word", "not_a_string", "lane_not_host", "no_authorizer_session"];
+export const INHERIT_ENV_REFUSAL_REASONS = ["unknown_word", "not_a_string", "lane_not_host"];
 export function inheritEnvFacts(reason) {
     return { field: "inheritEnv", reason };
 }

package/dist/rules-consent.d.ts

@@ -1,5 +1,5 @@
 import { type DirectWritableRuleBehavior, type RemovalLiveness } from "./permission-rule-vocab.js";
-import { type RuleOwner, type ImportPreview, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type RuleRefusalCode, type RuleWriteCommitted, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
+import { type ConfirmRefusalReason, type RuleOwner, type ImportPreview, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type RuleRefusalCode, type RuleWriteCommitted, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
 import type { DurableRulePartitionProvider, PermissionRuleStoreProvider, RuleApprovalRecordStore } from "@sema-agent/core";
 import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./plugins/permission-rule-store-sql.js";
 /**
@@ -192,9 +192,10 @@ export type LocalImportRefusalCode =
  | "not_importable";
 /** 兑付回执的**成员级终态**(闭集,机读;`detail` 是给人看的那一半)。两只 redeem 口(cc-import / local-import)同一张表。
  *
- *  🔴 **引擎拒的成员,结局只读引擎的两词 `committed`**(core 7.63.0 [ref],`RedeemedBatchMember` 拒臂必填):`no` ⇒ `refused`
- *  (引擎确知这一条没落 —— 裁定,如旧导入记录里从 `/` 写起的全局规则的 `unsupported.layer_root`;同批放行被扣下的 `withheld`)、
- *  `unknown` ⇒ `indeterminate`(写面抛 / 读回读不出 —— 那一条**可能已经落了**)。本仓不按串判,不另写第二份判据。
+ *  🔴 **引擎拒的成员,结局只读引擎的两位**(core 7.65.0 [ref] / [ref]:`committed` 一种读法 + `retriable` 另席,拒臂皆必填):
+ *  `committed: "no"` ∧ 不可重试 ⇒ `refused`(引擎定了这一条不立 —— 裁定,如旧导入记录里从 `/` 写起的全局规则的 `unsupported.layer_root`;
+ *  同批放行被扣下的 `withheld`;人撤掉了它的 `dot_removed`)。可重试(写前的店故障)或 `committed: "unknown"`(写已发出而结局未知)
+ *  ⇒ 这一走**未定**,整走不落定(见 {@link settleImportWalk})。本仓不按串判,不按码猜,不另写第二份判据。
  *  它进了**落盘回执的边界 schema**(`ImportOutcomeSchema`;`redeemed_outcome` 列回读同一张词表)。⚠️ 预览面**不用**这个词表:那一面的拒绝形是
  *  `admitted:false + LocalImportRefusalCode`({@link LocalImportPreviewMember}),两面词表**不同**。 */
 export type ImportMemberOutcome = 
@@ -202,11 +203,10 @@ export type ImportMemberOutcome =
 "persisted"
 /** 等价规则**已经在店**(引擎的 `deduped`)—— 同意早就生效,这次什么都不用做。 */
  | "no-op"
-/** 引擎拒了这一条,并答 `committed: "no"` —— 确知没落。重来同一条拒因(`reason`)会得同一个答,出路在 `detail`(引擎原话)。 */
+/** 引擎拒了这一条,并答 `committed: "no"`、不可重试 —— 定了不立。重来同一条拒因(`reason`)会得同一个答,出路在 `detail`(引擎原话)。 */
  | "refused"
-/** 引擎拒了这一条,并答 `committed: "unknown"` —— **不知道落没落**。如实编,禁猜。这一词**不进落定的回执**(落定律:任一成员
- *  结局不知 ⇒ 不落定、503 同票重走,见 {@link unsettledDetailOf});词表留着它,是因为 7.145.x 及更早落定的票行(`redeemed_outcome`)
- *  里有它,回放读那份存量。 */
+/** 7.145.x 及更早落定的票行(`redeemed_outcome`)里的词:引擎答 `committed: "unknown"` 的成员。7.146.0 起这一词**不再铸**(落定律:任一成员
+ *  未定 ⇒ 不落定、503 同票重走,见 {@link settleImportWalk});词表留着它只为回放读那份存量。 */
  | "indeterminate";
 /** prepare 面的一行。判别式联合:被收下的行**没有**拒因字段可读,被拒的行**必然**带拒因 ——
  *  「admitted 却带 reason」这种矛盾态在类型上不可表达。
@@ -227,7 +227,7 @@ export type LocalImportPreviewMember = {
 };
 /** 一条收紧在 prepare 当场落店的结局(与兑付回执的 `persisted` / `no-op` 同词同义;直写接缝 `addPersistedRule` 的 `added` / `no-op`)。 */
 export type LocalImportTighteningOutcome = "persisted" | "no-op";
-/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link buildImportOutcomeMembers})。`reason` / `detail` 在场 ⇔ 引擎拒了这一条
+/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link settleImportWalk})。`reason` / `detail` 在场 ⇔ 引擎拒了这一条
  *  (`refused` / `indeterminate`):`reason` = 引擎的闭集拒因码(`RuleRefusalCode`,core 属主,逐字),`detail` = 引擎给人看的那句话。 */
 export interface ImportOutcomeMember {
     key: ImportRuleKey;
@@ -239,12 +239,12 @@ export interface ImportOutcomeMember {
  * 一次兑付的回执整只 —— **两只 redeem 口同一张**(cc-import / local-import 的 200 体都是 `{ members, rev }`,路由同一个铸点),
  * local-import 另把它**逐字**写进票行 `redeemed_outcome`(回放同源:回放答的就是它)。
  *
- * 🔴 **落定律(一条,两口同读)**:兑付走完、拿到引擎的完整成员表、**且每个成员的结局都确定**(`persisted` / `no-op` / 引擎答
- * `committed: "no"` 的 `refused`)⇒ 这次兑付落定,回执逐成员交出,票不放回、不答 503:cc-import 一次性用掉、答 200 回执;local-import 把回执
+ * 🔴 **落定律(一条,两口同读,{@link settleImportWalk})**:兑付走完、拿到引擎的完整成员表、**且每个成员的结局都定了**(`persisted` / `no-op` / 引擎答
+ * `committed: "no"` 且不可重试的 `refused`)⇒ 这次兑付落定,回执逐成员交出,票不放回、不答 503:cc-import 一次性用掉、答 200 回执;local-import 把回执
  * 落进票行(SETTLED)后答 200 —— 落定这一跳答不成(落定写抛 / 认领被租约接管而新持有者还没落定)⇒ 照旧答 409
  * `conflict.rule_import_in_flight`,同票再来读到的是权威的那一份回执(那一跳不改成员结局,只决定哪一份是权威)。**没有**完整
- * 成员表(引擎在走之前整批拒 / confirm 输给并发写者 / 店在走之前抛 / 循环里仍抛出来的异常),或任一成员结局**不知**(引擎答
- * `committed: "unknown"`:规则店的写抛 / 读回读不出,引擎 7.64.0 起还有成员循环里审批记录店的记 dot CAS / dot 分配失败)⇒ 不落定:放回认领、503
+ * 成员表(引擎在走之前整批拒 / confirm 输给并发写者或撞记录店故障 / 店在走之前抛 / 循环里仍抛出来的异常),或任一成员**未定**(引擎答
+ * `retriable: true`:成员循环里审批记录店的记 dot CAS / dot 分配 / 读记录在规则写之前失败;或 `committed: "unknown"`:规则店的写抛 / 读回读不出)⇒ 不落定:放回认领、503
  * `state.rule_import_retry`,同一张票重来就是重走一遍 —— 兑付按引擎的设计幂等(记录里的 dot 台账),重走交出完整表,
  * 被打断的那一走已落的成员读 `no-op`。确知的成员拒**不**按票自动重试:一条永久被拒的成员(旧记录里的 `unsupported.layer_root`)
  * 若走重试臂,客户端会 503 到票过期、临期放不回 ⇒ 404,已落成员不撤、被拒成员永不落 —— 7.144.0 及更早 cc-import 口就是这一形。
@@ -286,6 +286,14 @@ export type LocalImportPrepared = {
     reason: "tightening-write-failed";
     committed: RuleWriteCommitted;
     detail: string;
+}
+/** 放行那一半的审批记录建不成(引擎 `prepareCcImport` 答可重试的店拒;同 {@link RuleImportPrepared} 同名臂):无票;同批更早的收紧
+ *  可能已生效,同一批原样重发即是出路(已生效的答 no-op)。 */
+ | {
+    ok: false;
+    reason: "record-store-refused";
+    committed: RuleWriteCommitted;
+    detail: string;
 };
 /** A7 redeem 的结果。 */
 export type LocalImportRedeemed = 
@@ -332,6 +340,14 @@ export type RuleImportPrepared = {
     ok: false;
     reason: "too-many-candidates";
     candidates: number;
+}
+/** 引擎的审批记录店建记录失败(core 7.65.0 起 `prepareCcImport` 答拒臂而不是抛):`retriable` 为真 ⇒ 本臂(无票、无规则落店,
+ *  同一请求原样重发即是出路;`committed` 原样是引擎那一词)。引擎说不可重试的拒(契约上不出现)不进本臂,响亮抛。 */
+ | {
+    ok: false;
+    reason: "record-store-refused";
+    committed: RuleWriteCommitted;
+    detail: string;
 };
 /** 导入 redeem 的结果。wire 口径写死(端点=http/routes/rules.ts):成功 ⇒ 200 回执 `{ members, rev }`(与 local-import 口
  *  同一张、同一个铸点;落定律见 {@link ImportOutcome});票拒五类(自造 / 别人的 / 错车道 / 过期 / 已用过)与裁定性拒绝
@@ -768,6 +784,18 @@ export interface RuleConsentLane {
         scope: DurableRuleScope;
     }): Promise<RuleWritten>;
 }
+/**
+ * 兑付腿拒绝里的**店故障**两词(审批记录店的读 / CAS / dot 分配失败与规则店自己的读写失败同两词):`store_read` / `store_write`。
+ * 其余十五词是裁定性拒。卡道重不重试 = 引擎的 `retriable` **∧** 本谓词(见 {@link throwIfRetriable}):`retriable` 真而码不是店故障 = 版本不同步,不重试、响一行;
+ * 两只导入口不读本谓词(只读 `retriable` 与 `committed`,见 `openRefusalOf`)。
+ * 闭集穷举(词表属主 core 加词 ⇒ 这里编译红,由人裁新词归哪边)。
+ */
+export declare function isRuleStoreFault(code: RuleRefusalCode): code is "store_read" | "store_write";
+/**
+ * 确认拒里**同一请求重来即可**的三词(闭集穷举):`conflict`(CAS 输给并发写者)、`store_read`(读记录抛,确认一个字没写)、`store_write`
+ * (记确认的 CAS 抛:记录可能已落 —— 同一确认重来,已落的记录答幂等的 yes;core 7.65.0 [ref])。其余是裁定。两只导入口读它定「放回认领 / 裁定拒」。
+ */
+export declare function confirmRefusalRetries(reason: ConfirmRefusalReason): boolean;
 export declare function createRuleConsentLane(stores: RuleConsentStores, opts?: {
     ticketTtlMs?: number;
     newTicketId?: () => string;