@sema-agent/server 7.149.0 → 7.151.0

package/dist/plugins/adoption-log-sql.d.ts

@@ -133,8 +133,10 @@ export declare class SqlAdoptionLogStore implements AdoptionLogStore {
     constructor(db: SqlDriver);
     private q;
     /** 池级只读执行面(phase 0 的 preflight 扫描用——它**零写**,不需要也不该占一条事务连接)。
-     *  写路径一律走 {@link rebindTransaction};把驱动整个暴露出去会让调用方能绕开 phase CAS。 */
+     *  写路径一律走 {@link rebindTransaction};把驱动整个暴露出去会让调用方能绕开 phase CAS。
+     *  交出的是**封过**的执行面(只一个 `query`,出店口:库错只带原码 + 稳定句),不是驱动本身。 */
     get reader(): SqlExec;
+    private sealedReader;
     /**
      * 发起腿的 **insert-or-fetch 原子形**。返回读回的行(可能是别人插的)+ 是否本次插入。
      * 调用方据 `row.toPrincipal !== toPrincipal` 判「同 from 异 to」⇒ typed 409。

package/dist/plugins/adoption-log-sql.js

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { acquireAdvisoryLockWithin, releaseAdvisoryLock } from "./ensure-schema-lock-policy.js";
 import { ensureIndexes } from "./ensure-index.js";
+import { sealStoreClass, sealStoreObject } from "./store-boundary.js";
 export const ADOPTION_LOG_TABLE = "adoption_log";
 export const ADOPTION_PHASE = {
     INTENT: 2,
@@ -105,8 +106,9 @@ export class SqlAdoptionLogStore {
         return this.db.dialect === "mysql" ? mysql : pg;
     }
     get reader() {
-        return this.db;
+        return (this.sealedReader ??= sealStoreObject({ query: (sql, params) => this.db.query(sql, params) }, "sql-adoption-log-reader", { query: "exit" }));
     }
+    sealedReader;
     async ensureAdoption(row) {
         const emptyLegs = "[]";
         const res = await this.db.query(this.q(`INSERT IGNORE INTO ${ADOPTION_LOG_TABLE} (${COLS}) VALUES (?, ?, ?, ?, 'in_flight', ?, ?, NULL, NULL, NULL, ?, ?)`, `INSERT INTO ${ADOPTION_LOG_TABLE} (${COLS}) VALUES ($1, $2, $3, $4, 'in_flight', $5, $6, NULL, NULL, NULL, $7, $8) ON CONFLICT (from_principal) DO NOTHING`), [row.adoptionId, row.fromPrincipal, row.toPrincipal, ADOPTION_PHASE.INTENT, emptyLegs, emptyLegs, row.nowMs, row.nowMs]);
@@ -216,6 +218,10 @@ export class SqlAdoptionLogStore {
         }
     }
 }
+sealStoreClass(SqlAdoptionLogStore, "sql-adoption-log-store", {
+    ensureAdoption: "exit", getById: "exit", getByFrom: "exit", listInFlight: "exit", rebindOn: "exit", sweepOn: "exit", advancePhase: "exit", putConfigs: "exit",
+    finalizeAdopted: "exit", finalizeRejected: "exit", withLock: "exit",
+});
 export class TiDBAdoptionLogStore extends SqlAdoptionLogStore {
     constructor(pool) {
         super(mysqlDriver(pool));

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

@@ -2,7 +2,7 @@ import { type ExecutionLane } from "../execution-lane-caps.js";
 import { type LocalAskLaneBackfillRefusal } from "./one-time-migrations.js";
 import type { AskState } from "../approval-ask-machine.js";
 import type { SettleCause } from "../approval-deny-reasons.js";
-import type { AskCallCoordinate, AskRow, AskTerminalClaimIntent, AskTerminalClaimOpts, AskTerminalClaimOutcome, AskTransitionPatch, ApprovalAskStore, BatchRow, BindGateInput, BindResult, DecideAskInput, DecideResult, EnsureAskResult, ExpireResult, NewAskRow } from "./approval-ask-store-sql.js";
+import type { AskCallCoordinate, AskDecisionRecord, AskRow, AskTerminalClaimIntent, AskTerminalClaimOpts, AskTerminalClaimOutcome, AskTransitionPatch, ApprovalAskStore, BatchRow, BindGateInput, BindResult, DecideAskInput, DecideResult, EnsureAskResult, ExpireResult, NewAskRow, RecordParkedDecisionResult } from "./approval-ask-store-sql.js";
 /** 数据根下的目录名。**按店命名**,与兄弟 File 店同规(`approval-nonces` / `approval-ask-audit` /
  *  `approval-exemptions` / `resume-anchors` / `checkpoint-ctx` / …)—— 首版写的是族名 `approvals`,而那
  *  正是读者会去找**持久 park 行**的地方(它们其实在 `checkpoint-ctx`),且持久数据面的名字按硬 breaking
@@ -24,7 +24,7 @@ export declare const ASK_JOURNAL_COMPACT_GROWTH = 2;
  * 账本的**动词闭集**([ref] 形)。运行期的词表判定与编译期的穷尽 `switch` 读同一份:
  * 往这里加一个词,{@link FileApprovalAskStore.replayOp} 的 switch 立刻编译红(漏一口不可能发布)。
  */
-declare const JOURNAL_OPS: readonly ["ensureAsk", "transitionAsk", "decideAsk", "claimTerminal", "claimTerminalRefuse", "expireAsk", "bindBatch", "abortBatch", "deferReconcile", "resolveProvisional", "deleteBySession", "reapSettledAsks", "reapEmptyBatches"];
+declare const JOURNAL_OPS: readonly ["ensureAsk", "transitionAsk", "decideAsk", "recordParkedDecision", "claimTerminal", "claimTerminalRefuse", "expireAsk", "bindBatch", "abortBatch", "deferReconcile", "resolveProvisional", "deleteBySession", "reapSettledAsks", "reapEmptyBatches"];
 type JournalOpWord = (typeof JOURNAL_OPS)[number];
 /** 运行期词表(上面的数组)与类型面动词维({@link JournalCall})的**双向**对表 —— 任一边加词而另一边
  *  没跟上,这个别名解析成 `never`,{@link JOURNAL_OP_TABLE_GATE} 的赋值当场编译红。 */
@@ -59,6 +59,12 @@ type JournalCall = {
     askId: string;
     batchId: string;
     decision: DecideAskInput;
+}
+/** 停驻形的人决落行。更老的读者不认这个动词 ⇒ 拒启并点名出路(与留存两动词同一条降级纪律)。 */
+ | {
+    op: "recordParkedDecision";
+    askId: string;
+    record: AskDecisionRecord;
 } | {
     op: "claimTerminal";
     askId: string;
@@ -202,6 +208,8 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
      * (整本账的信封号另算 —— 见顶注「信封版本」)。
      */
     decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
+    /** 停驻形的人决落行 —— 出域的一次不落账本(与 {@link decideAsk} 同一条 [ref] 理由),其余落账 → 内核。 */
+    recordParkedDecision(askId: string, owner: string | null, record: AskDecisionRecord): Promise<RecordParkedDecisionResult>;
     claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent, opts?: AskTerminalClaimOpts): Promise<AskTerminalClaimOutcome>;
     expireAsk(askId: string, batchId: string): Promise<ExpireResult>;
     bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;

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

@@ -20,6 +20,7 @@ const JOURNAL_OPS = [
     "ensureAsk",
     "transitionAsk",
     "decideAsk",
+    "recordParkedDecision",
     "claimTerminal",
     "claimTerminalRefuse",
     "expireAsk",
@@ -280,6 +281,8 @@ export class FileApprovalAskStore {
                 return this.core.transitionAsk(rec.askId, rec.from, rec.to, rec.patch);
             case "decideAsk":
                 return this.core.decideAsk(rec.askId, rec.batchId, this.core.peekAsk(rec.askId)?.owner ?? null, rec.decision);
+            case "recordParkedDecision":
+                return this.core.recordParkedDecision(rec.askId, this.core.peekAsk(rec.askId)?.owner ?? null, rec.record);
             case "claimTerminal":
                 return this.core.claimTerminal(rec.askId, rec.batchId, rec.intent, rec.cause !== undefined ? { cause: rec.cause } : undefined);
             case "claimTerminalRefuse":
@@ -318,6 +321,11 @@ export class FileApprovalAskStore {
             return this.core.decideAsk(askId, batchId, owner, journalled);
         return this.write({ op: "decideAsk", askId, batchId, decision: journalled }, (c) => this.core.decideAsk(c.askId, c.batchId, owner, c.decision));
     }
+    async recordParkedDecision(askId, owner, record) {
+        if (!askRowCarriesOwner(this.core.peekAsk(askId), owner))
+            return this.core.recordParkedDecision(askId, owner, record);
+        return this.write({ op: "recordParkedDecision", askId, record }, (c) => this.core.recordParkedDecision(c.askId, owner, c.record));
+    }
     async claimTerminal(askId, batchId, intent, opts) {
         switch (intent) {
             case "expire":

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

@@ -31,7 +31,7 @@
  */
 import { type AskState, type BatchState } from "../approval-ask-machine.js";
 import type { ExecutionLane } from "../execution-lane-caps.js";
-import type { AskCallCoordinate, AskDecision, AskRow, AskTerminalClaimIntent, AskTerminalClaimOpts, AskTerminalClaimOutcome, AskTransitionPatch, ApprovalAskStore, BatchRow, BindGateInput, BindResult, DecideAskInput, EnsureAskResult, DecideResult, ExpireResult, NewAskRow } from "./approval-ask-store-sql.js";
+import type { AskCallCoordinate, AskDecision, AskDecisionRecord, AskRow, AskTerminalClaimIntent, AskTerminalClaimOpts, AskTerminalClaimOutcome, AskTransitionPatch, ApprovalAskStore, BatchRow, BindGateInput, BindResult, DecideAskInput, EnsureAskResult, DecideResult, ExpireResult, NewAskRow, RecordParkedDecisionResult } from "./approval-ask-store-sql.js";
 /**
  * [ref] 的 `updatedInput` **入店编码**——两 twin 共用的那一只(本函数是唯一真源)。
  *
@@ -99,6 +99,11 @@ export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * 停驻形的人决落行(接口契约见 SQL 侧 {@link ApprovalAskStore.recordParkedDecision})。判定序照 SQL twin:行在 ∧ `PARKED` ∧ 属主维(UPDATE 谓词)→ 才轮到撞键
+     * (UNIQUE `(task_id, idempotency_key)` 的内存镜像,与 `decideAsk` 同一段;本行自己占着同一把键不算撞)。态不变。
+     */
+    recordParkedDecision(askId: string, owner: string | null, record: AskDecisionRecord): Promise<RecordParkedDecisionResult>;
     /**
      * [ref] 原子终局 claim(接口契约见 SQL 侧 {@link ApprovalAskStore.claimTerminal})。**委托形**:CAS 走
      * 既有 verb(expire ⇒ `this.expireAsk`;cancel ⇒ `this.transitionAsk(STREAM_PENDING→VOID)`)——律 2

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

@@ -1,6 +1,17 @@
 import { ASK_TERMINAL, canAskTransition } from "../approval-ask-machine.js";
 import { APPROVAL_ENDING_CAUSES } from "../approval-deny-reasons.js";
 import { askAttachedToSession, askRowCarriesOwner, askRowOnCall, assertDecideSource, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
+function applyDecisionRecord(row, record, now) {
+    row.decision = record.decision;
+    row.decisionActor = record.decisionActor ?? null;
+    row.decisionNote = record.decisionNote ?? null;
+    row.settledBy = record.settledBy ?? null;
+    row.decidedVia = record.decidedVia ?? null;
+    row.decidedAtMs = now;
+    row.idempotencyKey = record.idempotencyKey ?? null;
+    row.rev += 1;
+    row.updatedAtMs = now;
+}
 function applyPatch(row, patch) {
     if (patch.decision !== undefined)
         row.decision = patch.decision;
@@ -181,19 +192,27 @@ export class InMemoryApprovalAskStore {
         batch.rev += 1;
         batch.updatedAtMs = now;
         ask.state = "DECIDED";
-        ask.decision = decision.decision;
-        ask.decisionActor = decision.decisionActor ?? null;
-        ask.decisionNote = decision.decisionNote ?? null;
-        ask.settledBy = decision.settledBy ?? null;
-        ask.decidedVia = decision.decidedVia ?? null;
+        applyDecisionRecord(ask, decision, now);
         if (decision.updatedInput === undefined)
             delete ask.updatedInput;
         else
             ask.updatedInput = encodedUpdatedInput;
-        ask.decidedAtMs = now;
-        ask.idempotencyKey = decision.idempotencyKey ?? null;
-        ask.rev += 1;
-        ask.updatedAtMs = now;
+        return { ok: true, row: { ...ask } };
+    }
+    async recordParkedDecision(askId, owner, record) {
+        if (record.idempotencyKey != null)
+            assertIdempotencyKeyShape(record.idempotencyKey);
+        assertDecideSource(record);
+        const ask = this.asks.get(askId);
+        if (!ask || ask.state !== "PARKED" || !askRowCarriesOwner(ask, owner))
+            return { ok: false, reason: "ask_not_parked", row: projectDecideReading(ask ? { ...ask } : null, owner) };
+        if (record.idempotencyKey != null) {
+            for (const [id, r] of this.asks) {
+                if (id !== askId && r.taskId === ask.taskId && r.idempotencyKey === record.idempotencyKey)
+                    return { ok: false, reason: "idempotency_conflict", row: { ...ask } };
+            }
+        }
+        applyDecisionRecord(ask, record, this.now());
         return { ok: true, row: { ...ask } };
     }
     async claimTerminal(askId, batchId, intent, opts) {

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

@@ -249,11 +249,17 @@ export interface AskTransitionPatch {
     provisional?: boolean;
     updatedAtMs: number;
 }
-export interface DecideAskInput {
+/**
+ * 一次人对一张卡的决定**落行的那一份记录** —— live 与停驻两形同一份、同一张列、同一只映射(SQL twin {@link SqlApprovalAskStore} 的 `decisionRecordValues`、
+ * 内存 twin 的 `applyDecisionRecord`):决议向 · 署名 · 理由 · 回决幂等键 · 出处两格(+ 决定时刻,店铸)。
+ * live 形随 `STREAM_PENDING → DECIDED` 那一笔单赢者 CAS 落({@link ApprovalAskStore.decideAsk});停驻形在停驻门受理之后落在仍 `PARKED` 的行上
+ * ({@link ApprovalAskStore.recordParkedDecision})。两形唯一的写者 = 协调器的回决写者(`ToolApprovalCoordinator.writeAskDecision`)。
+ */
+export interface AskDecisionRecord {
     decision: AskDecision;
     decisionActor?: unknown;
     decisionNote?: string | null;
-    /** 车4 §12-E:回决幂等键,赢 CAS 时随决议一起落列(见 `AskRow.idempotencyKey`)。缺席 ⇒ 列保持 NULL。 */
+    /** 车4 §12-E:回决幂等键,随决议一起落列(见 `AskRow.idempotencyKey`)。缺席 ⇒ 列 NULL。 */
     idempotencyKey?: string | null;
     /**
      * 🔴 [ref]:本次回决的**结算来源**,与决议同一条 UPDATE 落列 `settled_by`(语义/两态读法/为什么是
@@ -265,6 +271,9 @@ export interface DecideAskInput {
     settledBy?: HostSettledBy;
     /** core 7.61.0([ref]):`settledBy:"policy"` 旁的机器座位,与决议同一条 UPDATE 落列 `decided_via`(语义见 {@link AskRow.decidedVia});缺席 ⇒ 列 NULL。 */
     decidedVia?: DecidedVia;
+}
+/** live 形的决定 = 那份记录 + 随决议交给在等那条腿的编辑实参(停驻形的编辑走停驻门的绑定,不落问行)。 */
+export interface DecideAskInput extends AskDecisionRecord {
     /** [ref]:ctrl+g 编辑实参,与决议同一条 UPDATE 落列(语义三态见 {@link AskRow.updatedInput})。
      *  缺席 / `undefined` ⇒ 列 NULL(没带编辑);**`null` 是值**(编辑成 null),照存 JSON `"null"`。
      *  调用方纪律:deny 不传(店不替调用方判决议方向,写什么存什么)。 */
@@ -285,6 +294,18 @@ export type DecideResult = {
     reason: "batch_closed" | "ask_not_pending" | "idempotency_conflict";
     row: AskRow | null;
 };
+/**
+ * {@link ApprovalAskStore.recordParkedDecision} 的结局:`ok` ⇒ 落后的行;`ask_not_parked` ⇒ 行不在 / 不在 `PARKED` / 已出了门判过的属主域;
+ * `idempotency_conflict` ⇒ 这把键已被同 task 另一只问占着(UNIQUE `(task_id, idempotency_key)`)。`row` 与 {@link DecideResult} 同一只属主维投影。
+ */
+export type RecordParkedDecisionResult = {
+    ok: true;
+    row: AskRow;
+} | {
+    ok: false;
+    reason: "ask_not_parked" | "idempotency_conflict";
+    row: AskRow | null;
+};
 /**
  * 幂等键的入店卫生门(属主兜底轮 F2,三 twin 同判——SQL 双方言与 InMemory 都从这里过)。
  *
@@ -513,6 +534,15 @@ export interface ApprovalAskStore {
      * 缺省等于不绑属主,安全轴上那是静默放行。
      */
     decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * **停驻形的人决落行**(一张卡一条记录:停驻卡的决定记在它的问行上,行仍 `PARKED`)—— 停驻门(checkpoint 上的那道门,单赢者是续跑腿的门 CAS)
+     * **已经受理**这次决定之后,把它的记录({@link AskDecisionRecord})落到这只问的行上。态不变:停驻形的终局恒是那道门,不是这一笔。
+     * 谓词 = 行在 ∧ `state = 'PARKED'` ∧ 门判过的那位属主还在行上([ref],与 {@link decideAsk} 同一只属主维)。
+     * **覆写**:门被引擎重开(同一把 token 翻回待决、世代号前进)之后又被受理的那一次再落一次 —— 记录恒是「门上此刻站着的那次决定」的那一份
+     * (决议向、谁、带哪把键);读者只在门已决时认它(`ToolApprovalCoordinator` 的停驻形读法)。
+     * 唯一调用方 = 协调器的回决写者,只在赎回席 2xx 之后调。三 twin 同答。
+     */
+    recordParkedDecision(askId: string, owner: string | null, record: AskDecisionRecord): Promise<RecordParkedDecisionResult>;
     /**
      * [ref]:原子终局 claim —— 把「争终局」与「读真相」并成**一次**店往返(胜负判定与败方 `current` 读数
      * 在同一原子单元内,语义见 {@link AskTerminalClaimOutcome})。[ref]-R1 的病根「CAS 与读真相是两次店
@@ -751,6 +781,17 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * 一份决定记录({@link AskDecisionRecord})的前五格列值,序 = `decision, decision_actor, decision_note, settled_by, decided_via` ——
+     * live 形({@link decideAsk})与停驻形({@link recordParkedDecision})两条 UPDATE 共用这**一只**映射(一个事实一处铸列值)。
+     */
+    private decisionRecordValues;
+    /**
+     * 停驻形的人决落行(接口契约见 {@link ApprovalAskStore.recordParkedDecision})。单条 UPDATE,谓词 `state='PARKED'` + 属主维([ref] 的同一只方言镜像);
+     * `rev = rev + 1` 照 CAS 铁则②(MySQL 同值 UPDATE 的 affectedRows=0 坑:覆写同一份记录时列值可以逐字节相同)。
+     * `(task_id, idempotency_key)` 撞键 ⇒ typed 臂 `idempotency_conflict`(方言错误不出店,与 `decideAsk` 同一只判别)。
+     */
+    recordParkedDecision(askId: string, owner: string | null, record: AskDecisionRecord): Promise<RecordParkedDecisionResult>;
     /**
      * [ref] 原子终局 claim(接口契约见 {@link ApprovalAskStore.claimTerminal};类型语义见
      * {@link AskTerminalClaimOutcome})。expire 意图 = 既有 `expireAsk` 事务**原体**(步⓪-③ 逐字保留,

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

@@ -9,6 +9,7 @@ import { decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn,
 import { ensureIndexes } from "./ensure-index.js";
 import { isExecutionLane } from "../execution-lane-caps.js";
 import { retiredExecutionLaneHintM40 } from "./execution-lane-rename-m40.js";
+import { sealStoreClass } from "./store-boundary.js";
 export function assertIntegralEpochMs(field, value) {
     if (!Number.isSafeInteger(value)) {
         throw new TypeError(`approval-ask store: ${field} must be an integer epoch-ms (BIGINT column), got ${String(value)}`);
@@ -565,11 +566,7 @@ export class SqlApprovalAskStore {
             let askRes;
             try {
                 askRes = await conn.query(`UPDATE ${APPROVAL_ASK_TABLE} SET state='DECIDED', decision=${ph(dialect, 1)}, decision_actor=${ph(dialect, 2)}, decision_note=${ph(dialect, 3)}, settled_by=${ph(dialect, 4)}, decided_via=${ph(dialect, 5)}, updated_input=${ph(dialect, 6)}, decided_at_ms=${ph(dialect, 7)}, idempotency_key=${ph(dialect, 8)}, rev=rev+1, updated_at_ms=${ph(dialect, 9)} WHERE ${pendingClaimWhere(dialect, 10)} AND ${ownerWhere.sql}`, [
-                    decision.decision,
-                    decision.decisionActor == null ? null : this.json(decision.decisionActor),
-                    decision.decisionNote ?? null,
-                    decision.settledBy ?? null,
-                    decision.decidedVia ?? null,
+                    ...this.decisionRecordValues(decision),
                     decision.updatedInput === undefined ? null : this.json(decision.updatedInput),
                     now,
                     decision.idempotencyKey ?? null,
@@ -608,6 +605,32 @@ export class SqlApprovalAskStore {
             throw new Error(`decideAsk: row vanished after commit (askId=${askId})`);
         return { ok: true, row };
     }
+    decisionRecordValues(record) {
+        return [record.decision, record.decisionActor == null ? null : this.json(record.decisionActor), record.decisionNote ?? null, record.settledBy ?? null, record.decidedVia ?? null];
+    }
+    async recordParkedDecision(askId, owner, record) {
+        if (record.idempotencyKey != null)
+            assertIdempotencyKeyShape(record.idempotencyKey);
+        assertDecideSource(record);
+        const now = Date.now();
+        const dialect = this.db.dialect;
+        const ownerWhere = decideOwnerWhere(dialect, owner, 10);
+        let res;
+        try {
+            res = await this.db.query(`UPDATE ${APPROVAL_ASK_TABLE} SET decision=${ph(dialect, 1)}, decision_actor=${ph(dialect, 2)}, decision_note=${ph(dialect, 3)}, settled_by=${ph(dialect, 4)}, decided_via=${ph(dialect, 5)}, decided_at_ms=${ph(dialect, 6)}, idempotency_key=${ph(dialect, 7)}, rev=rev+1, updated_at_ms=${ph(dialect, 8)} WHERE ask_id = ${ph(dialect, 9)} AND state = 'PARKED' AND ${ownerWhere.sql}`, [...this.decisionRecordValues(record), now, record.idempotencyKey ?? null, now, askId, ...ownerWhere.params]);
+        }
+        catch (err) {
+            if (this.isDupKey(err))
+                return { ok: false, reason: "idempotency_conflict", row: projectDecideReading(await this.getAsk(askId), owner) };
+            throw err;
+        }
+        const row = projectDecideReading(await this.getAsk(askId), owner);
+        if (res.affected !== 1)
+            return { ok: false, reason: "ask_not_parked", row };
+        if (row === null)
+            throw new Error(`recordParkedDecision: row vanished after write (askId=${askId})`);
+        return { ok: true, row };
+    }
     async claimTerminal(askId, batchId, intent, opts) {
         const to = claimTargetState(intent);
         if (!canAskTransition("STREAM_PENDING", to)) {
@@ -877,6 +900,12 @@ export class SqlApprovalAskStore {
         return rows[0] ? mapBatchRow(rows[0]) : null;
     }
 }
+sealStoreClass(SqlApprovalAskStore, "sql-approval-ask-store", {
+    ensureAsk: "exit", transitionAsk: "exit", decideAsk: "exit", claimTerminal: "exit", expireAsk: "exit", bindBatch: "exit", abortBatch: "exit",
+    listByState: "exit", listPendingByTask: "exit", listPendingBySession: "exit", listByCall: "exit", listParkingBySourceSession: "exit", getAsk: "exit",
+    getByIdempotencyKey: "exit", deferReconcile: "exit", resolveProvisional: "exit", deleteBySession: "exit", reapSettledAsks: "exit", reapEmptyBatches: "exit",
+    getBatch: "exit", recordParkedDecision: "exit",
+});
 export class TiDBApprovalAskStore extends SqlApprovalAskStore {
     constructor(pool) {
         super(mysqlDriver(pool));

package/dist/plugins/approval-exemption-store.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { existsSync, readdirSync, rmSync } from "node:fs";
 import { AppendLog, ensureDir, sanitizePathComponent } from "@sema-agent/core";
 import { replayJsonlGuarded } from "../observability/corrupt-read-seat.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const APPROVAL_EXEMPTED_EVENT = "approval_exempted";
 export class TiDBApprovalExemptionStore {
     pool;
@@ -33,6 +34,7 @@ export class TiDBApprovalExemptionStore {
         return r.affectedRows;
     }
 }
+sealStoreClass(TiDBApprovalExemptionStore, "tidb-approval-exemption-store", { grant: "exit", has: "exit", list: "exit", revoke: "exit", deleteBySession: "exit" });
 export class PgApprovalExemptionStore {
     pool;
     constructor(pool) {
@@ -69,6 +71,7 @@ export class PgApprovalExemptionStore {
         return res.rowCount ?? 0;
     }
 }
+sealStoreClass(PgApprovalExemptionStore, "pg-approval-exemption-store", { grant: "exit", has: "exit", list: "exit", revoke: "exit", deleteBySession: "exit" });
 export class MemoryApprovalExemptionStore {
     bySession = new Map();
     async grant(sessionId, toolName, grantedBy) {

package/dist/plugins/approval-nonce-store.js

@@ -4,6 +4,7 @@ import { mysqlDriver, pgDriver, SQL_DB_NOW_MS } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
 import { replayJsonlGuarded } from "../observability/corrupt-read-seat.js";
 import { createLogger } from "../observability/logger.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const APPROVAL_NONCE_TABLE = "approval_nonce";
 export const MAX_APPROVAL_NONCE_CHARS = 190;
 export const APPROVAL_NONCE_FLOOR_TABLE = "approval_nonce_floor";
@@ -62,6 +63,7 @@ export class SqlApprovalNonceStore {
         return res.affected;
     }
 }
+sealStoreClass(SqlApprovalNonceStore, "sql-approval-nonce-store", { nowMs: "exit", consume: "exit", reapExpired: "exit" });
 export class TiDBApprovalNonceStore extends SqlApprovalNonceStore {
     constructor(pool, opts) {
         super(mysqlDriver(pool), opts);

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

@@ -1,4 +1,5 @@
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const PG_BREAKER_STATE_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS breaker_state (
      breaker_key VARCHAR(190) COLLATE "C"   NOT NULL,
@@ -91,6 +92,7 @@ export class SqlBreakerState {
         this.timer = undefined;
     }
 }
+sealStoreClass(SqlBreakerState, "sql-breaker-state", { get: "exit", set: "exit", refresh: "exit", startRefresh: "exit", stop: "exit" });
 export class TiDBBreakerState extends SqlBreakerState {
     constructor(pool, onWriteFail) {
         super(mysqlDriver(pool), onWriteFail);

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

@@ -1,4 +1,5 @@
 import { type AcquiredSession, type PlacedSessionRow, type RetentionDeclaration, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry } from "@sema-agent/core";
+import type { EntriesStreamOptions } from "../session-sync-kernel.js";
 import type { LocalSessionDeletionSection } from "../session-erase.js";
 import type { OwnerAwareSessionStore, SessionListItem } from "../security.js";
 import type { StagingHandle } from "../session-sync-kernel.js";
@@ -7,6 +8,7 @@ import { type PlacementAcquireOpts } from "./session-placement.js";
 import type { InstructionSourceStore } from "../instruction-source-notice.js";
 import type { SessionWorkspaceStore } from "../session-workspace.js";
 import { type SessionBirthFace, type SessionWithdrawFace } from "./session-birth.js";
+import type { SessionFace } from "../session-incarnation.js";
 export interface CachingOptions {
     /** Idle seconds a woken session is kept warm. 0 disables caching (pure passthrough). */
     ttlSec: number;
@@ -72,18 +74,13 @@ export declare class CachingSessionStore implements SessionStore {
     readonly withdrawBirth?: SessionWithdrawFace["withdrawBirth"];
     /** Delegated SessionRepo seam (§0.5) — list/fork/delete operate on the DURABLE tables directly (they bypass the
      *  warm cache by design; a fork/delete must read/write durable state, not a possibly-stale cached view). */
-    readonly listSessions?: (opts: {
-        owner?: string;
-        includeUnowned?: boolean;
-        cursor?: {
-            lastActivityAt: string;
-            sessionId: string;
-        };
-        limit: number;
-        q?: string;
-    }) => Promise<SessionListItem[]>;
+    readonly listSessions?: OwnerAwareSessionStore["listSessions"];
     /** 带住客的同一只列表面(原样转发;理由同 listSessions)。 */
     readonly listSessionRows?: OwnerAwareSessionStore["listSessionRows"];
+    /** 按 id 的种类读(`session-kind.ts`;纯转发、不经暖缓存 —— 答的是行)。🔴 必须转发:授权口的种类判与能力位读的是本类。 */
+    readonly sessionKindOf?: OwnerAwareSessionStore["sessionKindOf"];
+    /** 老化候选面(纯转发;读的是持久行)。🔴 必须转发:能力位 `sessionKinds` 与老化腿读的是本类。 */
+    readonly listIdleOfKind?: OwnerAwareSessionStore["listIdleOfKind"];
     readonly fork?: OwnerAwareSessionStore["fork"];
     /** fork 续写的店契约(原样转发;与 fork 同理绕过暖缓存 —— 读写的是持久行,新 id 本来就不在缓存里)。 */
     readonly forkTo?: OwnerAwareSessionStore["forkTo"];
@@ -99,7 +96,7 @@ export declare class CachingSessionStore implements SessionStore {
     readonly sessionSummaryOf?: (sessionId: string) => Promise<SessionListItem | undefined>;
     readonly writeSessionRowCells?: OwnerAwareSessionStore["writeSessionRowCells"];
     /** The auto-titler's NULL-only title write (SQL twins + local sidecar carry it; pure pass-through). */
-    readonly setTitleIfNull?: (sessionId: string, title: string) => Promise<boolean>;
+    readonly setTitleIfNull?: (sessionId: string, title: string, landed: SessionFace) => Promise<boolean>;
     readonly probeTitle?: (sessionId: string) => Promise<"none" | "untitled" | "titled">;
     /** [ref] —— 换源通告的基线面(`session_ext.instruction_source` / local sidecar),纯转发、不经暖缓存。
      *  🔴 必须转发(与 retention / placements 同一条教训):默认 `SESSION_CACHE_TTL_SEC=300` 把真店包进本类,
@@ -117,10 +114,7 @@ export declare class CachingSessionStore implements SessionStore {
      *  (read straight from the durable log, bypassing the warm cache, like exportEntries). The stream's per-batch query
      *  discipline (one pooled query per page) lives in the inner store; this wrapper just forwards. */
     readonly listEntryIds?: (sessionId: string) => Promise<string[] | null>;
-    readonly exportEntriesStream?: (sessionId: string, opts?: {
-        afterSeq?: number;
-        batchSize?: number;
-    }) => Promise<AsyncIterable<SessionTreeEntry> | null>;
+    readonly exportEntriesStream?: (sessionId: string, opts: EntriesStreamOptions) => Promise<AsyncIterable<SessionTreeEntry> | null>;
     /** 轴A #1(1.254):core B-17 forget 面(evict 本地 + 转发 inner 可选面)。 */
     forget?: (sessionId: string) => void | Promise<void>;
     readonly importEntries?: (sessionId: string, owner: string | null, entries: SessionTreeEntry[]) => Promise<void>;

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

@@ -15,6 +15,8 @@ export class CachingSessionStore {
     withdrawBirth;
     listSessions;
     listSessionRows;
+    sessionKindOf;
+    listIdleOfKind;
     fork;
     forkTo;
     executionPlacement;
@@ -82,6 +84,10 @@ export class CachingSessionStore {
             this.listSessions = ownerAware.listSessions.bind(inner);
         if (ownerAware.listSessionRows)
             this.listSessionRows = ownerAware.listSessionRows.bind(inner);
+        if (ownerAware.sessionKindOf)
+            this.sessionKindOf = ownerAware.sessionKindOf.bind(inner);
+        if (ownerAware.listIdleOfKind)
+            this.listIdleOfKind = ownerAware.listIdleOfKind.bind(inner);
         if (ownerAware.sessionSummaryOf)
             this.sessionSummaryOf = ownerAware.sessionSummaryOf.bind(inner);
         if (ownerAware.writeSessionRowCells)

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

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

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

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

package/dist/plugins/error-origin.js

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

package/dist/plugins/exec-path-law.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The execution seam's path law — ONE reading for every execution environment this server mints (the seven lanes: adb / device / e2b /
+ * host / k8s / local-docker / ssh) and for the sandbox write gate's stand-in environment (`boot/deferred-sandbox-path-env.ts`).
+ *
+ * The law (the engine's, `ExecutionEnv` contract; the engine's own `NodeExecutionEnv` reads every path this way): a path a method is
+ * handed is ABSOLUTE AS WRITTEN, or relative and ANCHORED at the environment's working directory with exactly one separator. Nothing here
+ * folds a `..` or a `.` and nothing resolves a link: the filesystem the path lands on resolves them, components first — so a `..` that
+ * follows a symbolic link goes where the link leads (`<base>/bridge/../next` with `bridge -> elsewhere/sub` names `<base>/elsewhere/next`).
+ * A lexical fold would name `<base>/next` instead: the write gate (which asks the real filesystem what the spelling names) and the tool
+ * (which opened the folded name) would then judge and touch two different files.
+ *
+ * Three faces, one anchor ({@link anchorUnder}): the path a method reads ({@link anchoredPath}), `joinPath` ({@link joinedPath}) and the
+ * paths a listing reports (each entry anchored under the path the listing was handed). The remote lanes' shell scripts (the link-chain walk
+ * and the staged write, `remote-shell.ts`) already anchor this way in shell; this module is the same law for the TypeScript faces.
+ *
+ * Pure leaf: string arithmetic only, no I/O.
+ */
+import type { PlatformPath } from "node:path";
+/**
+ * The two facts of a path family the law reads: its separator and its absolute-path judge. The remote lanes read POSIX whatever the
+ * worker runs on (`path.posix`; the device lane passes its one absolute-path judge, `isDeviceAbsolutePath`); the host lane reads the
+ * worker's own (`path`).
+ */
+export type SeamPathFamily = Pick<PlatformPath, "sep" | "isAbsolute">;
+/** `name` placed under `dir` with exactly one separator — never folded, never re-rooted. */
+export declare function anchorUnder(family: SeamPathFamily, dir: string, name: string): string;
+/** The path a method is handed, as the environment reads it: absolute ⇒ as written; relative ⇒ anchored at `cwd`. */
+export declare function anchoredPath(family: SeamPathFamily, cwd: string, p: string): string;
+/**
+ * `joinPath`: the first part as written; every later part is a segment, never a root (its leading separators are dropped); empty parts
+ * are dropped; the rest anchored in turn. No parts ⇒ `"."`.
+ */
+export declare function joinedPath(family: SeamPathFamily, parts: readonly string[]): string;
+//# sourceMappingURL=exec-path-law.d.ts.map

package/dist/plugins/exec-path-law.js

@@ -0,0 +1,13 @@
+export function anchorUnder(family, dir, name) {
+    const endsInSeparator = dir.endsWith(family.sep) || (family.sep === "\\" && dir.endsWith("/"));
+    return endsInSeparator ? `${dir}${name}` : `${dir}${family.sep}${name}`;
+}
+export function anchoredPath(family, cwd, p) {
+    return family.isAbsolute(p) ? p : anchorUnder(family, cwd, p);
+}
+export function joinedPath(family, parts) {
+    const leading = family.sep === "\\" ? /^[\\/]+/ : /^\/+/;
+    const named = parts.map((part, i) => (i === 0 ? part : part.replace(leading, ""))).filter((part) => part !== "");
+    return named.length === 0 ? "." : named.reduce((at, part) => anchorUnder(family, at, part));
+}
+//# sourceMappingURL=exec-path-law.js.map

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

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