@sema-agent/server 7.150.0 → 7.152.0

package/dist/plugins/image-index-sql.js

@@ -5,6 +5,7 @@ import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { createObjectColumnReader, decodeNullableJsonColumn, foldJsonColumn, jsonColumnText, readJsonArrayColumn, readJsonObjectColumn } from "./sql-json-column.js";
 import { normalizeIsoOrNull as isoOrNull } from "./sql-row-helpers.js";
 import { ensureIndexes } from "./ensure-index.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const PG_IMAGE_INDEX_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS sandbox_image_index (
      id                 VARCHAR(64) COLLATE "C"  NOT NULL,
@@ -381,6 +382,9 @@ export class SqlImageIndex {
         await this.db.query(`UPDATE sandbox_image_index SET ${sets.join(", ")} WHERE id = $${idx}`, params);
     }
 }
+sealStoreClass(SqlImageIndex, "sql-image-index", {
+    upsert: "exit", registerBuilding: "exit", getById: "exit", getByDigest: "exit", latestPublished: "exit", list: "exit", setStatus: "exit",
+});
 export class TiDBImageIndex extends SqlImageIndex {
     constructor(pool) {
         super(mysqlDriver(pool));

package/dist/plugins/landed-attendants.d.ts

@@ -0,0 +1,212 @@
+/**
+ * **会话的附随物只写在判过的那一位住客上** —— 落定席位(`StoreBackend.landedAttendants()`;SQL 两只后端与 local 后端各组一只)。
+ *
+ * ## 律(一句)
+ * 一只会话的附随物(文件历史图 · 会话规则行 · 回退锚;会话行的两位与自动标题另经会话店自己的行格写口,判官同一只)只写在一位**判过的**住客上:
+ * 每一笔写在一只**落定段**里 —— 段的第一步锁会话根行,用**同一只**判官(`session-row.ts` 的 `judgeLandedRow` = 行格写原语的判官以 `replay` 写者问:
+ * 行在 ∧ 非在删 ∧ 非委派分区 ∧ 属主与化身整对同,core `sessionRowMatches`)比住客;不是那一位 ⇒ 一个字节不写,席位答 `{ landed: false }`。
+ * 段的物理形:SQL = `plugins/session-row-sql.ts` 的 `withLandedRow`(一只事务:锁根行 → 判 → 各店的**语句片**(出口表的 `in-store`)在同一连接上跑 → 提交;死锁 / 仲裁输了从段首重来);
+ * local = `LocalSessionStore.withLanded`(这只会话的写锁一节,与删净段 `deleteSession` 同锁)。
+ *
+ * ## 住客从哪来(`landed` 的来源只有这几处)
+ *  · 会话同步提交臂 = 暂存提交在同一事务 / 写锁里读出、原子交回的 `committed.face`;identical 臂 = 门读的那一位;
+ *  · 运行腿的每轮回退锚 = 这条腿受理时见证的那一位(`LegFacts.sessionWitness`;新会话的第一条腿在 run 还在跑、认领还在手时读一次头钉住 —— `runs.ts` 的 `createRunAnchorWriter`);
+ *  · `PUT /v1/sessions/:id/policy` = 门读的那一位;自动标题器 = 起标题时读到的那一位(会话店的 `setTitleIfNull` 自己收行期望)。
+ * 所以「提交 / 门读 / 受理之后会话被删、同 id 被任何人(包括同一属主)重建」时,迟到的写落不进新住客;只删不重建时,落不进空闲 id。
+ *
+ * ## 腿(`SESSION_TREE_LEGS` 的三员子集 —— 「附随物」一词只有删净段那一张腿表)
+ *  · `wipe` —— overwrite-dst 的擦除:文件历史整 scope · 规则行(抹除语义同店的 `deleteBySession`,封键照封)· 锚,一段一事务(SQL)/ 一节(local);
+ *  · `replayHistory` —— 段外做门判与取值校验(SQL 店的 `prepareImport`:同图只校验、首推 / 替换续租),段内做空目标 / 同图 / 异图判与发布;异图 ∧ `allowReplace` ⇒ 段内删整 scope 再插
+ *    (SQL 一事务;local 两步在一节里串行 —— local 的「替换后目标留空」残余只在 local 上);
+ *  · `replayPolicy` —— **逐条一段**(与修前每条 `putRules` 一事务同粒度):段内锁读 prior、等内容跳过、收紧门、计客户端写、写;某条拒 ⇒ 抛 `SessionPolicyError`(之前各条已提交);
+ *    某条段判住客没了 ⇒ `{ landed: false }`,后续条不跑;
+ *  · `putPolicy` —— `PUT …/policy` 的一笔写(同一只语句源,一段);
+ *  · `putAnchors` —— 锚的**唯一**生产写口(会话同步两臂 · 四条运行腿的每轮捕获);一段内逐条 upsert。
+ *
+ * ## 不在这里的(如实)
+ *  · 运行期仍不进段的写者:文件历史捕获(`trackEdit` / `snapshot`)、条目追加、引擎经会话规则席的规则写 —— 它们在整笔写期间持有 run 认领(认领律令删除与在跑 run 互斥)。
+ *  · fork 子会话的文件历史由引擎在子会话首个 run 里懒承接(`adoptScope`),承接不比源会话的世代 —— 那一形的座在引擎,本席位不补。
+ */
+import { type FileHistoryError, type FileHistoryExport, type FileHistoryResult, type PutRulesOptions, type SessionPermissionRules, type SessionPolicyStore, type SessionRulesRecord, type StoredSessionRules } from "@sema-agent/core";
+import type { SqlDriver, SqlTxConn } from "./sql-driver.js";
+import type { LandedOutcome } from "../session-row.js";
+import type { SessionFace } from "../session-incarnation.js";
+import type { BlobGetter } from "../session-sync.js";
+import type { ServiceFileHistoryStore, ServiceSessionPolicyStore } from "./store-backend.js";
+/** 一条要落的锚(已判过的:`entryId` 在这次导入声明的条目里 / 是这条 run 的提交)。 */
+export interface LandedAnchor {
+    readonly eventId: string;
+    readonly entryId: string;
+}
+/** 落定席位(头注)。每个方法的 `landed` = 这一笔要落在的那一位住客(来源见头注)。 */
+export interface LandedAttendantSeat {
+    wipe(sessionId: string, landed: SessionFace): Promise<LandedOutcome<void>>;
+    replayHistory(sessionId: string, landed: SessionFace, envelope: FileHistoryExport, getter: BlobGetter, opts: {
+        readonly allowReplace: boolean;
+    }): Promise<LandedOutcome<FileHistoryReplayResult>>;
+    replayPolicy(sessionId: string, landed: SessionFace, records: readonly SessionRulesRecord[], operator: boolean): Promise<LandedOutcome<void>>;
+    putPolicy(sessionId: string, landed: SessionFace, principal: string | undefined, rules: SessionPermissionRules, opts: PutRulesOptions): Promise<LandedOutcome<StoredSessionRules>>;
+    putAnchors(sessionId: string, landed: SessionFace, anchors: readonly LandedAnchor[], owner: string | null): Promise<LandedOutcome<void>>;
+}
+/**
+ * SQL 席位写经的两只店(组合座 `store-backend.ts` 交入:后端交它自己的那一只 —— 读者读的同一只实例;本目录不 import `stores-sql/**`,所以这里按形写)。席位只调这几员:
+ * 文件历史的段外半(`prepareImport`,自己借连接,出口)与唯一折法 `importFailureOf`;两只店的**语句片**(出口表的 `in-store`:`publishImportOn` / `deleteScopeOn` /
+ * `putRulesOn` / `eraseOn`,只在落定段借给它们的事务连接上跑,错交回段的主人 = 本席位);撞键判官 `isDupKeyError`;抹除提交之后的响亮面 `discloseErased`
+ * (`eraseOn` 交回的封键交给它 —— 封键那一条 warn,只在段提交之后调)。`K` = 规则店的封键形(本席位只转交,不读)。
+ */
+export interface SqlAttendantStatements<K> {
+    readonly history: {
+        prepareImport(scope: string, data: FileHistoryExport, getter: BlobGetter, opts: {
+            readonly replace: boolean;
+        }): Promise<{
+            readonly ok: false;
+            readonly error: FileHistoryError;
+        } | {
+            readonly ok: true;
+            readonly mode: "same" | "publish";
+        }>;
+        publishImportOn(conn: SqlTxConn, scope: string, data: FileHistoryExport, plan: {
+            readonly ok: true;
+            readonly mode: "same" | "publish";
+        }, opts: {
+            readonly replace: boolean;
+        }): Promise<FileHistoryResult>;
+        deleteScopeOn(conn: SqlTxConn, scope: string): Promise<number>;
+        /** 导入接住的一只故障的唯一折法(店的图事务与本席位的发布步同读;`adopt_failed` + 判得出的 `permanence`)。 */
+        importFailureOf(err: unknown): FileHistoryError;
+    };
+    readonly policy: {
+        putRulesOn(conn: SqlTxConn, sessionId: string, principal: string | undefined, rules: SessionPermissionRules, opts: PutRulesOptions | undefined, how: {
+            readonly count: boolean;
+            readonly skip?: (prior: StoredSessionRules | null) => boolean;
+        }): Promise<StoredSessionRules | {
+            readonly skipped: true;
+        }>;
+        eraseOn(conn: SqlTxConn, sessionId: string): Promise<K>;
+        discloseErased(sessionId: string, sealed: K): void;
+        isDupKeyError(e: unknown): boolean;
+    };
+}
+/**
+ * SQL 落定席位:`db` = 这台后端的池包成的 `SqlDriver`(与会话店、三只附随店同一只池)。
+ * **席位是店的出口**(店边界律:`store-boundary.ts` 头注):每个方法自己借连接、开事务(`withLandedRow`),段里跑的锁根行句、各店的语句片、锚的语句片、
+ * 提交都在这一只事务里 —— 它们都不是出口(出口表记 `in-store`,不封),席位的方法才是。所以封口只在这里一处(`sealStoreObject`):段里任何一句抛的驱动错
+ * 原样回到段的重来环(死锁 / 撞键读原码照判;重来成功 ⇒ 什么都不记),只在离开席位时换成「原码 + 稳定句」(原句只进 `at=store` 运维行,恰一次),
+ * 调用方(会话同步两臂 · `PUT …/policy` · 运行腿的锚写)读到的一律是边界形。
+ */
+export declare function createSqlLandedAttendantSeat<K>(db: Pick<SqlDriver, "dialect" | "connect">, statements: SqlAttendantStatements<K>): LandedAttendantSeat;
+/** local 席位要的:会话店的落定段 + 三只附随店的动词(规则店是**不计数**的内层店 —— 计数口由段交出,计数外包会回到会话店的锁,锁不可重入)。 */
+export interface LocalAttendantStores {
+    readonly sessions: {
+        withLanded<T>(sessionId: string, landed: SessionFace, body: (count: () => Promise<void>) => Promise<T>): Promise<LandedOutcome<T>>;
+    };
+    readonly history: ServiceFileHistoryStore;
+    readonly policy: ServiceSessionPolicyStore;
+    readonly anchors: {
+        put(sessionId: string, eventId: string, entryId: string, owner: string | null): Promise<void>;
+        deleteBySession(sessionId: string): Promise<unknown>;
+    };
+}
+/** local 落定席位(本地后端与进程内夹具同一只组装)。 */
+export declare function createLocalLandedAttendantSeat(stores: LocalAttendantStores): LandedAttendantSeat;
+/** The history-import capability face of a `FileHistoryStore` (`importHistory` is OPTIONAL on the core
+ *  contract — a store without it cannot be a 2c history sink). */
+export interface FileHistoryImportFace {
+    importHistory(scope: string, data: FileHistoryExport, srcGetBlob: BlobGetter): Promise<FileHistoryResult>;
+}
+/** Single-point capability probe ([ref] R7): does `fs` carry the optional `importHistory` seam?
+ *  Returns the bound method (never a naked function reference — `this` inside must resolve to `fs`) or
+ *  `undefined` when absent. Callers gate on the RETURN VALUE, not a separate `typeof` check, so there is
+ *  exactly one place that knows the shape of the probe. */
+export declare function fileHistoryImportFace(fs: unknown): FileHistoryImportFace | undefined;
+/**
+ * {@link replayFileHistory} 的结果 = 店的 {@link FileHistoryResult};失败臂可再带 `missingBlob` —— 这一次尝试里**重放自己交给店的 getter 亲口答过 `undefined`** 的那枚 hash
+ * (「这枚 blob 不在」是 getter 观察到的事实,不是从店码里猜的:同一个 `adopt_failed` 也可能是取值抛了 / 发布步撞上库的故障,那两形 `missingBlob` 缺席)。
+ * 下发口({@link sendFileHistoryReplayFailure} 在路由里)据它铸 wire `missing_blob`,否则原样送店的码。
+ */
+export type FileHistoryReplayResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: FileHistoryError;
+    readonly missingBlob?: string;
+};
+export type FileHistoryReplayFailure = Extract<FileHistoryReplayResult, {
+    ok: false;
+}>;
+/**
+ * **The local seat's history leg** (it runs inside `LocalSessionStore.withLanded`, so the two steps below are serial under the session's
+ * write lock; the SQL seat publishes in one transaction instead — `prepareImport` + `publishImportOn`, so the "target left empty" residual
+ * below holds on the local backend only). The 2c PUSH replay of a session's file-history graph — keep-SOURCE convergence over core's
+ * non-destructive-target law. `importHistory` refuses a target that already holds a DIFFERENT graph
+ * (typed `conflict`; the identical envelope re-publishes idempotently). On that arm, when the store has
+ * the purge seam, the sync's documented semantic (the destination converges to the source's state, same
+ * posture as the policy/anchor replays) is applied: wipe the scope, then import once more. Every bundled
+ * store carries the verb (the SQL twins, and core's local File store from core 7.64.0), so the three backends
+ * read one rule; a store WITHOUT `deleteBySession` (an embedder's) surfaces the typed conflict unchanged —
+ * an honest capability limit, never a silent half-state. The wipe throws on a store fault (and core's stores
+ * refuse it while they run a write of the scope): the throw propagates, nothing is re-imported.
+ *
+ * Honest residual (recorded, not hidden): if the RE-import after the wipe fails (a blob corrupted in
+ * transit past the Phase-A presence check), the destination's old graph is already gone and the target
+ * is left EMPTY — worse than the moment before this call, but strictly self-healing: the client re-PUTs
+ * the blob and re-POSTs, and the retry lands on an empty target (importHistory's first-import arm).
+ * The alternative (keeping the old graph) would wedge every retry on the same typed conflict forever.
+ *
+ * 缺 blob 的事实只在这里读一次:每次尝试给店的 getter 都包一层观察,店取到 `undefined` 就记下那枚 hash(按次计,替换臂的第二次尝试从空白起),
+ * 失败时随结果交出({@link FileHistoryReplayResult.missingBlob})。预检(按落点的可见性读 `LandingBlobFaces.visible`,`session-sync.ts`)管「这台部署根本收不到 / 这个落点看不见」,
+ * `srcGetBlob` 就是那一次可见性读的取值口(集外答 `undefined`);这里管「预检过了而这一枚取不到」(对象存储里已丢 / 校验和不符按缺席读 / 预检与重放之间被孤儿回收清走)—— 同一只不变量的两端,wire 上同一个词。
+ */
+export declare function replayFileHistory(store: ServiceFileHistoryStore, scope: string, envelope: FileHistoryExport, srcGetBlob: BlobGetter, opts: {
+    allowReplace: boolean;
+}): Promise<FileHistoryReplayResult>;
+/** [ref] ①(死码 A6 修的移植):同内容判据 —— 比较「归一化、去 rev」后的字节形。putRules 每次
+ *  无条件写都 rev+1,而 rev 是 operator 乐观锁的 CAS 令牌(`PutRulesOptions.expectedRev`),
+ *  幂等重试/无害重复同步不该把在途 CAS 打失败。归一化用 core 的 `normalizeRules`(store 落盘
+ *  前走同一函数 ⇒ 两侧同坐标);它略过店的戳 `rev` / `gen`(`listBySession` 的 rules 含 rev,
+ *  它不是内容;core 7.51.0 [ref] 起 `normalizeRules` 自己略过,修前的 `stripRev` 包裹随之退役)。
+ *  两侧过的是同一只形读法(core 7.51.0 `readSessionRulesShape`):`incoming` 由写口读者(引擎的写口判官)交出,`stored` 由店的读回交出 ——
+ *  店读回读不出形的行答 `corrupt`、根本到不了这里,所以 `normalizeRules` 对两侧都不抛(修前本仓的读回比引擎宽,另有一只判官先挡一次)。
+ *  🔴 字节同 ≠ 意思同(core 7.51.2 行自带文法戳;codex r1 [high] 验真):`normalizeRules` 把店的戳 `rev` / `gen` / `grammar` 都略过,而同一串桶字节在两种文法里是两句话 ——
+ *  目的行无戳(文法 0:`toolAllow` 里的 `Bash(rm:*)` 什么都不放行)、导入记录带 `grammar: 1`(放行 rm),只比字节会判「同内容」、零次 putRules、同步答 200 而目的行仍是旧意思。
+ *  所以字节同之外还问引擎的收紧比对 `loosenReasons` **双向**(两侧各在自己的文法里读:`stored` 带 `rev`,`incoming` 带 `grammar`):两个方向都「没放宽」才是同一句话;
+ *  意思不同就交给 `putRules` 的判官(非 operator ⇒ `loosen_forbidden`;operator ⇒ 改写成当前文法、盖戳)。本仓仍零处读 / 比戳值;意思由引擎说。
+ *  🔴 core 7.55.0 [ref]:行还有一格 **operator 部分**(`StoredSessionRules.operatorRules`:非 operator 的写只能收回非 operator 写加上去的东西;缺席 = 整行归 operator)。
+ *  桶同、意思同,这一次写仍可能挪动它 —— operator 重放把整行变成 operator 的(引擎写口判官的答:operator 写的值整只归 operator)。只比桶会判「同内容」⇒ 零次 putRules ⇒
+ *  属主盖过戳的目的行保持「属主收得回」,源端 operator 断言过的条目在目的端被属主一条非 operator 的写收回(安全轴的静默放宽)。所以第三问:这一次写之后的部分
+ *  = 引擎写口判官对(目的行, 记录, 这次重放的态度)的答,与目的行现有的部分按同一读法(缺席 = 整行)比;不同就交给 `putRules`。判官拒 ⇒ 原样上抛(`putRules` 会拒同一句)。
+ *  `operator` 必填:同一份记录在 operator 与非 operator 的重放下是两种写(漏传是编译错,不是一条静默的读法)。 */
+export declare function sameRulesContent(stored: StoredSessionRules | null, incoming: SessionPermissionRules, operator: boolean): boolean;
+/** [ref] ① 的重放腿共享实现:PUSH 路由的两条 policy 重放腿(Phase A identical 短路支 / Phase B
+ *  commit 后支)都从这里走 —— 等内容跳过(rev 零漂移),真变更照常落地(E6 tighten-only 门在
+ *  putRules 内部,此处不重述)。 */
+export declare function replayPolicyRecords(store: Pick<SessionPolicyStore, "getRules" | "putRules">, sessionId: string, records: readonly SessionRulesRecord[], operatorOk: boolean): Promise<void>;
+/** [ref] ② 能力预检(fail-loud 方向,[ref] 判据:保护型能力缺席=fail-closed):consented
+ *  overwrite-dst 需要 policy 店的 `deleteBySession` purge seam 才能不留混合态;缺席=true,路由在
+ *  commit **之前**用它干净中止(此时零写入落地),wire 拒因字面量归路由所有(api-error-text-freeze
+ *  锚字面站点)。anchor 店的 deleteBySession 是类型必填、history 店有 core 必填的 `reap` 兜底(+
+ *  {@link replayFileHistory} 的 conflict 收敛臂),都不构成缺席面;唯一可缺的就是 policy 这条
+ *  (core 接口上是可选方法)。 */
+export declare function overwriteWipeIncapable(policyStore: ServiceSessionPolicyStore | undefined): boolean;
+/** [ref] ②(死码 ⓪ 擦除步的移植):consented overwrite-dst = keep-source,结果必须是**源端那
+ *  一份**,不得混成「源端对话 + 目的端遗留 policy/anchor/历史」(混合态比丢历史更危险:悬空
+ *  anchor 指向已 purge 的 entry、被放弃分支的 policy 行继续 gating、目的端旧历史图挡住源端图的
+ *  importHistory 空目标法则)。调用时点=commit(原子 swap)成功**之后**、附随物重放**之前**:
+ *  死码在任何写入前擦(其 entries 写本身非原子);活路由有真 commit point,擦在 commit 前会在
+ *  「commit 失败」时留下反向混合态(目的端对话完好、附随物已毁)——方向更坏。
+ *  诚实残余:进程在 commit 与本函数之间崩溃时,重试落 Phase A identical 支(无 wipe)⇒ 遗留行
+ *  可存活;该窗口窄于修前世界(修前=遗留行**恒**存活),与 §8「历史重放失败 ⇒ 422 重试自愈」
+ *  同款接受,记录于此不装没有。
+ *  各店姿势:file history=deleteBySession(整 scope 清空;blob 走异步孤儿 GC)缺席则 core 必填
+ *  `reap(scope, [])`(丢全部 boundary;v1 基线按 core 契约留存 —— 随后 {@link replayFileHistory}
+ *  的 conflict 臂在有 purge 缝的店上收敛,无缝的店如实 422);anchor=直调(类型必填);
+ *  policy=deleteBySession(路由已用 {@link overwriteWipeIncapable} 预检过,此处缺席=类型外的
+ *  JS 层残缺实现,直调抛 TypeError 即 fail-loud)。 */
+export declare function wipeSessionAttendants(stores: {
+    fileHistoryStore?: ServiceFileHistoryStore | undefined;
+    sessionPolicyStore?: ServiceSessionPolicyStore | undefined;
+    resumeAnchorStore?: {
+        deleteBySession(sessionId: string): Promise<unknown>;
+    } | undefined;
+}, sessionId: string): Promise<void>;
+//# sourceMappingURL=landed-attendants.d.ts.map

package/dist/plugins/landed-attendants.js

@@ -0,0 +1,161 @@
+import { judgeSessionRulesWrite, loosenReasons, normalizeRules } from "@sema-agent/core";
+import { withLandedRow } from "./session-row-sql.js";
+import { putAnchorOn, deleteAnchorsOn } from "./resume-anchor-store-sql.js";
+import { sealStoreObject } from "./store-boundary.js";
+function observedGetter(getter) {
+    let missing;
+    return {
+        get: async (hash) => {
+            const bytes = await getter(hash);
+            if (bytes === undefined && missing === undefined)
+                missing = hash;
+            return bytes;
+        },
+        missing: () => missing,
+    };
+}
+function withMissing(r, missing) {
+    return r.ok || missing === undefined ? r : { ok: false, error: r.error, missingBlob: missing };
+}
+function dupKeyRetry(policy) {
+    return { alsoRetry: (err) => policy.isDupKeyError(err) };
+}
+function countedUnlessSame(rules, operator) {
+    return { count: true, skip: (prior) => sameRulesContent(prior, rules, operator) };
+}
+export function createSqlLandedAttendantSeat(db, statements) {
+    const { history, policy } = statements;
+    return sealStoreObject({
+        async wipe(sessionId, landed) {
+            const out = await withLandedRow(db, sessionId, landed, async (tx) => {
+                await history.deleteScopeOn(tx, sessionId);
+                await deleteAnchorsOn(tx, db.dialect, sessionId);
+                return policy.eraseOn(tx, sessionId);
+            });
+            if (!out.landed)
+                return out;
+            policy.discloseErased(sessionId, out.value);
+            return { landed: true, value: undefined };
+        },
+        async replayHistory(sessionId, landed, envelope, getter, opts) {
+            const observed = observedGetter(getter);
+            const plan = await history.prepareImport(sessionId, envelope, observed.get, { replace: opts.allowReplace });
+            if (!plan.ok) {
+                const still = await withLandedRow(db, sessionId, landed, async () => undefined);
+                return still.landed ? { landed: true, value: withMissing(plan, observed.missing()) } : still;
+            }
+            try {
+                return await withLandedRow(db, sessionId, landed, async (tx) => withMissing(await history.publishImportOn(tx, sessionId, envelope, plan, { replace: opts.allowReplace }), observed.missing()));
+            }
+            catch (err) {
+                return { landed: true, value: withMissing({ ok: false, error: history.importFailureOf(err) }, observed.missing()) };
+            }
+        },
+        async replayPolicy(sessionId, landed, records, operator) {
+            for (const rec of records) {
+                const one = await withLandedRow(db, sessionId, landed, (tx) => policy.putRulesOn(tx, sessionId, rec.principal, rec.rules, { operator }, countedUnlessSame(rec.rules, operator)), dupKeyRetry(policy));
+                if (!one.landed)
+                    return one;
+            }
+            return { landed: true, value: undefined };
+        },
+        async putPolicy(sessionId, landed, principal, rules, opts) {
+            const out = await withLandedRow(db, sessionId, landed, (tx) => policy.putRulesOn(tx, sessionId, principal, rules, opts, { count: true }), dupKeyRetry(policy));
+            if (!out.landed)
+                return out;
+            if ("skipped" in out.value)
+                throw new Error("createSqlLandedAttendantSeat.putPolicy: no skip predicate was given, yet the write was skipped");
+            return { landed: true, value: out.value };
+        },
+        async putAnchors(sessionId, landed, anchors, owner) {
+            const out = await withLandedRow(db, sessionId, landed, async (tx) => {
+                for (const a of anchors)
+                    await putAnchorOn(tx, db.dialect, sessionId, a.eventId, a.entryId, owner);
+            });
+            return out.landed ? { landed: true, value: undefined } : out;
+        },
+    }, "sql-landed-attendants", { wipe: "exit", replayHistory: "exit", replayPolicy: "exit", putPolicy: "exit", putAnchors: "exit" });
+}
+export function createLocalLandedAttendantSeat(stores) {
+    const { sessions, history, policy, anchors } = stores;
+    const counted = (count) => ({
+        getRules: (sessionId, principal) => policy.getRules(sessionId, principal),
+        putRules: async (sessionId, principal, rules, opts) => {
+            await count();
+            return policy.putRules(sessionId, principal, rules, opts);
+        },
+    });
+    return {
+        wipe: (sessionId, landed) => sessions.withLanded(sessionId, landed, () => wipeSessionAttendants({ fileHistoryStore: history, sessionPolicyStore: policy, resumeAnchorStore: anchors }, sessionId)),
+        replayHistory: (sessionId, landed, envelope, getter, opts) => sessions.withLanded(sessionId, landed, () => replayFileHistory(history, sessionId, envelope, getter, opts)),
+        replayPolicy: (sessionId, landed, records, operator) => sessions.withLanded(sessionId, landed, (count) => replayPolicyRecords(counted(count), sessionId, records, operator)),
+        putPolicy: (sessionId, landed, principal, rules, opts) => sessions.withLanded(sessionId, landed, (count) => counted(count).putRules(sessionId, principal, rules, opts)),
+        putAnchors: (sessionId, landed, list, owner) => sessions.withLanded(sessionId, landed, async () => {
+            for (const a of list)
+                await anchors.put(sessionId, a.eventId, a.entryId, owner);
+        }),
+    };
+}
+export function fileHistoryImportFace(fs) {
+    const candidate = fs?.importHistory;
+    if (typeof candidate !== "function")
+        return undefined;
+    return { importHistory: candidate.bind(fs) };
+}
+export async function replayFileHistory(store, scope, envelope, srcGetBlob, opts) {
+    const face = fileHistoryImportFace(store);
+    if (face === undefined) {
+        return { ok: false, error: { code: "unsupported_format", message: "this deployment's file-history store has no importHistory seam" } };
+    }
+    const attempt = async () => {
+        const observed = observedGetter(srcGetBlob);
+        return withMissing(await face.importHistory(scope, envelope, observed.get), observed.missing());
+    };
+    let r = await attempt();
+    if (!r.ok && r.error.code === "conflict" && opts.allowReplace && typeof store.deleteBySession === "function") {
+        await store.deleteBySession(scope);
+        r = await attempt();
+    }
+    return r;
+}
+export function sameRulesContent(stored, incoming, operator) {
+    if (stored === null)
+        return false;
+    const norm = (r) => JSON.stringify(normalizeRules(r));
+    if (norm(stored) !== norm(incoming))
+        return false;
+    if (loosenReasons(stored, incoming).length !== 0 || loosenReasons(incoming, stored).length !== 0)
+        return false;
+    return operatorPartUnmoved(stored, incoming, operator);
+}
+function operatorPartUnmoved(stored, incoming, operator) {
+    const next = judgeSessionRulesWrite(stored, incoming, { operator });
+    const partOf = (row) => JSON.stringify(normalizeRules(row.operatorRules ?? row));
+    return partOf(next) === partOf(stored);
+}
+export async function replayPolicyRecords(store, sessionId, records, operatorOk) {
+    for (const rec of records) {
+        const cur = await store.getRules(sessionId, rec.principal);
+        if (sameRulesContent(cur, rec.rules, operatorOk))
+            continue;
+        await store.putRules(sessionId, rec.principal, rec.rules, { operator: operatorOk });
+    }
+}
+export function overwriteWipeIncapable(policyStore) {
+    return policyStore !== undefined && typeof policyStore.deleteBySession !== "function";
+}
+export async function wipeSessionAttendants(stores, sessionId) {
+    const fs = stores.fileHistoryStore;
+    if (fs !== undefined) {
+        if (typeof fs.deleteBySession === "function")
+            await fs.deleteBySession(sessionId);
+        else
+            await fs.reap(sessionId, []);
+    }
+    if (stores.resumeAnchorStore !== undefined)
+        await stores.resumeAnchorStore.deleteBySession(sessionId);
+    const policy = stores.sessionPolicyStore;
+    if (policy !== undefined)
+        await policy.deleteBySession(sessionId);
+}
+//# sourceMappingURL=landed-attendants.js.map

package/dist/plugins/leader-run-store-sql.js

@@ -5,6 +5,7 @@ import { decodeNullableJsonColumn, foldJsonColumn, jsonColumnText, readNonNullJs
 import { ensureIndexes } from "./ensure-index.js";
 import { buildObjectivePreview } from "../user-authored-text.js";
 import { RUN_IDENTITY_COLUMNS, readRunIdentityCells, runIdentityCells } from "../identity-source.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const LEADER_RUN_TABLE = "leader_run";
 const LEADER_RUN_STATUSES = new Set(["running", "completed", "failed", "needs_human"]);
 const LEADER_RUN_ERROR_CODES = new Set(["cancelled"]);
@@ -173,6 +174,9 @@ export class SqlLeaderRunStore {
         return res.affected > 0;
     }
 }
+sealStoreClass(SqlLeaderRunStore, "sql-leader-run-store", {
+    createRun: "exit", getRun: "exit", getByIdem: "exit", requestCancel: "exit", reapStaleRunning: "exit", backdateStartedAtForTest: "exit", finishRun: "exit",
+});
 export class TiDBLeaderRunStore extends SqlLeaderRunStore {
     constructor(pool) {
         super(mysqlDriver(pool));

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

@@ -1,5 +1,5 @@
 import { type Checkpoint, type CheckpointPage, type CheckpointRowRead, type CheckpointSessionCursor, type CheckpointSessionQuery, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
-import { type CheckpointAskCandidate, type CtxClaimPut, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type ExpiredApprovalGate, type ExpiredGatePosition, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-face.js";
+import { type CheckpointAskCandidate, type CtxClaimPut, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type ExpiredApprovalGate, type ExpiredGatePosition, type PendingCheckpoint, type PendingRowBinding, type CardScopeRootSeat } from "./checkpoint-store-face.js";
 import { type CtxWriteClaim } from "./store-contracts.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
 /**
@@ -16,6 +16,8 @@ export interface LocalCheckpointStoreOptions {
     /** E21 owner guard (the LocalSessionStore's owner read, `headOf(id)?.owner`: `undefined` = no session row). Absent ⇒ owner guard degrades
      *  to null-owner-only (a non-null owner with no owner source purges NOTHING — fail-closed, mirrors the SQL EXISTS guard). */
     readSessionOwner?: (sessionId: string) => Promise<string | null | undefined>;
+    /** 「不再询问」规则 project root 的铸卡快照席(SQL 孪生同一只;缺席 = 永不绑 ⇒ 不记快照)。 */
+    cardScopeRoot?: CardScopeRootSeat;
 }
 /** checkpoint 店在数据根下自己铸的目录(构造器与一次性迁移 M39 的名册同读这一只)。 */
 export declare function localCheckpointStoreDirsFor(root: string): {
@@ -85,6 +87,12 @@ export declare class LocalCheckpointStore {
     private readonly hostTokens;
     private readonly hostOfToken;
     private readonly hostSessionsPath;
+    /**
+     * **铸卡快照索引**:每张卡上「不再询问」规则的 project root(SQL 孪生 `checkpoint.card_scope_root` 列在本店的同一个事实;`put` 读席一次)。不可知 ⇒ 不登记
+     * (读作 `null`,兑付不铸 scope)。与归属索引同一条落盘纪律(先登记、后内核 put;整文件原子替换)。
+     */
+    private readonly cardScopeRoots;
+    private readonly cardScopeRootsPath;
     private readonly opts;
     constructor(root: string, opts?: LocalCheckpointStoreOptions);
     /**
@@ -180,8 +188,8 @@ export declare class LocalCheckpointStore {
      *
      * 🔴 **为什么必须有这一口**(不是锦上添花):[ref] 让 local 车道有了持久 ask 账,于是收敛器在这条车道上
      * 第一次真的有行可扫。缺这一口 ⇒ 判据 1 结构性不命中 ⇒ **窗到期 park 的 ask 行永远停在 `PARKING`**,
-     * 而那个态在 wire 上是有后果的:`POST /v1/tool-approvals/:id/respond` 的 `PARKING` 臂答的是
-     * `202 parking_in_progress + retryAfterMs`(它的前提是「`bindBatch` 毫秒级就到」),在一台绑不了的机器上
+     * 而那个态在 wire 上是有后果的:决断口 `POST /v1/tasks/:taskId/asks/:askId/decision` 命中 `PARKING` 行答的是
+     * 一次带退避的「稍后再试」(它的前提是「`bindBatch` 毫秒级就到」),在一台绑不了的机器上
      * 那句「再试一次」**永远不会兑现**;run 跑到终局后判据 2 还会把它收成
      * `DENIED(routing_failure_fail_closed)` ⇒ 迟到答拿到的判别位是 `denied` —— 对一条**人真的批准过**的 ask
      * 撒谎。两条都是相对 7.80.2 的回归,根因同一个:**判据 1 的读口只有 SQL 孪生有**。修在源头 = 把这一口
@@ -216,6 +224,8 @@ export declare class LocalCheckpointStore {
     peekPendingScope(sessionId: string, binding?: PendingRowBinding): Promise<string | null | undefined>;
     /** 归在这只 run 会话上的待决卡(归属索引 → 逐张 `get`;只认 pending,scope 给了就再判一次)。 */
     private runPendings;
+    /** SQL 孪生 `cardScopeRootOf` 的本地形(铸卡快照索引;不在 ⇒ `null`)。 */
+    cardScopeRootOf(token: CheckpointToken): Promise<string | null>;
     /** SQL 孪生 `hostSessionOfCard` 的本地形:`undefined` = 没有这一行;`null` = 行在、归属索引里没有它(M49 还没回填到的存量卡)。 */
     hostSessionOfCard(token: CheckpointToken): Promise<string | null | undefined>;
     /**

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

@@ -1,22 +1,19 @@
 import { writeLogText } from "../observability/logger.js";
 import { z } from "zod";
-import { denySweepOwns, parkedApprovalCard } from "../approval-content-kind.js";
-import { parkRowFacts, skillCardFacts } from "../approval-card.js";
-import { durableRowIdentity } from "../checkpoint-identity.js";
+import { denySweepOwns } from "../approval-content-kind.js";
 import { createHash } from "node:crypto";
 import { closeSync, existsSync, fsyncSync, openSync, readFileSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { IS_WIN32 } from "./host-platform.js";
 import { join } from "node:path";
-import { CHECKPOINT_LIST_LIMITS, FileCheckpointStore, atomicWriteFile, checkpointDeadlinePassed, ensureDir, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
+import { CHECKPOINT_LIST_LIMITS, FileCheckpointStore, judgeCheckpointRow, summarizeCheckpoint, atomicWriteFile, checkpointDeadlinePassed, ensureDir, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
 import { approvalPayloadFingerprint } from "./approval-payload-fingerprint.js";
-import { approvalDecisionOfWinner, boundedRuleOffers, boundedToolInput, candidateIdentityOf, DENY_SWEEP_PAGE_ROWS, isUnreadableSummaryForm, parkedLegTaskId, pendingRowPrecedes, queueRowGateKind, queueTriageOrder, readRiskDescriptorBody, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS, } from "./checkpoint-store-face.js";
+import { approvalDecisionOfWinner, buildQueueActionFacts, buildQueueRow, candidateIdentityOf, DENY_SWEEP_PAGE_ROWS, pendingRowPrecedes, queueRowGateKind, queueTriageOrder, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS, } from "./checkpoint-store-face.js";
 import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
 import { hostSessionOf } from "./checkpoint-index-columns.js";
-import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, isJsonObject, readStringArrayColumn } from "./sql-json-column.js";
+import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, readStringArrayColumn } from "./sql-json-column.js";
 import { UNMANAGED_RETENTION } from "./retention-declaration.js";
 import { assertJsonColumnWritable, createObjectColumnReader } from "./sql-json-column.js";
 import { FENCE_LANDED } from "./store-contracts.js";
-import { recordFailOpen } from "../observability/fail-open.js";
 const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
 function terminalAtOf(cp) {
     const createdAt = cp.createdAt;
@@ -32,16 +29,6 @@ function sweepDeadlineKey(deadline) {
 function sweepPositionPrecedes(a, b) {
     return a.deadline < b.deadline || (a.deadline === b.deadline && a.token < b.token);
 }
-function queueRiskDescriptorOf(gate) {
-    const raw = isJsonObject(gate) ? gate.riskDescriptor : undefined;
-    if (raw === undefined || raw === null)
-        return null;
-    const shape = readRiskDescriptorBody(raw);
-    if (shape.problem === undefined)
-        return shape.value;
-    recordFailOpen("server.approvals.risk-descriptor-cell-unreadable");
-    return null;
-}
 function ctxFileOf(sessionId) {
     return `${sanitizePathComponent(sessionId).slice(0, 48)}-${createHash("sha256").update(sessionId).digest("hex").slice(0, 12)}.json`;
 }
@@ -69,6 +56,7 @@ const CtxRecordSchema = z.object({
 const readCtxRecord = createZodColumnReader(CtxRecordSchema);
 const readScopeRegistry = readStringArrayColumn;
 const readSessionTokenIndex = createZodColumnReader(z.record(z.string(), z.array(z.string())));
+const readCardScopeRootIndex = createZodColumnReader(z.record(z.string(), z.string()));
 function createCtxRecordReader() {
     const readPayload = createObjectColumnReader();
     return (body) => {
@@ -107,6 +95,8 @@ export class LocalCheckpointStore {
     hostTokens = new Map();
     hostOfToken = new Map();
     hostSessionsPath;
+    cardScopeRoots = new Map();
+    cardScopeRootsPath;
     opts;
     constructor(root, opts = {}) {
         this.inner = new FileCheckpointStore(root);
@@ -115,6 +105,7 @@ export class LocalCheckpointStore {
         this.scopesPath = join(root, "checkpoint-scopes.json");
         this.sessionTokensPath = join(root, "checkpoint-session-tokens.json");
         this.hostSessionsPath = join(root, "checkpoint-host-sessions.json");
+        this.cardScopeRootsPath = join(root, "checkpoint-card-scope-roots.json");
         const dirs = localCheckpointStoreDirsFor(root);
         this.ctxDir = dirs.ctx;
         this.tmpDir = dirs.tmp;
@@ -146,6 +137,11 @@ export class LocalCheckpointStore {
                 this.indexHost(host, toks);
             }
         }
+        if (existsSync(this.cardScopeRootsPath)) {
+            for (const [tok, root] of Object.entries(decodeJsonColumn(readFileSync(this.cardScopeRootsPath, "utf8"), readCardScopeRootIndex, "checkpoint-card-scope-roots.json (the local card→rule-scope-root snapshot index)"))) {
+                this.cardScopeRoots.set(tok, root);
+            }
+        }
     }
     registerDurably(record, undo, persist) {
         if (!record())
@@ -188,6 +184,10 @@ export class LocalCheckpointStore {
         const host = hostSessionOf(cp);
         this.registerDurably(() => !this.scopes.has(cp.scope) && (this.scopes.add(cp.scope), true), () => this.scopes.delete(cp.scope), () => atomicWriteFile(this.tmpDir, this.scopesPath, JSON.stringify([...this.scopes])));
         this.registerDurably(() => this.indexHost(host, [token]) > 0, () => this.unindexHost(host, token), () => this.persistHostSessions());
+        const scopeRoot = this.opts.cardScopeRoot?.of(cp.sessionId);
+        if (scopeRoot !== undefined) {
+            this.registerDurably(() => !this.cardScopeRoots.has(token) && (this.cardScopeRoots.set(token, scopeRoot), true), () => this.cardScopeRoots.delete(token), () => atomicWriteFile(this.tmpDir, this.cardScopeRootsPath, JSON.stringify(Object.fromEntries(this.cardScopeRoots))));
+        }
         this.registerDurably(() => {
             if (this.sessionTokens.get(cp.sessionId)?.has(token))
                 return false;
@@ -283,45 +283,31 @@ export class LocalCheckpointStore {
     }
     async listPending(scope) {
         const rows = [];
-        for (const { token, cp, summary } of await this.pendings(scope)) {
+        for (const { token, cp, summary: listed } of await this.pendings(scope)) {
+            let summary = listed;
+            let reading;
+            try {
+                summary = summarizeCheckpoint(cp, () => { });
+                reading = { rowVerdict: summary.rowVerdict, cp, summary };
+            }
+            catch {
+                reading = { rowVerdict: judgeCheckpointRow(cp), cp };
+            }
             const gateKind = queueRowGateKind(summary.gateKind);
             if (gateKind === undefined)
                 continue;
-            const joinKey = durableRowIdentity("approvals-queue", summary.checkpointId, token);
             const host = this.hostOfToken.get(token);
-            const taskId = parkedLegTaskId(cp.state?.rowTaskId, host === undefined ? null : ((await this.opts.getActiveTaskId?.(host)) ?? null));
-            const createdAt = summary.createdAt !== undefined ? { createdAt: summary.createdAt } : {};
-            const deadline = summary.deadline ?? null;
-            if (isUnreadableSummaryForm(summary)) {
-                rows.push({ sessionId: summary.sessionId, ...joinKey, scope: summary.scope, toolName: null, toolCallId: null, gateKind, taskId, input: null, ...createdAt, deadline, riskDescriptor: null, rowVerdict: summary.rowVerdict });
-                continue;
-            }
-            const pa = cp.pendingAction;
-            const toolCallId = pa?.toolCallId ?? null;
-            rows.push({
+            const claimHolder = host === undefined ? null : ((await this.opts.getActiveTaskId?.(host)) ?? null);
+            const address = {
+                token,
                 sessionId: summary.sessionId,
-                ...joinKey,
                 scope: summary.scope,
-                toolName: pa?.toolName ?? null,
-                toolCallId,
-                ...(toolCallId !== null ? { boundCallId: toolCallId } : {}),
-                ...(pa?.boundInputHash !== undefined ? { boundInputHash: pa.boundInputHash } : {}),
                 gateKind,
-                taskId,
-                input: boundedToolInput(pa?.args),
-                ...createdAt,
-                deadline,
-                riskDescriptor: queueRiskDescriptorOf(cp.gate),
-                ...(() => {
-                    const rs = boundedRuleOffers(pa?.ruleOffers);
-                    return rs !== undefined ? { ruleOffers: rs } : {};
-                })(),
-                ...(pa?.hasBidiControls === true ? { hasBidiControls: true } : {}),
-                ...((card) => (card !== undefined ? { approvalCard: card } : {}))(parkedApprovalCard(cp.gate)),
-                ...parkRowFacts(cp.pendingAction),
-                ...skillCardFacts(summary),
-                rowVerdict: summary.rowVerdict,
-            });
+                ...(summary.createdAt !== undefined ? { createdAt: summary.createdAt } : {}),
+                deadline: summary.deadline ?? null,
+                claimHolder,
+            };
+            rows.push(buildQueueRow(address, buildQueueActionFacts(reading)));
         }
         return rows.sort(queueTriageOrder);
     }
@@ -414,6 +400,9 @@ export class LocalCheckpointStore {
         }
         return out;
     }
+    async cardScopeRootOf(token) {
+        return this.cardScopeRoots.get(token) ?? null;
+    }
     async hostSessionOfCard(token) {
         const host = this.hostOfToken.get(token);
         if (host !== undefined)