@sema-agent/server 7.145.0 → 7.147.0

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,18 +5,18 @@ 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 { TOOL_RESULT_INDEXES } from "./tool-result-store-sql.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";
 import { OUTCOME_LEDGER_INDEXES } from "./outcome-ledger-sql.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/prompt-screen.d.ts

@@ -6,16 +6,13 @@
  * 会被交付,只有屏判完才知道;本服务存 / 转目标的每张面(run 行预览、续跑输入、标题器取材)因此只能在交付之后写交付的那一份
  * (律的属主 = `run-acceptance.ts`)。屏**不在**的腿上没有「屏前」:交付的就是请求原文,提交那一刻就知道 —— 与没有屏这回事之前逐字同。
  *
- * ## 判据(一条)
- * 两座任一注册的 `uses.events` 覆盖屏听的任一站 ⇒ 有屏。`uses.events` 是注册**声明**的事件全集(名字或 `<前缀>.*`);引擎准入保证一张注册挂上的
- * handler 不越出它声明的事件(越出 = 准入拒),所以「声明里没有」⇒ 这条腿的总线上**一定**没有屏 —— 判据只会多判有屏(声明了、`register`
- * 时没挂),不会漏判。多判的代价是这条腿的那几张面等到交付才写(写的仍是交付的那一份),不是放行。
- *
- * ## 过渡(引擎包根今天没有导出这一判据)
- * 屏听哪两站、`<前缀>.*` 怎么覆盖,读的是引擎自己的判据(引擎的 `promptScreenHasHandlers` 问的就是这两站;前缀形的展开同引擎准入的读法)。
- * 引擎在包根导出「一组注册声明了 prompt 屏」的判据之后,{@link PROMPT_SCREEN_STATIONS} 与 {@link covers} 一起退役,本函数改调引擎那一只 —— 读口换、判据不变。
+ * ## 判据(一条,引擎的)
+ * 引擎的 `promptScreenDeclaredBy`:两座的注册并起来,任一张的 `uses.events`(名字或 `<前缀>.*`,按引擎准入的读法展开)选中屏听的任一站
+ * (引擎的 `PROMPT_SCREEN_STATIONS`)⇒ 有屏。引擎准入保证一张注册挂上的 handler 不越出它声明的事件(越出 = 准入拒),所以「声明里没有」⇒
+ * 这条腿的总线上**一定**没有屏 —— 判据只会多判有屏(声明了、`register` 时没挂),不会漏判。多判的代价是这条腿的那几张面等到交付才写
+ * (写的仍是交付的那一份),不是放行。站名表与前缀展开只住在引擎里:引擎给屏加一站,本服务同一拍就认。
  */
-import type { ModRegistration } from "@sema-agent/core";
+import { type ModRegistration } from "@sema-agent/core";
 /** 这条腿的两座(缺席的座 = 没有注册)里有没有一张注册声明了 prompt 屏。 */
 export declare function promptScreenDeclared(seats: ReadonlyArray<ReadonlyArray<Pick<ModRegistration, "uses">> | undefined>): boolean;
 //# sourceMappingURL=prompt-screen.d.ts.map

package/dist/prompt-screen.js

@@ -1,8 +1,5 @@
-const PROMPT_SCREEN_STATIONS = ["prompt.submit", "classic.UserPromptSubmit"];
-function covers(declared, station) {
-    return declared === station || (declared.endsWith(".*") && declared.length > 2 && station.startsWith(declared.slice(0, -1)));
-}
+import { promptScreenDeclaredBy } from "@sema-agent/core";
 export function promptScreenDeclared(seats) {
-    return seats.some((seat) => seat?.some((registration) => registration.uses.events.some((declared) => PROMPT_SCREEN_STATIONS.some((station) => covers(declared, station)))) === true);
+    return promptScreenDeclaredBy(seats.flatMap((seat) => seat ?? []));
 }
 //# sourceMappingURL=prompt-screen.js.map

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 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,31 +192,22 @@ export type LocalImportRefusalCode =
  | "not_importable";
 /** 兑付回执的**成员级终态**(闭集,机读;`detail` 是给人看的那一半)。两只 redeem 口(cc-import / local-import)同一张表。
  *
- *  🔴 **引擎的成员拒一律落 `indeterminate`,本仓不铸 `refused`**:core 的 `RedeemedBatchMember` 拒绝臂只带一个**自由文本**
- *  `reason`,而它装的东西两类都有 —— 裁定(引擎 7.62.0 对旧导入记录里从 `/` 写起的全局规则答 `unsupported.layer_root:`;
- *  批里的收紧没落、同批放行被扣下的 `withheld:`)与店侧成因(读不出店 / 写面抛 / OCC 用尽 —— 写面抛时那一条**可能已经落了**)。
- *  按串去猜「这是裁定还是瞬时」正是本仓明令禁止的自造判读,所以一律 `indeterminate`(安全方向:不谎报落了,也不担保没落),
- *  `detail` 原样带引擎的话 —— 人读得到出路(例:那句 `unsupported.layer_root:` 自己说「重新 prepare,这一条会披露在 skipped」)。
- *  `refused` 留在词表里是给**带类型的**判别位到货那一天(引擎给拒绝臂一个机读的「裁定 / 瞬时」位之后,裁定那一类落 `refused`):
- *  它进了**落盘回执的边界 schema**(`ImportOutcomeSchema`;`redeemed_outcome` 列回读同一张词表),滚动升级窗里先升的进程写下的
- *  `refused`,后升的进程读得回。⚠️ 预览面**不用**这个词:那一面的拒绝形是 `admitted:false + LocalImportRefusalCode`
- *  ({@link LocalImportPreviewMember}),两面词表**不同**。 */
+ *  🔴 **引擎拒的成员,结局只读引擎的两位**(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 = 
 /** 这一次真的写进店里了。 */
 "persisted"
 /** 等价规则**已经在店**(引擎的 `deduped`)—— 同意早就生效,这次什么都不用做。 */
  | "no-op"
-/** 这条被拒了、确知没落(留给带类型判别位的词位,本版不铸 —— 见上)。 */
+/** 引擎拒了这一条,并答 `committed: "no"`、不可重试 —— 定了不立。重来同一条拒因(`reason`)会得同一个答,出路在 `detail`(引擎原话)。 */
  | "refused"
-/** **不知道落没落**:引擎在这一条上答了拒,而拒因只有自由文本。如实编,禁猜(猜"成了"会谎报一次没发生的授权,
- *  猜"没成"会让人以为可以盲目重来,而重来可能撞上一条其实已经存在的规则 —— 对账读 `GET /v1/rules`,重来走一次新的导入,幂等)。 */
+/** 7.145.x 及更早落定的票行(`redeemed_outcome`)里的词:引擎答 `committed: "unknown"` 的成员。7.146.0 起这一词**不再铸**(落定律:任一成员
+ *  未定 ⇒ 不落定、503 同票重走,见 {@link settleImportWalk});词表留着它只为回放读那份存量。 */
  | "indeterminate";
-/** `indeterminate` 的成因(闭集,一词)。
- *  「兑付走本身没走完」**不是**一个成员终态:那一形没有完整成员表,兑付不落定(放回认领、503 `state.rule_import_retry`,
- *  同一张票重走交出完整表)—— 所以没有第二个词。 */
-export type ImportIndeterminateCode = 
-/** 引擎在这一条上答了拒(`RedeemedBatchMember` 的 `refused` 臂),而拒因只有自由文本 ⇒ 落不了裁定,如实说"不知道"。 */
-"store_refused";
 /** prepare 面的一行。判别式联合:被收下的行**没有**拒因字段可读,被拒的行**必然**带拒因 ——
  *  「admitted 却带 reason」这种矛盾态在类型上不可表达。
  *  收下的**收紧**(deny / ask)在 prepare 当场经直写接缝落店,行带它的结局 `outcome`(`persisted` = 这次写了 / `no-op` = 等价规则已在店);
@@ -236,24 +227,26 @@ export type LocalImportPreviewMember = {
 };
 /** 一条收紧在 prepare 当场落店的结局(与兑付回执的 `persisted` / `no-op` 同词同义;直写接缝 `addPersistedRule` 的 `added` / `no-op`)。 */
 export type LocalImportTighteningOutcome = "persisted" | "no-op";
-/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link buildImportOutcomeMembers})。 */
+/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link settleImportWalk})。`reason` / `detail` 在场 ⇔ 引擎拒了这一条
+ *  (`refused` / `indeterminate`):`reason` = 引擎的闭集拒因码(`RuleRefusalCode`,core 属主,逐字),`detail` = 引擎给人看的那句话。 */
 export interface ImportOutcomeMember {
     key: ImportRuleKey;
     outcome: ImportMemberOutcome;
-    reason?: ImportIndeterminateCode;
+    reason?: RuleRefusalCode;
     detail?: string;
 }
 /**
  * 一次兑付的回执整只 —— **两只 redeem 口同一张**(cc-import / local-import 的 200 体都是 `{ members, rev }`,路由同一个铸点),
  * local-import 另把它**逐字**写进票行 `redeemed_outcome`(回放同源:回放答的就是它)。
  *
- * 🔴 **落定律(一条,两口同读)**:兑付走完、拿到引擎的**完整成员表** ⇒ 这次兑付落定,回执逐成员交出(引擎的成员拒落
- * `indeterminate`,见 {@link ImportMemberOutcome}),票不放回、不答 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 输给并发写者 / 店在走之前抛)⇒ 不落定:放回认领、503
+ * 成员表(引擎在走之前整批拒 / confirm 输给并发写者或撞记录店故障 / 店在走之前抛 / 循环里仍抛出来的异常),或任一成员**未定**(引擎答
+ * `retriable: true`:成员循环里审批记录店的记 dot CAS / dot 分配 / 读记录在规则写之前失败;或 `committed: "unknown"`:规则店的写抛 / 读回读不出)⇒ 不落定:放回认领、503
  * `state.rule_import_retry`,同一张票重来就是重走一遍 —— 兑付按引擎的设计幂等(记录里的 dot 台账),重走交出完整表,
- * 被打断的那一走已落的成员读 `no-op`。成员拒**不**按票自动重试:一条永久被拒的成员(旧记录里的 `unsupported.layer_root`)
+ * 被打断的那一走已落的成员读 `no-op`。确知的成员拒**不**按票自动重试:一条永久被拒的成员(旧记录里的 `unsupported.layer_root`)
  * 若走重试臂,客户端会 503 到票过期、临期放不回 ⇒ 404,已落成员不撤、被拒成员永不落 —— 7.144.0 及更早 cc-import 口就是这一形。
  */
 export interface ImportOutcome {
@@ -293,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 = 
@@ -339,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});票拒五类(自造 / 别人的 / 错车道 / 过期 / 已用过)与裁定性拒绝
@@ -346,12 +355,12 @@ export type RuleImportPrepared = {
  *  `state.rule_import_retry`;`state-unreadable` ⇒ 503 `state.rule_ticket_unreadable`。分类保留只为服务端日志/诊断与
  *  上述三分支的判据。 */
 export type RuleImportRedeemed = 
-/** 兑付走完、拿到完整成员表 ⇒ 落定(成员里有引擎拒的也在这一臂,那几行 `indeterminate`)。 */
+/** 兑付走完、拿到完整成员表且每个成员结局确定 ⇒ 落定(引擎确知没落的成员也在这一臂,那几行 `refused`)。 */
 {
     ok: true;
     outcome: ImportOutcome;
 }
-/** `retryable` = 这次失败**没有裁定任何事**、也**没有完整成员表**(store 抛错 / CAS 冲突 / 引擎走之前整批拒 / 走到一半抛),
+/** `retryable` = 这次兑付**没有落定**(store 抛错 / CAS 冲突 / 引擎走之前整批拒 / 循环里仍抛出来的异常 / 某个成员结局不知),
  *  认领已放回,属主原样重试即重走。
  *  它与裁定性拒绝(载荷被改写、记录不存在)分家是承重的:把两者塌成一格,一次数据库抖动就会被
  *  客户端读成「这张票永远不能用了」。⚠️ wire 面**不再**折 404:`retryable === true` ⇒ 503
@@ -775,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;