@sema-agent/server 7.149.0 → 7.151.0

package/dist/plugins/stop-then-start.d.ts

@@ -0,0 +1,109 @@
+/**
+ * **停-迁-起**(SQL 两方言;常设,不带窗)—— 一次性迁移登记表里每一条停-迁-起行的声明型、它唯一的判官、守卫段与证据读法。
+ *
+ * ## 它回答哪一问(只这一问)
+ * 「一只**已在服务**、不认迁移 M 的副本,在 M 之后写下的那一笔不兼容写,由谁挡?」—— 答案是一格闭集 {@link StopThenStartFence}(围栏类):
+ *  · `structural` —— 库挡:M 的第一笔改动是 DDL(就地改名 / 删退役列 / 按建表语句重建),更早副本点名旧对象的每一句不兼容写当场失败(先围后搬);
+ *  · `per-write` —— 写句挡:从 `fencedSince` 起的构建,点名的那几句写在同一句 / 同一事务里读起服要求行;`fencedSince` 严格早于 M 的引入版
+ *    (逐写围栏只对带这段代码的构建生效,所以必须早至少一版装入);
+ *  · `accepted` —— 没有人挡:`residual` 一句写明残余(MIGRATION 原样引),停光旧副本是唯一的补偿。
+ * 类取「从第一笔不兼容写起就成立」的那一种:晚于任何一笔搬运的 DDL 围栏不使本条成 `structural`;`per-write` 与 `structural` 同时成立 ⇒ 取 `structural`。
+ * **围栏类没有起服期的分臂**:三类在起服时同一只序 —— 守卫段读证据(有 ⇒ 拒)、各条在自己的第一笔不兼容写之前记一行起服要求(`serving-requirement.ts`)。
+ * 类只决定放行判据({@link judgeStopThenStart})、残余的披露与作者该选哪一形。
+ *
+ * ## 一份声明、一只判官
+ * 登记表(`one-time-migrations.ts` 的 `ONE_TIME_MIGRATIONS`)每一行**显式**写 `stopThenStart: StopThenStartRow | null`(缺键 = tsc 红,形门再红一次);
+ * `null` 只说「本条不声明停-迁-起」(不拒启、不进升级清单的停-迁-起一步),**不是**混跑安全的证明。判官只答「这份声明合不合本类的放行判据」;
+ * 读者两处:形门(全表,非空 ⇒ 红)与起服({@link assertStopThenStartDeclarations}:SQL 一次性迁移段**取连接之前**判本构建的每一条停-迁-起行,非空 ⇒ 抛构建缺陷,一句库语句都没发)。
+ *
+ * ## 守卫段在一切写之前
+ * {@link guardOwedStopThenStart} 在 SQL 一次性迁移段的锁内、准入复核之后、第一步迁移之前跑(`runSqlOneTimeMigrations`):按登记序逐条问「这只库还欠不欠」,
+ * 欠的读证据,任一有证据 ⇒ 抛那一条自己的拒(码与句是那一条的)—— 迁移段一字节没写,各拒句里的「Nothing was changed」由构造成立。迁移步里不再读证据。
+ *
+ * ## 证据读法(常设)
+ * {@link readOlderReplicaEvidence}:判活窗内心跳过的 `running` run(谓词 = run 店的 `runningHeartbeatPredicate` 的 `live` 一侧,与死亡判决同一只构造、同一个窗),
+ * 按持有者分组,减去登记为知道 M 的持有者(`replica-registration.ts`)。早于副本登记的副本不登记,只经它们持有的 run 心跳可见;没登记的持有者照算(保守)——
+ * 回滚到早于副本登记的构建、跳过公开序列的嵌入方、登记行过了留存视界的长寿进程会一直可能存在,所以这一读法不是过渡、没有删除日期。
+ * 它是观察谓词,不是存活证明:空闲的(零 `running` run)副本看不见;刚停的副本留下的 run 在窗内仍算(拒句给「全停之后何时再起」)。
+ * 「库上的副本够不够新」(服务下限)就是这一读法读空,不另立读口、不加版本常量。
+ *
+ * local 车道:数据根独占(起服锁只许一个进程)⇒ 没有混跑窗,守卫段与证据读法只在 SQL 腿。
+ */
+import type { StoreBootRefusalError } from "./store-contracts.js";
+import type { SchemaProbeRead } from "./schema-live-columns.js";
+import type { SqlDialect } from "./sql-driver.js";
+import type { PendingShapeChange } from "./schema-consistency.js";
+import type { OlderReplicaEvidence } from "./stop-then-start-sentence.js";
+import { type ReplicaCapability } from "./replica-registration.js";
+/** 已在服务、不认本条的副本在本条之后那一笔不兼容写由谁挡(闭集;停-迁-起行必填)。 */
+export type StopThenStartFence = 
+/** 库挡:`fencedBy` 是本行 `shapeChanges` 里的一项(`rename` / `drop` / `rebuild`,不许 `add`),且是本条的第一笔改动。 */
+{
+    readonly kind: "structural";
+    readonly fencedBy: PendingShapeChange;
+}
+/** 写句挡:从 `fencedSince`(x.y.z,严格早于本行 `introducedIn`)起的构建,`statements` 点名的那几句写读起服要求行,`(本条, in_force)` 在 ⇒ 不写、响亮。 */
+ | {
+    readonly kind: "per-write";
+    readonly fencedSince: string;
+    readonly statements: string;
+}
+/** 没人挡:`residual` 一句写明残余(MIGRATION 原样引);停光旧副本是唯一的补偿。 */
+ | {
+    readonly kind: "accepted";
+    readonly residual: string;
+};
+/**
+ * 一条停-迁-起迁移的登记格(登记表里只写引用,判据与拒句的码在本条的迁移步旁边):
+ *  · `reason` —— 一句英文:更早版本的副本在迁移之后还会写什么、写了会怎样(= 为什么不能两版滚动;升级清单原样列给运维);
+ *  · `owedOn` —— **这只库还欠不欠本条**的唯一读法(只读、无参语句):守卫段先问它(不欠 ⇒ 不读证据),升级清单的停-迁-起一步只列它答「欠」的行;
+ *  · `refuse` —— 有证据时本条的拒(本条自己的码与句;`read` = 锁连接上的无参读口,拒句尾的库况 / 本条的计数从它读);守卫段调它,迁移步里不再读证据;
+ *  · `fence` —— 围栏类({@link StopThenStartFence})。
+ */
+export interface StopThenStartRow {
+    readonly reason: string;
+    readonly owedOn: (read: SchemaProbeRead, dialect: SqlDialect) => Promise<boolean>;
+    readonly refuse: (evidence: OlderReplicaEvidence, read: SchemaProbeRead, dialect: SqlDialect) => Promise<StoreBootRefusalError>;
+    readonly fence: StopThenStartFence;
+}
+/** 一条停-迁-起行连同判官要读的两格(登记表行的 `id` / `introducedIn` / `shapeChanges`;一次性迁移文件的 `stopThenStartMigrations()` 交出这一形)。 */
+export interface StopThenStartEntry extends StopThenStartRow {
+    readonly id: string;
+    readonly introducedIn: string;
+    readonly shapeChanges?: readonly PendingShapeChange[];
+}
+/** 停-迁-起证据读法的判活窗输入:= 本部署的 `REAP_RUN_STALE_SEC`(收割器判「这条 run 的持有者还活着」用的同一个窗)。 */
+export interface LiveRunWindowInput {
+    readonly liveRunWindowMs: number;
+}
+/** 证据读法要的读口(一次性迁移段的锁连接;只读)。 */
+export interface EvidenceDb {
+    rows(sql: string, params?: readonly unknown[]): Promise<Record<string, unknown>[]>;
+}
+/**
+ * **唯一判官**:这份停-迁-起声明自相矛盾的清单(空 = 放行)。三类各自的放行判据(穷尽 `switch`,加第四类不处理 = tsc 红),外加三类共同的两条
+ * (名在能力名单里 —— 守卫读证据 ⇔ 名在名单里;缘由句不空)。纯函数。
+ */
+export declare function judgeStopThenStart(entry: StopThenStartEntry): readonly string[];
+/**
+ * **停-迁-起证据的唯一读法**(守卫段与 M43 的启用判同读;拒句与读数的句子属主 = `stop-then-start-sentence.ts`):判活窗内心跳过的 `running` run
+ * (run 店的 {@link runningHeartbeatPredicate} `live` 一侧 —— 收割器判活的同一只构造、同一个窗),按持有者(`task_run.instance_id`,建行铸、认领接管)分组,
+ * **减去登记为知道 `migrationId` 的持有者**(`knowsCapability`,与起服准入同一只判据)—— 剩下的 run 就是证据:持有者没有登记行(早于副本登记的副本、`NULL` 身份、
+ * 自传身份的嵌入方)或登记了而能力名单里没有这条迁移,照算(保守)。登记一半只作归因(点名持有者),**不判活**。
+ * 本进程此刻还在迁移段里、一条 run 都没起过 ⇒ 证据里只有别的进程。`task_run` 不在 ⇒ `undefined`。
+ * `migrationId` 在型上就要在能力名单里(`ReplicaCapability`):一条迁移读证据 ⇔ 它的名在名单里。
+ */
+export declare function readOlderReplicaEvidence(db: EvidenceDb, dialect: SqlDialect, input: LiveRunWindowInput, migrationId: ReplicaCapability): Promise<OlderReplicaEvidence | undefined>;
+/**
+ * 起服时的判官读者:本构建的每一条停-迁-起声明过 {@link judgeStopThenStart},任一条自相矛盾 ⇒ 抛(构建缺陷)。纯函数;唯一调用点 = SQL 一次性迁移段的入口
+ * (`runSqlOneTimeMigrations`),**在取连接之前** —— 抛出时这一次起服对库一句语句都没发(段头的登记、准入、取锁都还没开始)。
+ */
+export declare function assertStopThenStartDeclarations(entries: readonly StopThenStartEntry[]): void;
+/**
+ * **守卫段**(一次性迁移段的锁内、准入复核之后、第一步迁移之前;锁连接上;`entries` 已由调用方在取连接之前过了 {@link assertStopThenStartDeclarations}):
+ * 按登记序逐条 —— 不欠 ⇒ 跳过(不读证据);欠 ⇒ 读证据,有 ⇒ 抛那一条自己的拒({@link StopThenStartRow.refuse})。拒 ⇒ 迁移段一字节没写。
+ * 放行之后,各条在它**自己的**第一笔不兼容写之前记一行起服要求(`serving-requirement.ts` 的 `recordServingRequirement`;三类同记)—— 不在这里记:
+ * 本条若在本次起服里不欠,就没有那一笔写,也就不记。
+ */
+export declare function guardOwedStopThenStart(db: EvidenceDb, dialect: SqlDialect, input: LiveRunWindowInput, entries: readonly StopThenStartEntry[]): Promise<void>;
+//# sourceMappingURL=stop-then-start.d.ts.map

package/dist/plugins/stop-then-start.js

@@ -0,0 +1,104 @@
+import { REPLICA_CAPABILITIES, knowsCapability, readReplicaRegistrations } from "./replica-registration.js";
+import { compareReleaseTriples, releaseTriple } from "./release-version.js";
+import { runningHeartbeatPredicate } from "./run-store-sql.js";
+const isCapability = (id) => REPLICA_CAPABILITIES.includes(id);
+const sameChange = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export function judgeStopThenStart(entry) {
+    const faults = [];
+    if (!isCapability(entry.id))
+        faults.push(`${entry.id} is not in REPLICA_CAPABILITIES (a stop-then-start migration reads evidence only under a capability name)`);
+    if (entry.reason.trim() === "")
+        faults.push(`${entry.id}: reason is empty`);
+    const fence = entry.fence;
+    switch (fence.kind) {
+        case "structural":
+            if (!(entry.shapeChanges ?? []).some((c) => sameChange(c, fence.fencedBy)))
+                faults.push(`${entry.id}: structural fencedBy is not one of the row's shapeChanges`);
+            if (fence.fencedBy.kind === "add")
+                faults.push(`${entry.id}: structural fencedBy is an "add" (adding a column fences no earlier writer)`);
+            break;
+        case "per-write": {
+            const since = releaseTriple(fence.fencedSince);
+            const introduced = releaseTriple(entry.introducedIn);
+            if (since === undefined)
+                faults.push(`${entry.id}: per-write fencedSince "${fence.fencedSince}" is not x.y.z`);
+            if (introduced === undefined)
+                faults.push(`${entry.id}: introducedIn "${entry.introducedIn}" is not x.y.z`);
+            if (since !== undefined && introduced !== undefined && compareReleaseTriples(since, introduced) >= 0) {
+                faults.push(`${entry.id}: per-write fencedSince ${fence.fencedSince} is not earlier than introducedIn ${entry.introducedIn} (the fencing writes must ship at least one release before the migration)`);
+            }
+            if (fence.statements.trim() === "")
+                faults.push(`${entry.id}: per-write statements is empty`);
+            break;
+        }
+        case "accepted":
+            if (fence.residual.trim() === "")
+                faults.push(`${entry.id}: accepted residual is empty`);
+            break;
+        default: {
+            const unhandled = fence;
+            faults.push(`${entry.id}: unknown fence kind ${String(unhandled.kind)}`);
+        }
+    }
+    return faults;
+}
+export async function readOlderReplicaEvidence(db, dialect, input, migrationId) {
+    const scope = dialect === "mysql" ? "DATABASE()" : "current_schema()";
+    if ((await db.rows(`SELECT 1 AS present FROM information_schema.tables WHERE table_schema = ${scope} AND table_name = 'task_run'`)).length === 0)
+        return undefined;
+    const live = runningHeartbeatPredicate(dialect, "live", { nowMs: Date.now(), windowMs: input.liveRunWindowMs }, 1);
+    const groups = (await db.rows(`SELECT instance_id, COUNT(*) AS n, MAX(updated_at) AS newest FROM task_run WHERE ${live.sql} GROUP BY instance_id`, [live.param]))
+        .map((r) => ({ holder: typeof r["instance_id"] === "string" ? r["instance_id"] : undefined, runs: Number(r["n"] ?? 0), newest: r["newest"] }))
+        .filter((g) => g.runs > 0);
+    if (groups.length === 0)
+        return undefined;
+    const registered = await readReplicaRegistrations({ query: async (sql, params) => ({ rows: await db.rows(sql, params), affected: 0 }) }, dialect, groups.flatMap((g) => (g.holder === undefined ? [] : [g.holder])));
+    let unregisteredRuns = 0;
+    let newestMs = Number.NaN;
+    const registeredWithout = [];
+    for (const g of groups) {
+        const r = g.holder === undefined ? undefined : registered.get(g.holder);
+        if (r !== undefined && knowsCapability(r.capabilities, migrationId))
+            continue;
+        if (r === undefined)
+            unregisteredRuns += g.runs;
+        else
+            registeredWithout.push({ instanceId: r.instanceId, releaseLine: r.releaseLine, hostName: r.hostName, pid: r.pid, runs: g.runs });
+        const cell = g.newest instanceof Date ? g.newest : new Date(String(g.newest));
+        if (!Number.isNaN(cell.getTime()) && !(cell.getTime() <= newestMs))
+            newestMs = cell.getTime();
+    }
+    const liveRuns = unregisteredRuns + registeredWithout.reduce((n, h) => n + h.runs, 0);
+    if (liveRuns === 0)
+        return undefined;
+    const now = Date.now();
+    const restartAtMs = (Number.isNaN(newestMs) ? now : newestMs) + input.liveRunWindowMs;
+    return {
+        migration: migrationId,
+        liveRuns,
+        windowSec: Math.round(input.liveRunWindowMs / 1000),
+        restartAfter: new Date(restartAtMs).toISOString(),
+        after: `${new Date(restartAtMs).toISOString()} (${Math.max(0, Math.ceil((restartAtMs - now) / 1000))}s from now)`,
+        unregisteredRuns,
+        registeredWithout: registeredWithout.sort((a, b) => a.instanceId.localeCompare(b.instanceId)),
+    };
+}
+export function assertStopThenStartDeclarations(entries) {
+    const faults = entries.flatMap((e) => judgeStopThenStart(e));
+    if (faults.length > 0) {
+        throw new Error(`stop-then-start: this build declares a stop-then-start migration that contradicts its fence class (a build defect; refused before any statement reached the database): ${faults.join("; ")}`);
+    }
+}
+export async function guardOwedStopThenStart(db, dialect, input, entries) {
+    const read = (sql) => db.rows(sql);
+    for (const entry of entries) {
+        if (!(await entry.owedOn(read, dialect)))
+            continue;
+        if (!isCapability(entry.id))
+            throw new Error(`stop-then-start: ${entry.id} is not in REPLICA_CAPABILITIES`);
+        const evidence = await readOlderReplicaEvidence(db, dialect, input, entry.id);
+        if (evidence !== undefined)
+            throw await entry.refuse(evidence, read, dialect);
+    }
+}
+//# sourceMappingURL=stop-then-start.js.map

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

@@ -3,12 +3,14 @@ import type { Pool as PgPool } from "pg";
 import type { SessionStore, SessionPolicyStore, FileHistoryStore, FileHistoryBlobExchange, FileHistoryError, WorkflowJournalStore, ToolResultStore, SessionCaptureRecordStore, UsageWindowStore } from "@sema-agent/core";
 import { FileStorageBackend } from "@sema-agent/core";
 import { type OutcomeSink } from "./file-outcome-sink.js";
-import { type InboxWarn } from "./workflow-run-store-sql.js";
+import { SqlWorkflowRunStore, type InboxWarn } from "./workflow-run-store-sql.js";
 import { FileRunStore } from "./file-run-store.js";
+import { type WorkflowParkDecisionStore, type WorkflowRecordFenceStore } from "../orchestration/workflow-park-decision.js";
 import { type RunStallWiring } from "./store-contracts.js";
 import { type StoreOpenLane } from "./store-open-refusal.js";
 import { type OneTimeMigrationReport, type SqlOneTimeMigrationInput } from "./one-time-migrations.js";
 import { LocalSessionStore } from "./local-session-store.js";
+import { type LocalWorkflowRunsReader } from "./local-session-live-reference.js";
 import { type LocalStoreDeclaration } from "../local-store-declaration.js";
 import type { LocalSessionRows } from "./local-session-window.js";
 import type { SessionHeadReader } from "./caching-session-store.js";
@@ -22,7 +24,9 @@ import { type MemoryOptOutGrantStore } from "./memory-optout-grant-store-sql.js"
 import { type SendFileLedger } from "./send-file-ledger.js";
 import type { UserInputLedgerStore } from "../user-input-ledger.js";
 import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
-import { type SessionPolicyStoreLogger } from "../stores-sql/session-policy-store-sql.js";
+import { SqlSessionPolicyStore } from "../stores-sql/session-policy-store-sql.js";
+import { SqlFileHistoryStore } from "../stores-sql/file-history-store-sql.js";
+import { type LandedAttendantSeat } from "./landed-attendants.js";
 import type { ServiceConfig } from "../config-types.js";
 import { TiDBRunStore, PgRunStore } from "./run-store-sql.js";
 import { TiDBCheckpointStore, PgCheckpointStore } from "../stores-sql/checkpoint-store-sql.js";
@@ -66,7 +70,9 @@ export type RunStore = TiDBRunStore | PgRunStore | FileRunStore;
 /** E18 resume-at eventId→entryId anchor map — tidb/pg/local 3-backend (works LOCAL; needs only the session tree +
  *  this map, no cloud-only checkpoint). Union = the three nominal twins; consumers use put/resolve/deleteBySession.
  *  FileResumeAnchorStore is the FILE-backed local twin (P0.5 variant-1; survives restart). */
-export type ResumeAnchorStore = TiDBResumeAnchorStore | PgResumeAnchorStore | FileResumeAnchorStore;
+/** 回退锚店的部署面:读(`resolve` / `listBySession`)与按会话删 —— **没有写**。锚的生产写口只有落定席位的 `putAnchors`
+ *  ({@link StoreBackend.landedAttendants}:段首锁会话根行判住客,迟到的写落不进别一代住客或空闲 id);店类上的 `put` 是夹具与契约面的同一句语句。 */
+export type ResumeAnchorStore = Pick<TiDBResumeAnchorStore | PgResumeAnchorStore | FileResumeAnchorStore, "resolve" | "listBySession" | "deleteBySession">;
 export type { ApprovalExemptionStore } from "./approval-exemption-store.js";
 /** 会话树根的写(事务内钩的写闭集,`stores-sql/session-write-hooks.ts`):本组合座转口给目录外的判官(`execution-placement.ts` 的 `judgeSessionWrite`;local 店的写锁内同一组词)。 */
 export type { SessionWrite } from "../stores-sql/session-write-hooks.js";
@@ -193,7 +199,7 @@ export interface StoreBackend {
     close(): Promise<void>;
     run(): RunStore;
     /** E18 resume-at eventId→entryId map. REQUIRED on all backends (works local — needs only the session tree + this
-     *  map, no cloud-only checkpoint), unlike the optional cloud-only stores below. */
+     *  map, no cloud-only checkpoint), unlike the optional cloud-only stores below. **恒同一只**(附随店的律见 {@link landedAttendants})。 */
     resumeAnchor(): ResumeAnchorStore;
     /** Per-session per-toolName approval exemption ("本会话不再询问") — an approval MEMORY the F4
      *  ask-gate consults after deny/neverAuto. REQUIRED on all backends (works local, like resumeAnchor). */
@@ -250,12 +256,20 @@ export interface StoreBackend {
     userInputLedger(): UserInputLedgerStore;
     /** E6 durable SessionPolicyStore (operator-tightened per-session tool rules). REQUIRED on all backends — works local
      *  (local = core's FileSessionPolicyStore), like resumeAnchor. Backs core's RunnerDeps.sessionPolicyStore.
-     *  `logger`:SQL 孪生抹除封键那一臂([ref])的点名口(装配点缺省交日志出口接缝的 logger);local(core 的 File 店)不收。 */
-    sessionPolicy(logger?: SessionPolicyStoreLogger): ServiceSessionPolicyStore;
+     *  **恒同一只**(附随店的律见 {@link landedAttendants}):服务面的规则读口、引擎的规则席、E21 抹除与落定席位的规则写都是这一只。
+     *  SQL 孪生抹除封键那一臂([ref])的 warn 经开后端时交的 warn 座(`createStoreBackend` 第二参;缺席 ⇒ 日志出口接缝的缺省 logger)。 */
+    sessionPolicy(): ServiceSessionPolicyStore;
     /** [ref] per-edited-file rewind FileHistoryStore (trackEdit/annulTrack/snapshot/restore over the tracked set;
      *  also the 2c history-transfer store). REQUIRED on all backends (local = core's file-backed
-     *  `FileFileHistoryStore` under the data root). Backs core's RunnerDeps.fileHistoryStore. */
+     *  `FileFileHistoryStore` under the data root). Backs core's RunnerDeps.fileHistoryStore. **恒同一只**(附随店的律见 {@link landedAttendants})。 */
     fileHistory(): ServiceFileHistoryStore;
+    /** 会话附随物(文件历史图 · 会话规则行 · 回退锚)的**唯一写口** —— 落定席位(`plugins/landed-attendants.ts`):每一笔写在一只先锁会话根行、判过住客的段里,
+     *  住客不是那一位 ⇒ 零写。会话同步的落定腿、`PUT /v1/sessions/:id/policy`、运行腿的每轮回退锚都经它。**必选**:SQL 两只后端交一只事务形(与会话店同一只池),
+     *  local 后端交会话写锁一节形;自建后端的嵌入方实现它(没有它,会话同步族答 501)。
+     *  🔴 **附随店的律**:一只后端对 {@link sessionPolicy} / {@link fileHistory} / {@link resumeAnchor} 与本席位各恒交同一只实例,席位写的就是那三只读口交出的店
+     *  (服务面 `ServiceDeps` 上附随店只有这一条读法 —— `deps.backend` —— 没有第二个注入位)。随包三只后端都如此;自建后端的嵌入方同守(写经一只、读经另一只 ⇒
+     *  `PUT …/policy` 答 200 而 `GET` 与引擎读不到这条收紧)。 */
+    landedAttendants(): LandedAttendantSeat;
     /** [ref] §3.1 / [ref] §一([ref] S-2):per-principal **memory-capture opt-out 授权表**
      *  (`memory_optout_grant`)—— `RuntimeCaps.allowMemoryOptOut` 的本地 verdict 源(三层折叠:per-principal
      *  行 → 部署缺省哨兵行 → 代码缺省 allow)+ `/v1/admin/memory-optout` 四端点的持久层。
@@ -319,7 +333,7 @@ export interface StoreBackend {
     /** P1 (fleet failover): durable cross-replica WorkflowRunStore + completion-inbox twins. OPTIONAL —
      *  SQL backends only (local keeps the File pair: single box, no cross-replica surface). main.ts prefers
      *  these under WORKFLOW_RUN_STORE=auto (the default). */
-    workflowRun?(onWarn?: InboxWarn): import("@sema-agent/core").WorkflowRunStore;
+    workflowRun?(onWarn?: InboxWarn): SqlWorkflowRunStore;
     completionInbox?(onWarn?: InboxWarn): import("../orchestration/workflow-completion-inbox.js").WorkflowCompletionInbox;
     /** 1.108 review fix (lens③ HIGH): the notify-JOURNAL twin — third leg of the same axis (a SQL run store +
      *  inbox with a replica-LOCAL File journal stranded a dead replica's un-acked notify forever). */
@@ -329,11 +343,12 @@ export interface StoreBackend {
      *  缺席**是一个真答案**:那里的索引家在 run 店同一间屋子里(`LocalWorkflowAgentSessionIndex`,文件账本
      *  或纯内存),不需要经过 backend。契约与单写者纪律的属主 = orchestration/workflow-agent-session-index.ts。 */
     workflowAgentSessionIndex?(): import("../orchestration/workflow-agent-session-index.js").WorkflowAgentSessionIndex;
-    /** workflow 子代停驻卡的耐久决定行(一张卡一行,键 = 子代 checkpoint 的 token),**绑在本后端的 {@link run} 那只 run 店上**(每一笔写都在它的会话认领栅栏里落)。
-     *  与 `run()` 同形:无参、恒交同一只(三孪生同),所以这只决定店绑的就是部署的 run 店。SQL 后端 = 跨副本表,读写走 run 店的池;`local` 后端 = 进程内,
-     *  账本位置由后端按自己的数据根与 `WORKFLOW_RUN_STORE` 定(`<数据根>/workflows/workflow-park-decisions/decisions.jsonl`;`memory` ⇒ 纯内存)。
+    /** workflow 子代停驻卡的耐久决定行(一张卡一行,键 = 子代 checkpoint 的 token),**绑两只栅栏**:本后端的 {@link run} 那只 run 店(认领栅栏)与 `records` ——
+     *  本服务全部 workflow 记录写者经它写的那只记录店(记录栅栏:SQL 后端 = 本后端 `workflowRun()` 交出的 SQL 记录店,同一只池;local 后端 = 基店外那只按 runId 互斥的装饰器)。
+     *  恒交同一只(三孪生同):记录栅栏在第一次交出时绑定,以另一只记录店再取 ⇒ 响亮抛(两只栅栏各管各的就不是同一个仲裁点)。SQL 后端 = 跨副本表,读写走 run 店的池;
+     *  `local` 后端 = 进程内,账本位置由后端按自己的数据根与 `WORKFLOW_RUN_STORE` 定(`<数据根>/workflows/workflow-park-decisions/decisions.jsonl`;`memory` ⇒ 纯内存)。
      *  契约与律的属主 = orchestration/workflow-park-decision.ts。 */
-    workflowParkDecisions?(): import("../orchestration/workflow-park-decision.js").WorkflowParkDecisionStore;
+    workflowParkDecisions?(records: WorkflowRecordFenceStore): WorkflowParkDecisionStore;
     /** Cloud-only stores below are OPTIONAL: the `local` (in-memory/file) backend omits them (it has no core
      *  in-memory twin carrying the service extras, and these are fleet/multi-replica concepts), so a local HTTP
      *  service degrades EXACTLY like today's no-DB env (the consumers gate on `backend?.X?.()`). TiDB/PG provide all. */
@@ -434,6 +449,11 @@ export interface StoreBackend {
     fileUsageWindowStore?(): UsageWindowStore;
     /** **local 后端专有**:构造时交给两半店(会话店顶层、检查点店)的那一份声明(唯一读者 `localStoreDeclarationOf`)—— 装配值从这里读回,不重算。SQL 后端省略。 */
     localStoreDeclaration?(): LocalStoreDeclaration;
+    /**
+     * 会话店活引用判的 workflow 那一腿(会话种类的老化;`local-session-live-reference.ts`):本后端的会话店读不到 workflow run 店时(local:那只店在 boot 第 6 段才铸),
+     * 第 6 段把这台部署的 workflow run 店交过来(不起 workflow ⇒ `"none"`);绑一次。SQL 两孪生不实现(它们的判是一句 SQL,读 `workflow_run` 表)。
+     */
+    bindWorkflowRunReader?(reader: LocalWorkflowRunsReader | "none"): void;
 }
 /**
  * 托管留存执行器的**组合**:引擎座表那一半(`SqlRetentionStore`,事务属主)+ 部署那一半(hold / 审计 / 认领判 / 十三张部署表,
@@ -467,8 +487,13 @@ export declare function createSqlSessionEraser(db: SqlDriver, opts: RetentionExe
  *  ({@link SQL_BLOB_POSTURE_FACTS})。云形缺 MinIO ⇒ fail-loud(启动了才是假安全);`SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true` =
  *  显式接受 SQL 店 + per-blob 帽(单机/测试台形;pg 上帽只来自 `SNAPSHOT_BLOB_SQL_MAX_BYTES`)。local 后端不经此门(file 店,无 SQL 包墙)。 */
 export declare function assertCloudSnapshotBlobPosture(kind: "mysql" | "pg" | "local", config: Pick<ServiceConfig, "snapshotBlobStore" | "snapshotBlobAllowSql">): void;
-/** SQL 一次性迁移段的输入(两只 SQL 后端同一份;各条目那一半的来源见 `SqlOneTimeMigrationInput`):M32 的车道表 · M40 的判活窗 = 收割器的同一个窗 · M48 的部署形读数(表里那一行)。 */
+/** SQL 一次性迁移段的输入(两只 SQL 后端同一份;各条目那一半的来源见 `SqlOneTimeMigrationInput`):M32 的车道表 · 停-迁-起证据读法的判活窗(守卫段与 M43 读,`stop-then-start.ts`)= 收割器的同一个窗 · M48 的部署形读数(表里那一行)。 */
 export declare function buildSqlOneTimeMigrationInput(config: ServiceConfig): SqlOneTimeMigrationInput;
+/**
+ * SQL 落定席位的组装(两只 SQL 后端同一只;进程内夹具也经它):席位跑在 `db`(这台后端的池)上,写经的就是交进来的这两只店 —— 后端交的是它自己的那一只
+ * (`fileHistory()` / `sessionPolicy()`,读者读的同一只实例);席位只调它们的**语句片**(出口表的 `in-store`)与两只不拨库的判官 / 披露口,锚的语句片住 `resume-anchor-store-sql.ts`。
+ */
+export declare function sqlLandedAttendantsOf(db: SqlDriver, history: SqlFileHistoryStore, policy: SqlSessionPolicyStore): LandedAttendantSeat;
 /**
  * LOCAL backend (clay 2026-06-25 seamless local↔cloud; P0.5 variant-2 + variant-1 file-backed 2026-06-26): a DB-less StoreBackend
  * so a locally-run HTTP service serves the SAME contract a cloud worker does (runs + trace + sessions + resume;
@@ -527,6 +552,8 @@ export interface LocalStoreBackend extends StoreBackend {
     fileUsageWindowStore(): UsageWindowStore;
     /** local 后端恒有(构造时交给两半店的声明;接口上可选的那一口在这里必在)。 */
     localStoreDeclaration(): LocalStoreDeclaration;
+    /** local 后端恒有(会话店活引用判的 workflow 晚绑座;接口上可选的那一口在这里必在)。 */
+    bindWorkflowRunReader(reader: LocalWorkflowRunsReader | "none"): void;
 }
 /** 引擎 File 后端上会话店之外、本仓没有自己一份口的店(run-local 的 Runner 接它们;工具结果 / 用量窗 / 会话规则走既有的 `toolResult()` / `fileUsageWindowStore()` / `sessionPolicy()` 口)。 */
 export type LocalEngineFileStores = Pick<FileStorageBackend, "checkpointStore" | "backgroundAgentStore" | "mailboxStore" | "rosterStore">;