@sema-agent/server 7.150.0 → 7.151.0

package/dist/plugins/store-fault-sentence-m53.d.ts

@@ -0,0 +1,7 @@
+type Json = Record<string, unknown>;
+/** 后台子代记录的改写(见头注);不改 ⇒ `undefined`。 */
+export declare function rewrittenBackgroundRecordM53(record: unknown): Json | undefined;
+/** `tool_end` 事件数据的改写(见头注);不改 ⇒ `undefined`。 */
+export declare function rewrittenToolEndDataM53(data: unknown): Json | undefined;
+export {};
+//# sourceMappingURL=store-fault-sentence-m53.d.ts.map

package/dist/plugins/store-fault-sentence-m53.js

@@ -0,0 +1,25 @@
+import { outwardFailureCode, outwardStoreMessageOf } from "../terminal.js";
+const isRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+function outwardOrUnchanged(code, message) {
+    if (typeof code !== "string" || typeof message !== "string" || outwardFailureCode(code) === code)
+        return undefined;
+    const outward = outwardStoreMessageOf(code, message);
+    return outward === message ? undefined : outward;
+}
+export function rewrittenBackgroundRecordM53(record) {
+    if (!isRecord(record))
+        return undefined;
+    const outward = outwardOrUnchanged(record.errorCode, record.error);
+    if (outward === undefined)
+        return undefined;
+    const old = record.error;
+    const summary = typeof record.summary === "string" && old !== "" && record.summary.includes(old) ? { summary: record.summary.split(old).join(outward) } : {};
+    return { ...record, error: outward, ...summary };
+}
+export function rewrittenToolEndDataM53(data) {
+    if (!isRecord(data) || !isRecord(data.structured))
+        return undefined;
+    const outward = outwardOrUnchanged(data.structured.errorCode, data.structured.errorMessage);
+    return outward === undefined ? undefined : { ...data, structured: { ...data.structured, errorMessage: outward } };
+}
+//# sourceMappingURL=store-fault-sentence-m53.js.map

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

@@ -6,12 +6,13 @@ export type StoreFaultClass = "corrupt" | "connection" | "deployment" | "defect"
  */
 export declare function isCodeDefect(err: unknown): boolean;
 /** 判官本体。纯函数、不抛;只看被抛出的这一只对象(不沿 `cause` 链找)。连接类与部署错配两张识别表互斥,两者之间判序不影响结果(`test/store-fault-judge.test.ts` 钉互斥);
- *  程序错排在它们之后(带那两类归因键的对象按那两类认)。 */
+ *  程序错排在它们之后(带那两类归因键的对象按那两类认)。
+ *  首臂 = 店边界形({@link StoreBoundaryFault}):边界在**原错**上判过一次(连接类整句、errno 臂、1005 内层号都只在原错上读得到),词随形带走 —— 读它就是读那一判,不是第二种读法。 */
 export declare function storeFaultClassOf(err: unknown): StoreFaultClass;
 /**
  * 判官每个词的**对外句**(闭集 `Record`:判官加一个词而不在这里写出它对外怎么说 = 编译错)。这是本判官唯一的一张「对外怎么说」的表 ——
- * 失败要出 wire 时,调用方只拿**类别**说话,不把驱动的原句(带库用户名 / 主机 / 表名 / 约束名)交出去;驱动原句只进运维日志
- * (`terminal.ts` 的折码处),出口脱敏器是模式脱敏、认不出「这是库账号 / 表名」。每句只说两件事:**坏在哪一类** + **重试有没有用**,不带任何实例化的名字。
+ * 失败要出店 / 出 wire 时,调用方只拿**类别**说话,不把驱动的原句(带库用户名 / 主机 / 表名 / 约束名)交出去;驱动原句只进运维日志
+ * (店边界 `terminal.ts` 的 `storeBoundaryFault` 那一行 `at=store`),出口脱敏器是模式脱敏、认不出「这是库账号 / 表名」。每句只说两件事:**坏在哪一类** + **重试有没有用**,不带任何实例化的名字。
  *
  * 🔴 **句子只断言码本身证明得了的事**:判官读到的只有一个码,而同一个码形可以出自库驱动,也可以出自别的系统调用(`ECONNREFUSED` 出自任何一个套接字、`ENOENT` 出自文件系统),
  * 所以 `connection` 说「一条连接」而不说「数据库的连接」;`unclassified` 只说「带了一个本服务不公布的码」。只有 `deployment` 的两类码(缺表、权限拒:`42P01` / `42501` /
@@ -22,9 +23,27 @@ export declare function storeFaultClassOf(err: unknown): StoreFaultClass;
  */
 export declare const STORE_FAULT_OUTWARD_SENTENCE: Readonly<Record<StoreFaultClass, string>>;
 /**
- * 一个**失败码**的对外句 —— 终局因由只带码(引擎把错压成 `code` + `message` 两格,类型与 `cause` 链已不在)的那些站点用:判官读 `{ code }`(识别表按 `code` 字符串登记,
- * 数字 `errno` 只是同一件事的另一种写法,这里读不到也不影响:每个登记行都有 `code`),交回的词按 {@link STORE_FAULT_OUTWARD_SENTENCE} 说一句。
- * 判官是整仓一只,这里不第二次认「什么算连接类 / 部署错配类」。
+ * 对外句的**唯一拼法**(纯函数):判官的词 → 本表那一句 + 原码尾注 `[original code: <码>]`(码缺席 ⇒ 只有类别句)。两种输入、一只拼法:
+ *  · 店边界({@link StoreBoundaryFault}):词是边界在**原错**上判的那一个(带 `cause` 的包装、只带 errno 的错、无码整句 —— 只看码判不出的那几形都在原错上判得出);
+ *  · 只剩码的站点(终局因由 / 投影 / 抛出臂:引擎已把错压成 `code` + `message` 两格,类型与 `cause` 链已不在,`terminal.ts` 的 `outwardStoreMessage`):词 = 判官读 `{ code }`。
+ * 两者对同一次店失败说同一句(边界句原样过出口,出口的幂等判 `isOutwardStoreSentence` 由本表派生)。句子里没有「持久层失败」之类的前缀:码 `internal.store_error` 已经在同一条因由上说了辖域,
+ * 而抛出臂(没有因由、没有码)上同一句不该替抛出物断言它的出身。
  */
-export declare function storeFaultSentenceOfCode(code: string): string;
+export declare function outwardStoreSentence(cls: StoreFaultClass, code: string | undefined): string;
+/** 判官的词(闭集,与 {@link STORE_FAULT_OUTWARD_SENTENCE} 的键同一份):出口幂等判逐词比对用。 */
+export declare const STORE_FAULT_CLASSES: readonly StoreFaultClass[];
+/**
+ * **店边界形** —— 一只 SQL 店的任何出口(抛出值 / 包装错的 `cause` / 失败文本 / 交出的读器与事务对象)上驱动错的**唯一**形:原码 + 稳定句,别无他物。
+ * 自有成员恰为 `name` · `message` · `stack`(新铸,第一行就是稳定句)· `faultClass` · `code`(有码时)· `errno`(原错链上带数字 errno 时)——
+ * **不带** `cause`、`sqlMessage`、`sql`(带插值后的语句全文)、`sqlState`、`fatal`、node-pg `DatabaseError` 的 `detail` / `hint` / `where` / `table` / `column` / `constraint` …、
+ * 套接字错的 `syscall` / `address` / `port`、原 stack:引擎在拒绝路径上对抛出值做全量自有键快照,同主体档不跑主机 / 路径脱敏,所以只能是新对象,不能「删几键」。
+ * 唯一铸点 = 边界函数 `terminal.ts` 的 `storeBoundaryFault`(它在铸之前把原句经出口座记一行运维日志);本类住在判官旁边,因为判官的首臂读它带的词(`terminal.ts` → 本文件已是一条边,反向成环)。
+ */
+export declare class StoreBoundaryFault extends Error {
+    /** 判官在**原错**上读出的词(只算一次、随形带走)。 */
+    readonly faultClass: StoreFaultClass;
+    readonly code?: string;
+    readonly errno?: number;
+    constructor(faultClass: StoreFaultClass, code: string | undefined, errno: number | undefined);
+}
 //# sourceMappingURL=store-fault.d.ts.map

package/dist/plugins/store-fault.js

@@ -7,6 +7,8 @@ export function isCodeDefect(err) {
     return RUNTIME_DEFECT_CLASSES.some((cls) => err instanceof cls) && !Object.hasOwn(err, "cause");
 }
 export function storeFaultClassOf(err) {
+    if (err instanceof StoreBoundaryFault)
+        return err.faultClass;
     if (err instanceof StoreCorruptError)
         return "corrupt";
     if (isConnectionFaultError(err))
@@ -22,7 +24,21 @@ export const STORE_FAULT_OUTWARD_SENTENCE = {
     defect: "the service failed on an internal error; retrying fails the same way until the service is fixed",
     unclassified: "the failure carried a code this service does not publish; the operator log carries the original sentence",
 };
-export function storeFaultSentenceOfCode(code) {
-    return STORE_FAULT_OUTWARD_SENTENCE[storeFaultClassOf({ code })];
+export function outwardStoreSentence(cls, code) {
+    const sentence = STORE_FAULT_OUTWARD_SENTENCE[cls];
+    return code === undefined ? sentence : `${sentence} [original code: ${code}]`;
+}
+export const STORE_FAULT_CLASSES = Object.keys(STORE_FAULT_OUTWARD_SENTENCE);
+export class StoreBoundaryFault extends Error {
+    faultClass;
+    constructor(faultClass, code, errno) {
+        super(outwardStoreSentence(faultClass, code));
+        this.name = "StoreBoundaryFault";
+        this.faultClass = faultClass;
+        if (code !== undefined)
+            this.code = code;
+        if (errno !== undefined)
+            this.errno = errno;
+    }
 }
 //# sourceMappingURL=store-fault.js.map

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

@@ -6,6 +6,7 @@ import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isDupKeyError, retryOnDeadlock } from "./sql-errors.js";
 import { countClientWriteOn } from "./session-withdraw-sql.js";
 import { readAtAddress } from "./blob-backend.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const TaskAttachmentRecordSchema = z.object({
     id: z.string(),
     owner: z.string(),
@@ -420,6 +421,10 @@ export class TiDBTaskAttachmentStore {
         return out;
     }
 }
+sealStoreClass(TiDBTaskAttachmentStore, "tidb-task-attachment-store", {
+    put: "exit", get: "exit", getContent: "exit", releaseBytes: "exit", bind: "exit", listBySession: "exit", delete: "exit", deleteBySession: "exit",
+    reapUnbound: "exit", sweepOrphanObjects: "exit",
+});
 export class PgTaskAttachmentStore {
     bytes;
     db;
@@ -536,4 +541,8 @@ export class PgTaskAttachmentStore {
         return out;
     }
 }
+sealStoreClass(PgTaskAttachmentStore, "pg-task-attachment-store", {
+    put: "exit", get: "exit", getContent: "exit", releaseBytes: "exit", bind: "exit", listBySession: "exit", delete: "exit", deleteBySession: "exit",
+    reapUnbound: "exit", sweepOrphanObjects: "exit",
+});
 //# sourceMappingURL=task-attachment-store.js.map

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

@@ -50,9 +50,9 @@ export declare function ensurePgTaskListSchema(q: (text: string, params?: unknow
  * 事务内先对 meta 行 `FOR UPDATE`(与 `mutate` 同一把分区锁)⇒ 与并发的清单写串行,不会删到
  * 一半被插回新行。meta 行不在(从未写过任何任务)= 无锁可拿,DELETE 命中 0 行,幂等。
  */
-export declare function deleteTiDBTaskList(pool: MySqlPool, listKey: string): Promise<void>;
+export declare const deleteTiDBTaskList: (pool: MySqlPool, listKey: string) => Promise<void>;
 /** {@link deleteTiDBTaskList} 的 PG 孪生(同语义、同事务姿势)。 */
-export declare function deletePgTaskList(pool: PgPool, listKey: string): Promise<void>;
+export declare const deletePgTaskList: (pool: PgPool, listKey: string) => Promise<void>;
 export declare function createTiDBTaskListStore(pool: MySqlPool, listKey: string): TaskListStore;
 export declare function createPgTaskListStore(pool: PgPool, listKey: string): TaskListStore;
 //# sourceMappingURL=task-list-store-sql.d.ts.map

package/dist/plugins/task-list-store-sql.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { assertJsonMetadata } from "@sema-agent/core";
 import { pgHasUnstorable, pgSafeJsonStringify, PgUnstorableError } from "./pg-safe-json.js";
 import { decodeJsonColumn, foldJsonColumn, jsonColumnText } from "./sql-json-column.js";
+import { sealStoreFunction, sealStoreObject } from "./store-boundary.js";
 export const TASK_LIST_META_TABLE = "task_list_meta";
 export const TASK_LIST_ITEM_TABLE = "task_list_item";
 export function taskListKeyFor(sessionId) {
@@ -98,7 +99,7 @@ async function setOn(exec, dialect, listKey, id, itemJson) {
         ? `UPDATE ${TASK_LIST_META_TABLE} SET next_sort = ? WHERE list_key = ?`
         : `UPDATE ${TASK_LIST_META_TABLE} SET next_sort = $1 WHERE list_key = $2`, [sort + 1, listKey]);
 }
-export async function deleteTiDBTaskList(pool, listKey) {
+export const deleteTiDBTaskList = sealStoreFunction(async function deleteTiDBTaskList(pool, listKey) {
     assertListKeyBytes(listKey);
     const c = await pool.getConnection();
     try {
@@ -115,8 +116,8 @@ export async function deleteTiDBTaskList(pool, listKey) {
     finally {
         c.release();
     }
-}
-export async function deletePgTaskList(pool, listKey) {
+}, "sql-task-list-tidb.delete");
+export const deletePgTaskList = sealStoreFunction(async function deletePgTaskList(pool, listKey) {
     if (pgHasUnstorable(listKey))
         throw new PgUnstorableError("task-list listKey");
     assertListKeyBytes(listKey);
@@ -135,7 +136,8 @@ export async function deletePgTaskList(pool, listKey) {
     finally {
         c.release();
     }
-}
+}, "sql-task-list-pg.delete");
+const TASK_LIST_EXIT_PLAN = { get: "exit", set: "exit", delete: "exit", list: "exit", allocateId: "exit", mutate: "exit" };
 export function createTiDBTaskListStore(pool, listKey) {
     assertListKeyBytes(listKey);
     const tx = async (fn) => {
@@ -158,7 +160,7 @@ export function createTiDBTaskListStore(pool, listKey) {
         const [rows] = (await q.query(sql, params));
         return rows;
     };
-    const build = (q, inTx) => ({
+    const build = (q, inTx) => sealStoreObject({
         get: async (id) => {
             const [rows] = (await q.query(`SELECT ${jsonColumnText("mysql", "item_json")} FROM ${TASK_LIST_ITEM_TABLE} WHERE list_key = ? AND id = ?${inTx ? " FOR UPDATE" : ""}`, [listKey, id]));
             return rows.length > 0 ? parseItem(rows[0].item_json, `for list ${listKey} item ${JSON.stringify(id)}`) : undefined;
@@ -187,7 +189,7 @@ export function createTiDBTaskListStore(pool, listKey) {
                     return fn(build(c, true));
                 }),
             }),
-    });
+    }, inTx ? "sql-task-list-tidb-tx" : "sql-task-list-tidb", TASK_LIST_EXIT_PLAN);
     return build(pool, false);
 }
 export function createPgTaskListStore(pool, listKey) {
@@ -214,7 +216,7 @@ export function createPgTaskListStore(pool, listKey) {
         const res = await q.query(sql, params);
         return res.rows;
     };
-    const build = (q, inTx) => ({
+    const build = (q, inTx) => sealStoreObject({
         get: async (id) => {
             const { rows } = await q.query(`SELECT ${jsonColumnText("pg", "item_json")} FROM ${TASK_LIST_ITEM_TABLE} WHERE list_key = $1 AND id = $2${inTx ? " FOR UPDATE" : ""}`, [listKey, id]);
             return rows.length > 0 ? parseItem(rows[0].item_json, `for list ${listKey} item ${JSON.stringify(id)}`) : undefined;
@@ -250,7 +252,7 @@ export function createPgTaskListStore(pool, listKey) {
                     return fn(build(c, true));
                 }),
             }),
-    });
+    }, inTx ? "sql-task-list-pg-tx" : "sql-task-list-pg", TASK_LIST_EXIT_PLAN);
     return build(pool, false);
 }
 //# sourceMappingURL=task-list-store-sql.js.map

package/dist/plugins/tidb-cost-quota.js

@@ -1,5 +1,6 @@
 import { decideQuota } from "../observability/cost-quota.js";
 import { WriteBehindCounter } from "./write-behind-counter.js";
+import { sealStoreClass } from "./store-boundary.js";
 export class TiDBCostQuota {
     counter;
     limitMicroUsd;
@@ -50,4 +51,7 @@ export class TiDBCostQuota {
         this.counter.stop();
     }
 }
+sealStoreClass(TiDBCostQuota, "tidb-cost-quota", {
+    setLimits: "exit", check: "exit", add: "exit", flush: "exit", refresh: "exit", reap: "exit", startRefresh: "exit", stop: "exit",
+});
 //# sourceMappingURL=tidb-cost-quota.js.map

package/dist/plugins/tidb-pool.js

@@ -8,7 +8,7 @@ import { TIDB_PERMISSION_RULE_STATEMENTS } from "./permission-rule-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, SESSION_META_LINEAGE_COLUMNS } from "../session-incarnation.js";
-import { ensureSessionExtTableMysql } from "./session-ext-table.js";
+import { SESSION_EXT_INDEXES, ensureSessionExtTableMysql } from "./session-ext-table.js";
 import { CHECKPOINT_HOST_SESSION_COLUMN } from "./checkpoint-index-columns.js";
 import { RUN_IDENTITY_COLUMNS } from "../identity-source.js";
 import { SESSION_RULES_COLUMN } from "./session-rules-column.js";
@@ -843,6 +843,7 @@ export async function releaseEnsureSchemaLock(conn, tag = "ensureSchema") {
 export const SCHEMA_INDEXES = [
     ...CENTRAL_SCHEMA_INDEXES,
     ...SESSION_INDEXES,
+    ...SESSION_EXT_INDEXES,
     ...TOOL_RESULT_INDEXES,
     ...COST_QUOTA_INDEXES,
     ...RATE_LIMIT_INDEXES,

package/dist/plugins/tidb-rate-limiter.js

@@ -1,4 +1,5 @@
 import { WriteBehindCounter } from "./write-behind-counter.js";
+import { sealStoreClass } from "./store-boundary.js";
 export class TiDBRateLimiter {
     counter;
     limit;
@@ -48,4 +49,7 @@ export class TiDBRateLimiter {
         this.counter.stop();
     }
 }
+sealStoreClass(TiDBRateLimiter, "tidb-rate-limiter", {
+    setLimits: "exit", check: "exit", sweep: "exit", flush: "exit", refresh: "exit", startRefresh: "exit", stop: "exit",
+});
 //# sourceMappingURL=tidb-rate-limiter.js.map

package/dist/plugins/user-input-ledger-sql.js

@@ -2,6 +2,7 @@ import { recordFailOpen } from "../observability/fail-open.js";
 import { isDupKeyError } from "./sql-errors.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { assertPageLimit, CRASHED_CAUSE, SETTLE_HOW_WORDS, USER_INPUT_KIND_WORDS, USER_INPUT_OPEN_SCAN_MAX, USER_INPUT_SESSION_READ_MAX, } from "../user-input-ledger.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const USER_INPUT_ACCEPTANCE_TABLE = "user_input_acceptance";
 const COLUMNS = "accept_id, input_kind, message_id, session_id, task_id, writer, accepted_at_ms, state, state_at_ms, settle_how, announced_at_ms, announced_task_id";
 function rowState(r) {
@@ -116,6 +117,9 @@ export class SqlUserInputLedgerStore {
         return res.affected;
     }
 }
+sealStoreClass(SqlUserInputLedgerStore, "sql-user-input-ledger-store", {
+    accept: "exit", settle: "exit", converge: "exit", announce: "exit", listOpen: "exit", listCrashed: "exit", listUnannounced: "exit", deleteBySession: "exit",
+});
 export class TiDBUserInputLedgerStore extends SqlUserInputLedgerStore {
     constructor(pool) {
         super(mysqlDriver(pool));

package/dist/plugins/workflow-run-store-sql.d.ts

@@ -60,9 +60,9 @@ import { summarizeWorkflowRun, type CheckpointToken, type WorkflowRunStore } fro
 import { type WorkflowCompletionInbox, type WorkflowCompletionInboxEntry } from "../orchestration/workflow-completion-inbox.js";
 import type { WorkflowNotifyJournalStore, WorkflowNotifyJournalEntry } from "../orchestration/workflow-notify-journal.js";
 import { type WorkflowAgentSessionIndex, type WorkflowAgentSessionRow } from "../orchestration/workflow-agent-session-index.js";
-import { type WorkflowParkDecision, type WorkflowParkDecisionStore } from "../orchestration/workflow-park-decision.js";
+import { type HolderFenceVerdict, type RecordFenced, type WorkflowParkDecision, type WorkflowParkDecisionStore } from "../orchestration/workflow-park-decision.js";
 import type { SqlRunStore } from "./run-store-sql.js";
-import { type SqlDialect, type SqlDriver, type SqlExec } from "./sql-driver.js";
+import { type SqlDialect, type SqlDriver, type SqlExec, type SqlTxConn } from "./sql-driver.js";
 type WorkflowRun = Parameters<WorkflowRunStore["put"]>[1];
 /** Row cap guard: a run blob beyond this is NOT stored on update (the prior revision stays) — TiDB's
  *  ~6 MiB txn-entry limit would otherwise throw the (best-effort) progress write into the workflow loop.
@@ -126,6 +126,14 @@ export declare class SqlWorkflowRunStore implements WorkflowRunStore {
     private q;
     put(id: string, run: WorkflowRun): Promise<void>;
     get(id: string): Promise<WorkflowRun | null>;
+    /**
+     * **记录栅栏(SQL 形)**:一个事务 —— 锁读这条 run 的记录行且它读作 `running`(`workflow_run … FOR UPDATE`,行体经本店唯一列读者 {@link readRunColumn} 解、
+     * `rev` 列覆盖),读到 ⇒ `fn` 在**同一个事务连接**上跑(收锁住的那份记录);没读到(终态 / 不在)⇒ `fn` 不调、答 `{ running: false }`。提交即放锁;`fn` 抛或提交失败 ⇒ 整只抛。
+     * 引擎的记录写是同一行的 CAS `UPDATE`({@link update}),notify 门的收养翻转同一条 ⇒ 与本段在这一行锁上串行:本段先拿锁 ⇒ 段里落的写先于终态提交;
+     * 终态先提交 ⇒ 本段读不到 `running`。决定行的写就落在这里(契约属主 = `orchestration/workflow-park-decision.ts` 文件头)。
+     * 取锁序 = `workflow_run` → `workflow_park_decision`(段里只碰这两张表;认领栅栏那一形先锁 `task_run` / `task_active` 再碰 `workflow_park_decision`,两序不成环)。
+     */
+    whileRunning<T>(id: string, fn: (tx: SqlTxConn, run: WorkflowRun) => Promise<T>): Promise<RecordFenced<T>>;
     update(id: string, scope: string, run: WorkflowRun, expect?: {
         rev: number;
     }): Promise<boolean>;
@@ -212,24 +220,34 @@ export declare class SqlWorkflowAgentSessionIndex implements WorkflowAgentSessio
 /**
  * workflow 子代停驻卡的耐久决定行 —— SQL 双生(契约与律的唯一属主 =
  * {@link import("../orchestration/workflow-park-decision.js").WorkflowParkDecisionStore} 的文件头,这里只记方言差)。
- * 写者只有 `/decide` 的 workflow 车道(开跑之前那一笔);删除只有 run 收割的级联({@link SqlWorkflowRunStore.reap})。
- *
- * 构造时绑在 SQL run 店上(`claims`):写在那只 run 店的认领栅栏事务里(`SqlRunStore.whileHoldingClaim` 交出的那条事务连接 —— 栅栏攥着
- * run 行与认领行的锁直到提交),读走那只 run 店的池(`claims.db`)—— 决定行、认领、读写同一只池,池只有这一处来源。
+ * 写在两只栅栏之一的事务里:记录栅栏(`records`:{@link SqlWorkflowRunStore.whileRunning} 交出的那条事务连接 —— 栅栏攥着 `workflow_run` 行锁直到提交)
+ * 或认领栅栏(`claims`:`SqlRunStore.whileHoldingClaim` 交出的那条事务连接 —— 攥着 run 行与认领行的锁直到提交);读走 run 店的池(`claims.db`)。
+ * 两只栅栏、决定行、读写同一只池(后端交出的三只店同出一只池)。删除只有 run 收割的级联({@link SqlWorkflowRunStore.reap})。
  *
  * ── 方言差,保持显式 ──────────────────────────────────────────────────────────────────────────
  *   - `?` 占位 vs `$n`。
- *   - 整行 upsert(主键 `token`):TiDB `INSERT … ON DUPLICATE KEY UPDATE col = VALUES(col)` vs PG `INSERT … ON CONFLICT (token) DO UPDATE SET col = EXCLUDED.col`。
- *     无条件:序由认领栅栏定(同一宿主会话上的受理由认领串行,栅栏事务的提交序就是受理序),`accepted_at_ms` 只是记下的值。
+ *   - 认领栅栏下的整行 upsert(主键 `token`):TiDB `INSERT … ON DUPLICATE KEY UPDATE col = VALUES(col)` vs PG `INSERT … ON CONFLICT (token) DO UPDATE SET col = EXCLUDED.col`。
+ *     序由认领栅栏定,`accepted_at_ms` 只是记下的值。
+ *   - 记录栅栏下的「没有才插」(先受理者立):TiDB `INSERT … ON DUPLICATE KEY UPDATE token = token` vs PG `INSERT … ON CONFLICT (token) DO NOTHING`;
+ *     之后**锁定读**行上的指纹(`SELECT … FOR UPDATE`)判立没立 —— TiDB 悲观事务里的普通读走事务起点的快照,一只等锁等过对方提交的事务用普通读会读不到
+ *     对方刚落的行;锁定读读最新提交。PG READ COMMITTED 每句新快照,锁定读同样成立。收场转交的条件读同此(认领栅栏里锁定读指纹再写)。
  *   - `outcome` 是 JSON 承载的文本列(TiDB MEDIUMTEXT / PG TEXT,与 `workflow_run.run` 同形:两方言同一条 `JSON.stringify` 绑定),
  *     读腿按文本投影、恰好解一次({@link jsonColumnText} / {@link decodeJsonColumn})。
  *   - schema 属主同店内其余表:TiDB DDL 在 tidb-pool.ts,PG DDL 在 pg-pool.ts(店不建表)。
  */
 export declare class SqlWorkflowParkDecisionStore implements WorkflowParkDecisionStore {
     readonly claims: SqlRunStore;
-    constructor(claims: SqlRunStore);
+    readonly records: SqlWorkflowRunStore;
+    constructor(claims: SqlRunStore, records: SqlWorkflowRunStore);
     private q;
-    record(d: WorkflowParkDecision): Promise<boolean>;
+    /** 事务里锁定读这张卡行上的指纹(没有行 ⇒ `undefined`)。 */
+    private lockedFingerprint;
+    record(d: WorkflowParkDecision, condition?: {
+        readonly expect: string;
+    }): Promise<boolean>;
+    recordForRunningHolder(d: WorkflowParkDecision, request: {
+        readonly restated: boolean;
+    }): Promise<HolderFenceVerdict>;
     get(token: CheckpointToken): Promise<WorkflowParkDecision | null>;
     listByHostSession(hostSessionId: string): Promise<WorkflowParkDecision[]>;
 }

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

@@ -2,10 +2,12 @@ import { redactErrorMessage, redactHead } from "../observability/run-terminal.js
 import { summarizeWorkflowRun, isTerminalWorkflowStatus, WorkflowRunStoreError } from "@sema-agent/core";
 import { foldKeyFamily, MAX_PENDING_PER_SESSION, PURGE_FENCE_MS, SERVED_FENCE_MS, } from "../orchestration/workflow-completion-inbox.js";
 import {} from "../orchestration/workflow-agent-session-index.js";
-import { readWorkflowParkOutcome } from "../orchestration/workflow-park-decision.js";
+import { holderFenceAdmits, readWorkflowParkOutcome } from "../orchestration/workflow-park-decision.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { createObjectColumnReader, decodeJsonColumn, foldJsonColumn, jsonColumnText } from "./sql-json-column.js";
 import { isDupKeyError } from "./sql-errors.js";
+import { storeBoundaryFault } from "../terminal.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const MAX_RUN_BLOB_BYTES = 4 * 1024 * 1024;
 const SLIM_HEADER_MAX = 200;
 const onWarnType = (msg, meta) => void [msg, meta];
@@ -81,6 +83,37 @@ export class SqlWorkflowRunStore {
         run.rev = Number(r.rev);
         return run;
     }
+    async whileRunning(id, fn) {
+        const conn = await this.db.connect();
+        try {
+            await conn.begin();
+            try {
+                const { rows } = await conn.query(this.q(`SELECT ${jsonColumnText("mysql", "run")}, rev FROM workflow_run WHERE id = ? AND status = 'running' FOR UPDATE`, `SELECT ${jsonColumnText("pg", "run")}, rev FROM workflow_run WHERE id = $1 AND status = 'running' FOR UPDATE`), [id]);
+                const r = rows[0];
+                let fenced = { running: false };
+                if (r !== undefined) {
+                    const run = readRunColumn(r.run, id);
+                    run.rev = Number(r.rev);
+                    fenced = { running: true, value: await fn(conn, run) };
+                }
+                await conn.commit();
+                return fenced;
+            }
+            catch (err) {
+                try {
+                    await conn.rollback();
+                }
+                catch (rollbackErr) {
+                    const rollbackFault = storeBoundaryFault(rollbackErr, "sql-workflow-run-store.whileRunning");
+                    throw new Error(`workflow record fence on ${id}: the segment failed and its rollback failed too (${rollbackFault instanceof Error ? rollbackFault.message : String(rollbackFault)})`, { cause: err });
+                }
+                throw err;
+            }
+        }
+        finally {
+            conn.release();
+        }
+    }
     async update(id, scope, run, expect) {
         run = withRedactedError(run);
         let blob = JSON.stringify({ ...run, id, scope });
@@ -166,6 +199,7 @@ export class SqlWorkflowRunStore {
         return res.affected;
     }
 }
+sealStoreClass(SqlWorkflowRunStore, "sql-workflow-run-store", { put: "exit", get: "exit", update: "exit", whileRunning: "exit", listByScope: "exit", reapAllScopes: "exit", reap: "exit" });
 const KIND_SERVED = "served";
 const KIND_PURGE = "purge";
 export async function writeInboxPurgeFenceOn(exec, dialect, sessionId, purgedOwner, now) {
@@ -264,6 +298,7 @@ export class SqlWorkflowCompletionInbox {
         await this.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ? AND run_id <> ? AND REGEXP_REPLACE(run_id, '#[0-9]+$', '') = ?", "DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND run_id <> $2 AND regexp_replace(run_id, '#[0-9]+$', '') = $3"), [sessionId, runId, runId]);
     }
 }
+sealStoreClass(SqlWorkflowCompletionInbox, "sql-workflow-completion-inbox", { enqueue: "exit", pending: "exit", ack: "exit", purge: "exit", markTerminalServed: "exit" });
 export class SqlWorkflowNotifyJournalStore {
     db;
     constructor(db) {
@@ -309,6 +344,7 @@ export class SqlWorkflowNotifyJournalStore {
         };
     }
 }
+sealStoreClass(SqlWorkflowNotifyJournalStore, "sql-workflow-notify-journal-store", { record: "exit", ack: "exit", listPending: "exit", reapAcked: "exit", get: "exit" });
 export class SqlWorkflowAgentSessionIndex {
     db;
     constructor(db) {
@@ -328,6 +364,7 @@ export class SqlWorkflowAgentSessionIndex {
         return rows.map((r) => ({ sessionId: String(r.session_id), runId: String(r.run_id), agentKey: String(r.agent_key), scope: String(r.scope) }));
     }
 }
+sealStoreClass(SqlWorkflowAgentSessionIndex, "sql-workflow-agent-session-index", { ensurePointers: "exit", listByAgentSession: "exit" });
 function readParkDecisionOutcomeColumn(v, where) {
     try {
         return decodeJsonColumn(v, readWorkflowParkOutcome, `workflow_park_decision.outcome ${where}`);
@@ -338,19 +375,41 @@ function readParkDecisionOutcomeColumn(v, where) {
 }
 export class SqlWorkflowParkDecisionStore {
     claims;
-    constructor(claims) {
+    records;
+    constructor(claims, records) {
         this.claims = claims;
+        this.records = records;
     }
     q(mysql, pg) {
         return this.claims.db.dialect === "mysql" ? mysql : pg;
     }
-    async record(d) {
+    async lockedFingerprint(tx, token) {
+        const { rows } = await tx.query(this.q("SELECT fingerprint FROM workflow_park_decision WHERE token = ? FOR UPDATE", "SELECT fingerprint FROM workflow_park_decision WHERE token = $1 FOR UPDATE"), [token]);
+        const r = rows[0];
+        return r === undefined ? undefined : String(r.fingerprint);
+    }
+    async record(d, condition) {
         const fenced = await this.claims.whileHoldingClaim(d.hostSessionId, d.deliveredTaskId, async (tx) => {
+            if (condition !== undefined && (await this.lockedFingerprint(tx, d.token)) !== condition.expect)
+                return false;
             await tx.query(this.q(`INSERT INTO workflow_park_decision (token, run_id, host_session_id, outcome, fingerprint, delivered_task_id, accepted_at_ms) VALUES (?,?,?,?,?,?,?)
              ON DUPLICATE KEY UPDATE ${PARK_DECISION_REPLACED_COLUMNS.map((c) => `${c} = VALUES(${c})`).join(", ")}`, `INSERT INTO workflow_park_decision (token, run_id, host_session_id, outcome, fingerprint, delivered_task_id, accepted_at_ms) VALUES ($1,$2,$3,$4,$5,$6,$7)
              ON CONFLICT (token) DO UPDATE SET ${PARK_DECISION_REPLACED_COLUMNS.map((c) => `${c} = EXCLUDED.${c}`).join(", ")}`), [d.token, d.runId, d.hostSessionId, JSON.stringify(d.outcome), d.fingerprint, d.deliveredTaskId, d.acceptedAtMs]);
+            return true;
+        });
+        return fenced.held && fenced.value;
+    }
+    async recordForRunningHolder(d, request) {
+        const fenced = await this.records.whileRunning(d.runId, async (tx, run) => {
+            const admits = holderFenceAdmits(run, d, request.restated);
+            if (admits !== "land")
+                return admits;
+            await tx.query(this.q(`INSERT INTO workflow_park_decision (token, run_id, host_session_id, outcome, fingerprint, delivered_task_id, accepted_at_ms) VALUES (?,?,?,?,?,?,?)
+             ON DUPLICATE KEY UPDATE token = token`, `INSERT INTO workflow_park_decision (token, run_id, host_session_id, outcome, fingerprint, delivered_task_id, accepted_at_ms) VALUES ($1,$2,$3,$4,$5,$6,$7)
+             ON CONFLICT (token) DO NOTHING`), [d.token, d.runId, d.hostSessionId, JSON.stringify(d.outcome), d.fingerprint, d.deliveredTaskId, d.acceptedAtMs]);
+            return (await this.lockedFingerprint(tx, d.token)) === d.fingerprint ? "stands" : "other_decision";
         });
-        return fenced.held;
+        return fenced.running ? fenced.value : "not_running";
     }
     async get(token) {
         const { rows } = await this.claims.db.query(this.q(`SELECT token, run_id, host_session_id, ${jsonColumnText("mysql", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE token = ?`, `SELECT token, run_id, host_session_id, ${jsonColumnText("pg", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE token = $1`), [token]);
@@ -362,6 +421,7 @@ export class SqlWorkflowParkDecisionStore {
         return rows.map(rowToParkDecision);
     }
 }
+sealStoreClass(SqlWorkflowParkDecisionStore, "sql-workflow-park-decision-store", { record: "exit", recordForRunningHolder: "exit", get: "exit", listByHostSession: "exit" });
 const PARK_DECISION_REPLACED_COLUMNS = ["run_id", "host_session_id", "outcome", "fingerprint", "delivered_task_id", "accepted_at_ms"];
 function rowToParkDecision(r) {
     const token = String(r.token);

package/dist/plugins/workspace-fill.d.ts

@@ -1,4 +1,5 @@
-import { RemoteExecutionError, type ExecutionEnvFactoryContext } from "@sema-agent/core";
+import { type ExecutionEnvFactoryContext } from "@sema-agent/core";
+import { type ConnectRefusal } from "./remote-env-connect-seat.js";
 import type { Logger } from "../observability/logger.js";
 import { type TaskAttachmentStore } from "./task-attachment-store.js";
 /** 车道一次固定命令的读数(适配器自己的起动身份 —— 与引擎命令同一个执行用户;从不抛)。 */
@@ -29,14 +30,10 @@ export interface WorkspaceChannel {
 }
 /** 恢复点交出的工作区从哪来:`minted` = 车道刚铸出的新工作区(没有可恢复的树 —— 含恢复点指的归档不在:`latest` 悬空、停驻快照的归档不在);`restored` = 恢复出来的(空间 `latest` / 停驻快照的树真回来了)。 */
 export type WorkspaceOrigin = "minted" | "restored";
-/** 一次填充的结局。`standing` = 这只执行环境此后每一次恢复点都会得到同一个答(适配器把它记成这只环境的拒,不再建机器)。 */
+/** 一次填充的结局。拒的那一臂是一只建连的拒:`standing` = 这只执行环境此后每一次恢复点都会得到同一个答(适配器的建连座记住它,不再建机器)。 */
 export type FillOutcome = {
     readonly ok: true;
-} | {
-    readonly ok: false;
-    readonly error: RemoteExecutionError;
-    readonly standing: boolean;
-};
+} | ConnectRefusal;
 /** 恢复点的填充座(按 run 由工厂装配交给适配器;适配器只在恢复点调它、只说工作区从哪来,不判内容)。 */
 export interface WorkspaceFill {
     /** 往恢复点即将交出的工作区(根 = `root`,适配器的工作根;来处 = `origin`)里放内容。 */

package/dist/plugins/workspace-fill.js

@@ -1,12 +1,13 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { RemoteExecutionError } from "@sema-agent/core";
+import { connectRefusal } from "./remote-env-connect-seat.js";
 import { readProjectBundle } from "../project-bundle.js";
 import { attachmentBytesOf, attachmentPlacementsOf, seedOfSession } from "./task-attachment-store.js";
 import { shellQuote } from "./remote-shell.js";
 const FILLED = { ok: true };
 function refused(message, standing = false) {
-    return { ok: false, error: new RemoteExecutionError("connect_failed", message), standing };
+    return standing ? connectRefusal("workspace_fill_refused", message) : { ok: false, error: new RemoteExecutionError("connect_failed", message), standing: false };
 }
 function errText(e) {
     return e instanceof Error ? e.message : String(e);

package/dist/plugins/write-behind-counter.js

@@ -1,4 +1,5 @@
 import { alignedWindow, retryAfterSecUntil } from "../observability/cost-quota.js";
+import { sealStoreClass } from "./store-boundary.js";
 const SEP = "\u0000";
 export const DEFAULT_COUNTER_QUERY_TIMEOUT_MS = 30_000;
 export class SqlWriteBehindCounter {
@@ -173,6 +174,10 @@ export class SqlWriteBehindCounter {
         this.windowMs = windowMs;
     }
 }
+sealStoreClass(SqlWriteBehindCounter, "sql-write-behind-counter", {
+    window: "exit", bucket: "exit", usedIn: "exit", used: "exit", addLocal: "exit", retryAfterSec: "exit", flush: "exit", refresh: "exit", reap: "exit",
+    startRefresh: "exit", stop: "exit", refreshRunning: "exit", setWindowMs: "exit",
+});
 export class WriteBehindCounter extends SqlWriteBehindCounter {
     constructor(pool, t, windowMs, now, onDegraded, queryTimeoutMs) {
         super("mysql", pool, t, windowMs, now, onDegraded, queryTimeoutMs);

package/dist/project-context.d.ts

@@ -37,8 +37,6 @@ export interface ProjectContextDecision {
     readonly context: ProjectContext | undefined;
     readonly withheldPathItems: number;
 }
-/** 一只登记对这位观者可见吗(读面与继承同调的唯一判):全舰队视域看全部;否则只看 `registeredBy` 恰是自己的。看不见与不存在同答。 */
-export declare function projectVisible(registration: Pick<ProjectRegistration, "registeredBy">, viewer: ListFilter): boolean;
 /**
  * 项目简报的唯一铸点(纯串;各段缺席不出,全缺席 ⇒ 无简报)。只读 {@link PROJECT_BRIEF_FIELDS};路径两段只在 `pathsHonored` 时出,且只列名字 ——
  * `file` 条目未附上,段名写明「相关时去读」。首行点名来源与项目 id(不带 `displayName`:身份字段不进提示)。

package/dist/project-context.js

@@ -1,11 +1,9 @@
 import { PROJECT_ID_REGEX } from "@sema-agent/core";
 import { isAbsoluteHostPath } from "@sema-agent/settings-schema";
+import { visibleProjectOf } from "./project-registry.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS } from "./task-settings.js";
 export const PROJECT_BRIEF_FIELDS = ["goal", "notes", "contextItems"];
 export const PROJECT_CONTENT_ATTESTATION_FIELD = "contentAttestedAt";
-export function projectVisible(registration, viewer) {
-    return viewer.fleetWide || registration.registeredBy === viewer.gateOwner;
-}
 export function buildProjectBrief(projectId, registration, pathsHonored) {
     const sections = [];
     if (registration.goal !== undefined && registration.goal.length > 0)
@@ -29,11 +27,9 @@ export function buildProjectBrief(projectId, registration, pathsHonored) {
     return [`# Project context (from this deployment's project registry; project ${projectId})`, ...sections].join("\n\n");
 }
 export function projectContextOf(input) {
-    const { projectId, registry, viewer } = input;
-    if (projectId === undefined || registry === undefined || viewer === undefined)
-        return { context: undefined, withheldPathItems: 0 };
-    const registration = Object.hasOwn(registry, projectId) ? registry[projectId] : undefined;
-    if (registration === undefined || !projectVisible(registration, viewer))
+    const { projectId } = input;
+    const registration = visibleProjectOf(input.registry, projectId, input.viewer);
+    if (projectId === undefined || registration === undefined)
         return { context: undefined, withheldPathItems: 0 };
     if (registration[PROJECT_CONTENT_ATTESTATION_FIELD] === undefined)
         return { context: undefined, withheldPathItems: 0 };