@sema-agent/server 7.150.0 → 7.151.0

package/dist/memory-scope.js

@@ -1,6 +1,6 @@
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
-import { FileMemoryEngineBackend, readMemoryLedgerForm, resolveMemoryEngineRoot, deriveControlPlaneDir, formatUserScope, formatProjScope, normalizeMemorySpec } from "@sema-agent/core";
+import { FileMemoryEngineBackend, physicalPathOf, readMemoryLedgerForm, resolveMemoryEngineRoot, deriveControlPlaneDir, formatUserScope, formatProjScope, normalizeMemorySpec } from "@sema-agent/core";
 import { capabilitiesFor, executionLaneOf } from "./execution-lane-caps.js";
 import { errorCodeOf, errorKindOf } from "./observability/err-text.js";
 import { assertMemoryScopeWidth } from "./plugins/memory-key-guards.js";
@@ -113,7 +113,7 @@ export function fileMemoryEngineRoot(config, fallbackRoot) {
 }
 export function canonicalPathOf(p) {
     if (isAbsolute(p) && existsSync(p))
-        return realpathSync.native(p);
+        return physicalPathOf(p);
     const abs = isAbsolute(p) ? p : `${process.cwd()}${sep}${p}`;
     const { root } = parse(abs);
     let existing = root;
@@ -134,7 +134,7 @@ export function canonicalPathOf(p) {
         }
         const next = join(existing, seg);
         if (existsSync(next))
-            existing = realpathSync.native(next);
+            existing = physicalPathOf(next);
         else
             tail.push(seg);
     }

package/dist/memory-sync-client.d.ts

@@ -1,4 +1,4 @@
-import { type memorySyncReportOf, type MemorySyncTransport } from "@sema-agent/core";
+import { type memorySyncReportOf, type MemorySyncLayerReport, type MemorySyncTransport } from "@sema-agent/core";
 import type { ServiceConfig } from "./config-types.js";
 import type { MemoryScopeStores } from "./memory-scope-stores.js";
 import { type OneTimeMigrationWindow } from "./plugins/one-time-migrations.js";
@@ -48,10 +48,37 @@ export declare function memorySyncCursorDirFor(memoryEngineDir: string): string;
  * 加一个词 ⇒ {@link wayOutSentence} 的穷尽 switch 编译红(句子先写好,词才上得了 wire)。
  */
 export type MemorySyncWayOut = "delete_cursor";
-/** ⑦ 一层停驻的读数(读面与运维行同读这一只记录;不带盘路径 —— 路径只进运维行)。 */
+/** 引擎游标拒的 `detail`(轴 + 游标在那一轴上是缺席还是别的值);型取自引擎的同步报告,本仓不另写一份。 */
+type CursorRefusalDetail = NonNullable<Extract<MemorySyncLayerReport, {
+    readonly outcome: "refused";
+}>["detail"]>;
+/** 一层为什么停驻(铸记录的输入):`kind` 与引擎读数经记录上 wire,`why` 句只进运维行的 `note`(不在记录里)。 */
+type ParkCause = {
+    readonly kind: "cursor_refused";
+    readonly detail: CursorRefusalDetail | undefined;
+} | {
+    readonly kind: "cursor_unusable";
+    readonly why: string;
+};
+/**
+ * ⑦ 停驻成因的闭集(词 = {@link ParkCause} 的 `kind`):`cursor_refused` = 同步引擎在游标上拒了这一层(轴与读数见 `axis` / `found`);`cursor_unusable` = 游标文件读不成游标。
+ * 与运维行的 `reason`(本轮的触发原因)是两回事 —— 本词答「为什么停」,不答「哪一轮撞上它」。
+ */
+export type MemorySyncParkCause = ParkCause["kind"];
+/** 引擎游标拒读数的两个闭集(型取自引擎的同步报告,本仓不另写一份):被拒的是哪一轴;游标在那一轴上是缺席(`absent`)还是绑着别的值(`other`)。 */
+export type MemorySyncCursorAxis = CursorRefusalDetail["axis"];
+export type MemorySyncCursorFound = CursorRefusalDetail["found"];
+/**
+ * ⑦ 一层停驻的记录(读面与运维行同读这一只;**整条**就是 `memory-status.memorySync.parked[]` 的条目,所以它不带盘路径 —— 路径只进运维行)。
+ * 在场律:`cause` 恒在;`axis` / `found` ⇔ 成因是 `cursor_refused` 且引擎的读数在闭集内(别的成因、读数不在闭集 ⇒ 两键缺席,不是 `undefined` 值)。
+ * 加一个键 ⇒ 它就上 wire:自铸登记表的键集(`memorySyncParkedKey`)按本型 `satisfies`,漏登是编译红。唯一铸点 = {@link parkedLayerOf}。
+ */
 export interface MemorySyncParkedLayer {
     readonly scope: string;
     readonly wayOut: MemorySyncWayOut;
+    readonly cause: MemorySyncParkCause;
+    readonly axis?: MemorySyncCursorAxis;
+    readonly found?: MemorySyncCursorFound;
 }
 /** M31 一次的读数(测试按它断言)。`window: "closed"` ⇒ 一行都没读。 */
 export interface SyncCursorRelocationM31Report {
@@ -134,4 +161,5 @@ export declare function startMemorySyncRunner(deps: {
     stores: MemoryScopeStores;
     log: MemorySyncLog;
 }): MemorySyncRunner;
+export {};
 //# sourceMappingURL=memory-sync-client.d.ts.map

package/dist/memory-sync-client.js

@@ -55,6 +55,18 @@ export function memorySyncCursorDirFor(memoryEngineDir) {
 }
 const CURSOR_AXES = { scope: true, peer: true, store: true, incarnation: true };
 const CURSOR_FOUND = { absent: true, other: true };
+function parkedLayerOf(scope, cause, wayOut) {
+    switch (cause.kind) {
+        case "cursor_refused":
+            return Object.freeze({ scope, wayOut, cause: cause.kind, ...(cause.detail !== undefined ? { axis: cause.detail.axis, found: cause.detail.found } : {}) });
+        case "cursor_unusable":
+            return Object.freeze({ scope, wayOut, cause: cause.kind });
+        default: {
+            const unhandled = cause;
+            throw new Error(`memory sync: unknown park cause ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
 function wayOutSentence(wayOut, cursorPath) {
     switch (wayOut) {
         case "delete_cursor":
@@ -81,16 +93,12 @@ function parkCauseSentence(cause) {
     }
 }
 class MemorySyncLayerParked extends Error {
-    scope;
     cursorPath;
-    parkCause;
-    wayOut;
+    layer;
     constructor(scope, cursorPath, parkCause, wayOut = "delete_cursor") {
         super(`memory sync: layer ${JSON.stringify(scope)} parked — ${parkCauseSentence(parkCause)}; ${wayOutSentence(wayOut, cursorPath)}`);
-        this.scope = scope;
         this.cursorPath = cursorPath;
-        this.parkCause = parkCause;
-        this.wayOut = wayOut;
+        this.layer = parkedLayerOf(scope, parkCause, wayOut);
     }
 }
 function cursorRefusalOf(err) {
@@ -354,8 +362,7 @@ export function createMemorySyncRunner(opts) {
     let parkedLayers = [];
     const logLayerFailure = (reason, scope, err) => {
         if (err instanceof MemorySyncLayerParked) {
-            const refused = err.parkCause.kind === "cursor_refused" ? err.parkCause.detail : undefined;
-            opts.log.warn("memory_sync_layer_parked", { reason, scope, cursorPath: err.cursorPath, ...(refused !== undefined ? { axis: refused.axis, found: refused.found } : {}), wayOut: err.wayOut, note: err.message });
+            opts.log.warn("memory_sync_layer_parked", { reason, cursorPath: err.cursorPath, ...err.layer, note: err.message });
         }
         else {
             opts.log.warn("memory_sync_layer_failed", { reason, scope, cursorPath: memorySyncCursorPath(memoryEngineDir, scope), err: errorText(err) });
@@ -386,7 +393,7 @@ export function createMemorySyncRunner(opts) {
             catch (err) {
                 calls.push({ scope, thrown: err });
                 if (err instanceof MemorySyncLayerParked)
-                    parkedNow.push({ scope, wayOut: err.wayOut });
+                    parkedNow.push(err.layer);
                 logLayerFailure(reason, scope, err);
             }
         }

package/dist/observability/err-text.d.ts

@@ -14,4 +14,11 @@ export declare function errorKindOf(err: unknown): string;
  * 不是串 ⇒ `undefined`(没有码,不编一个)。调用方按自己的形判(什么样的码配进一句拒句)再用它。
  */
 export declare function errorCodeOf(err: unknown): string | undefined;
+/**
+ * 不可信对象上**一个成员**的读口(店边界读 `code` / `errno` / `cause` / `message` 的唯一一只;同一处兜底 {@link readOr}):不是对象 ⇒ 缺席;访问器 / 代理抛 ⇒ 缺席(`undefined`)。
+ * 三问(缺席倒向):错误落到哪 —— 成员被当作不在,不单独记(这一读不是任何一条路的判词);谁受害 —— 没有真实受害者(驱动错误是平面数据对象),只有 getter 会抛的对象读不出码 / 链 / 句;
+ * 缺席倒向 —— 码读不出 ⇒ 没有码扳机、`cause` 读不出 ⇒ 链在此处止步,而**驱动出身扳机按对象身份判、不读任何成员**(`plugins/error-origin.ts`),链深扳机数的是层数 —— 所以带驱动记号的错照样**触发**换形;
+ * 换形本身读 `code` 判类时,成员 getter 会抛的对象仍可能在那一步抛出(店边界既有的限制,不是本读口引入的;真实驱动错误是平面数据对象,不在射程内)。
+ */
+export declare function errorMemberOf(o: unknown, key: string): unknown;
 //# sourceMappingURL=err-text.d.ts.map

package/dist/observability/err-text.js

@@ -30,4 +30,9 @@ export function errorCodeOf(err) {
     }, "");
     return code === "" ? undefined : code;
 }
+export function errorMemberOf(o, key) {
+    if (o === null || typeof o !== "object")
+        return undefined;
+    return readOr(() => o[key], undefined);
+}
 //# sourceMappingURL=err-text.js.map

package/dist/observability/fail-open.d.ts

@@ -55,13 +55,13 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "S-1173(`workflow-notify-journal.ts` 的 `ensurePointersFor`,park 指针的唯一写点):workflow run 记录的 `parks[]` **读不出**(在场却不是列表 / 某条目身份位或持有者两位形坏;读者 = `workflow-agent-session-index.ts` 的 `readRunParks`,整档成败制)⇒ 这一份指针投影派生不出来 ⇒ 写者这次**不写**指针,记录照写(已写过的指针只增不删,原样留着)。修前这一臂静默 `return`。**`parks` 缺席不进这一臂**:那是引擎契约里的合法形(更早引擎写的记录 / 准入没走完的续跑记录),读者答 `[]`(没有条目),没有要写的指针,不计。与指针**写**失败分家:写失败 ⇒ 记录写抛、记录不落(指针先于记录,不 fail-open);本臂没有丢任何一枚已写的指针 —— 读不出的是**记录本身**,引擎对条目形坏的记录整条拒续跑(`park_binding_broken`),读口对已有指针的 run 据记录响亮拒(`unproven/unreadable`),所以要的是查那条记录为什么读不出(投影把它写坏 / 手改)。放行的最坏后果:这条 run 首写就读不出时没有指针 ⇒ 这张卡没有别的指针时 `/decide` 落 legacy 腿、409 响亮拒,方向 fail-closed,不误配、不放行任何东西;例外 —— 同一张卡上另一支的指针在时分叉门判不出、决定投给那一支(引擎从不写坏形,要这一支在首写之前就被写坏);derived cache 没更新、真源读口自带响亮拒 ⇒ F 类。detail = `runId=`;计数非零 = 有记录的 `parks[]` 读不出,按 runId 去查记录。";
     };
-    readonly "server.workflow-live-receipt.channel-unreadable": {
+    readonly "server.workflow-park-holder.read-failed": {
         readonly cls: "F";
-        readonly note: "活 run 收下 workflow 停驻卡的决定之后,本进程回执簿(`parked-decide.ts` 的 `holdLiveReceipt`)等那条 run 的引擎观察通道收场来删簿;等的那一读拒 ⇒ 按收场删掉这条 run 的回执。放行的最坏后果:那条 run 仍在跑、驱动还在等并发槽时,同一决定重点一次答 409 `decide.claim_lost` 而不是首张回执(卡此刻仍 pending,重读列表再决);不重复执行、不放宽任何判定。";
+        readonly note: "workflow 停驻卡持有进程的拉取腿(`orchestration/workflow-park-holder.ts`,维护拍上读本进程执行中、持有停驻卡的 run 的决定行,把立住的决定在本地交给引擎)这一拍对某条候选读不出:决定行的主键读抛或超过期限(`step=decision`)、卡 / 持有者那一读超过期限(`step=card`),或执行器视图等那条 run 的引擎观察通道收场的那一读拒(`step=channel`,core 的观察队列只关不拒,结构上不可达)。放行的最坏后果:这条决定这一拍不交,行留着、卡仍 pending —— 下一拍再来;`channel` 那一形这条 run 出视图,它的行改由 run 的收场送达交给宿主会话的下一跑(交付晚到 run 收场,不丢、不错交)。不放宽任何判定:交不交、交给谁仍由行 + 卡状态 + 引擎判。detail = `step=<decision|card|channel> runId=<持有者> err=<原句,经记录器脱敏>`;计数持续非零 = 决定店 / 检查点店对这几条读不出,按 runId 查。";
     };
     readonly "server.workflow-park-decision.card-unreadable": {
         readonly cls: "F";
-        readonly note: "起跑读者(`parked-decide.ts` 的 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次)读某条已受理的 workflow 子代决定所属的那张卡时 checkpoint 店抛 ⇒ 这一跑**不带**这条决定,行留着给下一跑。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `runId=<留存锚> err=<原句,经记录器脱敏>`。";
+        readonly note: "交付决定行的三方(起跑读者 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次;workflow 停驻卡持有进程的拉取腿;run 收场送达)共用的逐行判(`parked-decide.ts` 的 `deliverableEntryOf`)读某条已受理的 workflow 子代决定所属的那张卡(`step=card`)或那张卡的当下持有者(`step=holder`:park 索引 / 记录读)时店抛 ⇒ 这一次**不交付**这条决定,行留着(起跑读者:这一跑不带它,下一跑照带;拉取腿:下一拍再来;收场送达:不 ack、`recover` 重投)。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店 / park 索引 / 记录店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `step=<card|holder> runId=<留存锚> err=<原句,经记录器脱敏>`。";
     };
     readonly "server.workflow-park-decision.store-unreadable": {
         readonly cls: "F";
@@ -351,6 +351,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "#329 / #343(黑板 [5100] Q3):停驻行迟到决议的**受理回执表**(本副本对「200 丢包后重试」的幂等承诺 + 重叠请求的单飞句柄;键 = 行的键 askId,只在一次赎回真开飞时开格;容量帽只数受理之后留下的回执,在飞的单飞句柄永不被逐)**拒留一张回执**。放行的最坏后果 = 这**一次**受理(照旧生效)没有本副本的回执可依:200 丢包后的重试会再进一次赎回腿、拿到那条腿的 409(那张 checkpoint 已被消费)而不是幂等 200 回放(终局恒由赎回腿的 gate CAS 定,不会错兑也不会双兑);迟到受理本身、`GET /v1/approvals` 列表与 `/v1/approvals/:sessionId/decide` 一个字节不动 ⇒ F 类。为什么方向是「拒新」而不是 FIFO 挤最旧:那个形让**甲的用量决定乙的可用性**(已鉴权租户量产受理即可把别家回执挤出,merge-rescan 744 confirmed 的同一病形)。必须留痕:「表被别人打满」与「这一次本来就没有回执」在 wire 上同形。detail 带 owner(判「压力来自谁」的第一手线索)。臂只有一条:全局回执帽满、本 principal 未到子帽、表里没有过期回执可收 ⇒ 拒留(detail 带 owner)。本 principal 到了子帽的常态臂逐自己最旧的一张回执(量产者自伤,设计内有界表纪律),不走本 tag;在飞的单飞句柄不占帽、永不被逐。";
     };
+    readonly "server.approval.parked-decision-not-recorded": {
+        readonly cls: "F";
+        readonly note: "S-1054 α(`tool-approval.ts` 的 `recordParkedOutcome`,停驻赎回那一飞的落行步):停驻门**已经受理**了这次决定(续跑已开始),而把它的记录(决议向 · 署名 · 理由 · 回决幂等键 · 出处)落到仍 `PARKED` 的问行上没成 —— 店错 / 超时 / 行出了门判过的属主域 / 这把键已被同 task 另一只问占着(detail 带 `reason`)。放行的最坏后果 = 这一问在耐久决断口上的**同键回放**读不到这把键:同键重发得到 `409 conflict.ask_decided`(回显门上站着的那次决定,决议向 / 时刻 / 理由取自门,无署名),而不是 200 回放;审计面少一份署名。决定本身零影响(终局恒在停驻门上,门已决);不改判、不重赎、不双兑。计数非零 = 问账店在受理之后写不动了,运维要去看店。";
+    };
     readonly "server.approvals.stale-echoed-token-unreadable": {
         readonly cls: "F";
         readonly note: "S-02 codex R1-[medium](验真后修):decide 的 409 `approval_stale` 臂对**调用方回显的旧 token** 做归属判定(`cs.get(binding.checkpointToken)`),那次读**抛了**(store 抖动 / 坏 checkpoint 行 / 行恰被清理)。修前这里是静默 `catch(()=>null)`,「读不出」被折成「确认不在库」——叠上 S-02 的 404 收口后,一次 store 抖动就会把合法旧 token 的 409+terminal 谎报成 404「没有这条审批」。修后:unreadable ⇒ **保持 409**(`terminal` 不披露——证不出归属就不说,与 2026-07-26 纪律同向;404 折叠只在读成功且未命中时走,探测方无法自控 store 故障 ⇒ 谕示封闭不破)。放行的最坏后果 = 该次拒体 `terminal` 诚实缺席(`currentPending` 由它自己的读口与属主复核另判,不受本臂牵连),壳退回重拉列表,judgment 面 fail-safe,故 F 类。留痕理由:这次读是 terminal 披露与 404 折叠两个判定的输入,长期抖动必须在遥测显形。";

package/dist/observability/fail-open.js

@@ -36,13 +36,13 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-1173(`workflow-notify-journal.ts` 的 `ensurePointersFor`,park 指针的唯一写点):workflow run 记录的 `parks[]` **读不出**(在场却不是列表 / 某条目身份位或持有者两位形坏;读者 = `workflow-agent-session-index.ts` 的 `readRunParks`,整档成败制)⇒ 这一份指针投影派生不出来 ⇒ 写者这次**不写**指针,记录照写(已写过的指针只增不删,原样留着)。修前这一臂静默 `return`。**`parks` 缺席不进这一臂**:那是引擎契约里的合法形(更早引擎写的记录 / 准入没走完的续跑记录),读者答 `[]`(没有条目),没有要写的指针,不计。与指针**写**失败分家:写失败 ⇒ 记录写抛、记录不落(指针先于记录,不 fail-open);本臂没有丢任何一枚已写的指针 —— 读不出的是**记录本身**,引擎对条目形坏的记录整条拒续跑(`park_binding_broken`),读口对已有指针的 run 据记录响亮拒(`unproven/unreadable`),所以要的是查那条记录为什么读不出(投影把它写坏 / 手改)。放行的最坏后果:这条 run 首写就读不出时没有指针 ⇒ 这张卡没有别的指针时 `/decide` 落 legacy 腿、409 响亮拒,方向 fail-closed,不误配、不放行任何东西;例外 —— 同一张卡上另一支的指针在时分叉门判不出、决定投给那一支(引擎从不写坏形,要这一支在首写之前就被写坏);derived cache 没更新、真源读口自带响亮拒 ⇒ F 类。detail = `runId=`;计数非零 = 有记录的 `parks[]` 读不出,按 runId 去查记录。",
     },
-    "server.workflow-live-receipt.channel-unreadable": {
+    "server.workflow-park-holder.read-failed": {
         cls: "F",
-        note: "活 run 收下 workflow 停驻卡的决定之后,本进程回执簿(`parked-decide.ts` 的 `holdLiveReceipt`)等那条 run 的引擎观察通道收场来删簿;等的那一读拒 ⇒ 按收场删掉这条 run 的回执。放行的最坏后果:那条 run 仍在跑、驱动还在等并发槽时,同一决定重点一次答 409 `decide.claim_lost` 而不是首张回执(卡此刻仍 pending,重读列表再决);不重复执行、不放宽任何判定。",
+        note: "workflow 停驻卡持有进程的拉取腿(`orchestration/workflow-park-holder.ts`,维护拍上读本进程执行中、持有停驻卡的 run 的决定行,把立住的决定在本地交给引擎)这一拍对某条候选读不出:决定行的主键读抛或超过期限(`step=decision`)、卡 / 持有者那一读超过期限(`step=card`),或执行器视图等那条 run 的引擎观察通道收场的那一读拒(`step=channel`,core 的观察队列只关不拒,结构上不可达)。放行的最坏后果:这条决定这一拍不交,行留着、卡仍 pending —— 下一拍再来;`channel` 那一形这条 run 出视图,它的行改由 run 的收场送达交给宿主会话的下一跑(交付晚到 run 收场,不丢、不错交)。不放宽任何判定:交不交、交给谁仍由行 + 卡状态 + 引擎判。detail = `step=<decision|card|channel> runId=<持有者> err=<原句,经记录器脱敏>`;计数持续非零 = 决定店 / 检查点店对这几条读不出,按 runId 查。",
     },
     "server.workflow-park-decision.card-unreadable": {
         cls: "F",
-        note: "起跑读者(`parked-decide.ts` 的 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次)读某条已受理的 workflow 子代决定所属的那张卡时 checkpoint 店抛 ⇒ 这一跑**不带**这条决定,行留着给下一跑。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `runId=<留存锚> err=<原句,经记录器脱敏>`。",
+        note: "交付决定行的三方(起跑读者 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次;workflow 停驻卡持有进程的拉取腿;run 收场送达)共用的逐行判(`parked-decide.ts` 的 `deliverableEntryOf`)读某条已受理的 workflow 子代决定所属的那张卡(`step=card`)或那张卡的当下持有者(`step=holder`:park 索引 / 记录读)时店抛 ⇒ 这一次**不交付**这条决定,行留着(起跑读者:这一跑不带它,下一跑照带;拉取腿:下一拍再来;收场送达:不 ack、`recover` 重投)。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店 / park 索引 / 记录店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `step=<card|holder> runId=<留存锚> err=<原句,经记录器脱敏>`。",
     },
     "server.workflow-park-decision.store-unreadable": {
         cls: "F",
@@ -332,6 +332,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "#329 / #343(黑板 [5100] Q3):停驻行迟到决议的**受理回执表**(本副本对「200 丢包后重试」的幂等承诺 + 重叠请求的单飞句柄;键 = 行的键 askId,只在一次赎回真开飞时开格;容量帽只数受理之后留下的回执,在飞的单飞句柄永不被逐)**拒留一张回执**。放行的最坏后果 = 这**一次**受理(照旧生效)没有本副本的回执可依:200 丢包后的重试会再进一次赎回腿、拿到那条腿的 409(那张 checkpoint 已被消费)而不是幂等 200 回放(终局恒由赎回腿的 gate CAS 定,不会错兑也不会双兑);迟到受理本身、`GET /v1/approvals` 列表与 `/v1/approvals/:sessionId/decide` 一个字节不动 ⇒ F 类。为什么方向是「拒新」而不是 FIFO 挤最旧:那个形让**甲的用量决定乙的可用性**(已鉴权租户量产受理即可把别家回执挤出,merge-rescan 744 confirmed 的同一病形)。必须留痕:「表被别人打满」与「这一次本来就没有回执」在 wire 上同形。detail 带 owner(判「压力来自谁」的第一手线索)。臂只有一条:全局回执帽满、本 principal 未到子帽、表里没有过期回执可收 ⇒ 拒留(detail 带 owner)。本 principal 到了子帽的常态臂逐自己最旧的一张回执(量产者自伤,设计内有界表纪律),不走本 tag;在飞的单飞句柄不占帽、永不被逐。",
     },
+    "server.approval.parked-decision-not-recorded": {
+        cls: "F",
+        note: "S-1054 α(`tool-approval.ts` 的 `recordParkedOutcome`,停驻赎回那一飞的落行步):停驻门**已经受理**了这次决定(续跑已开始),而把它的记录(决议向 · 署名 · 理由 · 回决幂等键 · 出处)落到仍 `PARKED` 的问行上没成 —— 店错 / 超时 / 行出了门判过的属主域 / 这把键已被同 task 另一只问占着(detail 带 `reason`)。放行的最坏后果 = 这一问在耐久决断口上的**同键回放**读不到这把键:同键重发得到 `409 conflict.ask_decided`(回显门上站着的那次决定,决议向 / 时刻 / 理由取自门,无署名),而不是 200 回放;审计面少一份署名。决定本身零影响(终局恒在停驻门上,门已决);不改判、不重赎、不双兑。计数非零 = 问账店在受理之后写不动了,运维要去看店。",
+    },
     "server.approvals.stale-echoed-token-unreadable": {
         cls: "F",
         note: "S-02 codex R1-[medium](验真后修):decide 的 409 `approval_stale` 臂对**调用方回显的旧 token** 做归属判定(`cs.get(binding.checkpointToken)`),那次读**抛了**(store 抖动 / 坏 checkpoint 行 / 行恰被清理)。修前这里是静默 `catch(()=>null)`,「读不出」被折成「确认不在库」——叠上 S-02 的 404 收口后,一次 store 抖动就会把合法旧 token 的 409+terminal 谎报成 404「没有这条审批」。修后:unreadable ⇒ **保持 409**(`terminal` 不披露——证不出归属就不说,与 2026-07-26 纪律同向;404 折叠只在读成功且未命中时走,探测方无法自控 store 故障 ⇒ 谕示封闭不破)。放行的最坏后果 = 该次拒体 `terminal` 诚实缺席(`currentPending` 由它自己的读口与属主复核另判,不受本臂牵连),壳退回重拉列表,judgment 面 fail-safe,故 F 类。留痕理由:这次读是 terminal 披露与 404 折叠两个判定的输入,长期抖动必须在遥测显形。",

package/dist/observability/metrics.js

@@ -279,6 +279,7 @@ export function createMetrics() {
     m.counter("memory_knn_query_failed_total", "Memory KNN searchScored queries that failed at runtime (S22)");
     m.counter("memory_dedup_folded_total", "Memory writes folded into an existing near-duplicate row (LOW)");
     m.counter("memory_dedup_probe_failed_total", "Memory dedup KNN probes that failed and fell through to INSERT (LOW)");
+    m.counter("store_boundary_fault_total", "SQL-store failures whose driver error was rewritten at the store boundary (code + fixed sentence leave the store; the driver's own sentence goes to the at=store log line), by site (store.method) and class (store fault judge word)");
     m.counter("redactions_applied_total", "redactSecrets rewrites (S24), by pattern label and `arm` (S-88: full vs prefix-fragment arm — which RULE fired, NOT proof the text was upstream-truncated)");
     m.counter("session_cache_stale_hit_total", "Warm session-cache hits dropped because the store had moved past the cached leaf (written by another replica, or gone); the session was re-woken from the store");
     m.counter("breaker_writethrough_failed_total", "Circuit-breaker cross-replica write-through failures (LOW), by backend");

package/dist/orchestration/workflow-notify-journal.d.ts

@@ -278,6 +278,15 @@ export declare class InMemoryWorkflowNotifyJournalStore implements WorkflowNotif
     get(runId: string): Promise<WorkflowNotifyJournalEntry | null>;
     get size(): number;
 }
+/** 一笔**落成**的记录写的观察者(执行器视图;型属主在这里,实现 = `workflow-park-holder.ts` 的 `HeldParksHere`)。 */
+export interface LandedRecordObserver {
+    noteLanded(runId: string, run: WorkflowRun): void;
+}
+/**
+ * 「本服务的 workflow 记录写者经哪一只记录店写」的唯一读法:交给引擎的那只记录店是 journaling 装饰器 ⇒ 它里面那一只(notify 门的收养翻转也经它写);
+ * 否则就是它自己。起服判官(`workflow-park-decision.ts` 的 `parkDecisionStoreRefusal`)拿它与决定店的记录栅栏按身份比。
+ */
+export declare function recordWriterOf(store: object): object;
 /**
  * A {@link WorkflowRunStore} DECORATOR that journals a run the instant core persists it at START. core's
  * `startWorkflow` `put`s the run row (`status: "running"`) synchronously before the body runs, carrying both the
@@ -304,6 +313,9 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
     private readonly agentSessionIndex?;
+    /** 本进程执行器视图(`workflow-park-holder.ts` 的 `HeldParksHere`):本装饰器在本进程引擎每一笔**落成**的记录写之后把记录交给它(它读其中本记录持有的停驻 token)。
+     *  写抛 / CAS 输 ⇒ 不交(视图保留上一份)。可选:缺席 ⇒ 不维护(没有 workflow 停驻车道的部署)。 */
+    private readonly landedRecords?;
     constructor(inner: WorkflowRunStore, 
     /** [ref] optional since the fleet decoupling: undefined ⇒ no start-time journal (ephemeral memory
      *  backend has nothing to recover), the FLEET half still publishes — the panel is replica-local UI
@@ -316,7 +328,12 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     /** [ref] 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
-    agentSessionIndex?: WorkflowAgentSessionIndex | undefined);
+    agentSessionIndex?: WorkflowAgentSessionIndex | undefined, 
+    /** 本进程执行器视图(`workflow-park-holder.ts` 的 `HeldParksHere`):本装饰器在本进程引擎每一笔**落成**的记录写之后把记录交给它(它读其中本记录持有的停驻 token)。
+     *  写抛 / CAS 输 ⇒ 不交(视图保留上一份)。可选:缺席 ⇒ 不维护(没有 workflow 停驻车道的部署)。 */
+    landedRecords?: LandedRecordObserver | undefined);
+    /** 本装饰器的每一笔记录写经它落下的那只记录店(起服判官按身份比:决定店的记录栅栏必须就是它 —— {@link recordWriterOf})。 */
+    get records(): WorkflowRunStore;
     /** 本进程**亲眼看着落进索引**的指针:run → 它点名过的子会话。只用来跳过重复的 upsert,不是缓存(指针只增不删,记着的必在索引里)。
      *
      *  为什么需要:workflow 的进度写是每只 agent 状态变化一次,而 park 是罕见事件 ⇒ 无条件 upsert 会给每一次写多打几发语句(SQL)

package/dist/orchestration/workflow-notify-journal.js

@@ -270,16 +270,24 @@ export class InMemoryWorkflowNotifyJournalStore {
         return this.entries.size;
     }
 }
+export function recordWriterOf(store) {
+    return store instanceof JournalingWorkflowRunStore ? store.records : store;
+}
 export class JournalingWorkflowRunStore {
     inner;
     gate;
     fleetBus;
     agentSessionIndex;
-    constructor(inner, gate, fleetBus, agentSessionIndex) {
+    landedRecords;
+    constructor(inner, gate, fleetBus, agentSessionIndex, landedRecords) {
         this.inner = inner;
         this.gate = gate;
         this.fleetBus = fleetBus;
         this.agentSessionIndex = agentSessionIndex;
+        this.landedRecords = landedRecords;
+    }
+    get records() {
+        return this.inner;
     }
     pointedSessions = new Map();
     async ensurePointersFor(id, run) {
@@ -338,10 +346,13 @@ export class JournalingWorkflowRunStore {
             scope: run.scope,
         });
         await this.writeWithPointers(id, run, () => this.inner.put(id, run), () => true);
+        this.landedRecords?.noteLanded(id, run);
         this.publishFleet(id, run);
     }
     async update(id, scope, run, expect) {
         const ok = await this.writeWithPointers(id, run, () => this.inner.update(id, scope, run, expect), (won) => won);
+        if (ok)
+            this.landedRecords?.noteLanded(id, run);
         if (ok)
             this.publishFleet(id, run);
         return ok;

package/dist/orchestration/workflow-park-decision.d.ts

@@ -1,4 +1,4 @@
-import { type CheckpointToken, type ResumeOutcome } from "@sema-agent/core";
+import { type CheckpointToken, type ResumeOutcome, type WorkflowRun } from "@sema-agent/core";
 import type { ResumeRestatement } from "../http/resume-restatement.js";
 import { type JsonColumnReader } from "../plugins/sql-json-column.js";
 import { type InProcessClaimFence } from "../plugins/store-contracts.js";
@@ -15,25 +15,68 @@ export interface WorkflowParkDecision {
     /** 带着它的会话 = 受理那一刻那条 run 的发起会话(宿主)。 */
     readonly hostSessionId: string;
     readonly outcome: WorkflowParkOutcome;
-    /** {@link parkDecisionFingerprint}:同一决定的判据(回执幂等用)。 */
+    /** {@link parkDecisionFingerprint}:同一决定的判据(先受理者立 / 回执幂等 / 收场转交的条件)。 */
     readonly fingerprint: string;
-    /** 受理它的那一次投递跑(回执上的 `taskId`)。 */
+    /** 承运者(回执上的 `taskId`):记录栅栏下 = 持有这张卡的那条 workflow run;认领栅栏下 = 投递那一跑。读者不按它的种类分支(文件头)。 */
     readonly deliveredTaskId: string;
-    /** 受理时刻(受理那台副本的墙钟,记录值;不当任何条件 —— 序由认领栅栏的提交序定,见文件头律二)。 */
+    /** 受理时刻(受理那台副本的墙钟,记录值;不当任何条件)。 */
     readonly acceptedAtMs: number;
 }
 /**
- * 决定行的店契约(SQL 两方言 / local 文件 / 内存三形同律)。写者只有 `/decide` 的 workflow 车道(开跑之前那一笔);读者是起跑读者与
- * `/decide` 自己的回执幂等判;删除只有 SQL 收割的级联。
+ * 记录栅栏下一次决断的结局(闭集;`switch` 穷尽):
+ *  · `not_running`    —— 记录已不读作 `running`(或不在)⇒ 承运者换成续跑车道的投递那一跑,零写;
+ *  · `not_held`       —— 仍在跑,本记录的 `parks[]` 已不持有这个 token(或读不出)⇒ 零写;
+ *  · `restated`       —— 仍在跑、仍持有,请求带续跑重述键(`mcpServers` / `a2aPeers`)⇒ 零写(活 run 上的子代带着它停驻时的表继续,重述盖不上);
+ *  · `other_decision` —— 行上已是**另一个**决定(先受理者立)⇒ 零写;
+ *  · `stands`         —— 本决定落下了,或行上就是同一决定(指纹相等)。
+ */
+export type HolderFenceVerdict = "not_running" | "not_held" | "restated" | "other_decision" | "stands";
+/** 记录栅栏的结局:`running: false` = 记录此刻不读作 `running`(或不在),`fn` 一次都没调。 */
+export type RecordFenced<T> = {
+    readonly running: true;
+    readonly value: T;
+} | {
+    readonly running: false;
+};
+/**
+ * **workflow 记录的「仍在跑」原子段 —— 进程内那一形**(属主 = `workflow-record-fence.ts` 的 `FencedWorkflowRecordStore`:本服务全部记录写者 ——
+ * 引擎经 journaling 装饰器、notify 门的收养翻转 —— 都经它写,它按 runId 互斥)。`whileRunning(runId, fn)`:在这条 run 的互斥段里读记录;读作 `running`
+ * 才调 `fn`(同步:判与写同一段,型上不许把写挪到段外)、答 `{ running: true, value }`,否则答 `{ running: false }`。
+ * SQL 孪生是一个事务(`SqlWorkflowRunStore.whileRunning`:锁住 `workflow_run` 行,`fn` 收那只事务连接),不是本型。
+ */
+export interface InProcessRecordFence {
+    whileRunning<T>(runId: string, fn: (run: WorkflowRun) => T): Promise<RecordFenced<T>>;
+}
+/** 记录栅栏的两形(闭集,与认领栅栏 `ClaimFenceStore` 同形):SQL 孪生一只行锁事务 / 进程内按 runId 互斥。决定店的两形各绑各的那一形。 */
+export type WorkflowRecordFenceStore = import("../plugins/workflow-run-store-sql.js").SqlWorkflowRunStore | InProcessRecordFence;
+/**
+ * 记录栅栏判的那一半(两形同一只纯函数;写那一半各形自己的原子段):本记录持有这个 token 吗(`heldParksOf`,`parks[]` 读不出 ⇒ 证不出持有),
+ * 请求带重述键吗。交回 `land` ⇒ 进「行上没有就落、有就比指纹」那一步。
+ */
+export declare function holderFenceAdmits(run: WorkflowRun, d: Pick<WorkflowParkDecision, "runId" | "token">, restated: boolean): "not_held" | "restated" | "land";
+/**
+ * 决定行的店契约(SQL 两方言 / local 文件 / 内存三形同律)。写者两个:`/decide` 与应答口的 workflow 车道(记录栅栏那一笔 / 续跑车道开跑之前那一笔)、
+ * run 收场送达的转交(续跑车道那一笔,带条件);读者是起跑读者、持有进程的拉取腿、收场送达与 `/decide` 自己的回执幂等判;删除只有 SQL 收割的级联。
  */
 export interface WorkflowParkDecisionStore {
-    /** 这只店每一笔写所在的认领栅栏 = 构造时绑定的那只 run 店。起服判官要它**就是**部署的 run 店({@link parkDecisionStoreRefusal})。 */
+    /** 认领栅栏 = 构造时绑定的那只 run 店。起服判官要它**就是**部署的 run 店({@link parkDecisionStoreRefusal})。 */
     readonly claims: object;
+    /** 记录栅栏 = 构造时绑定的那只 workflow 记录店。起服判官要它**就是**本服务记录写者共用的那一只。 */
+    readonly records: object;
+    /**
+     * 认领栅栏的原子段里写(律的第二个取值):投递那一跑此刻持有宿主会话的认领且在跑 ⇒ 写并答 `true`;否则什么都不写、答 `false`。
+     * `condition` 缺席 ⇒ 整行写(没有行插入、有行整行取代);在场 ⇒ 行上的指纹仍等于 `expect` 才整行写,否则不写、答 `false`(收场转交:一个更新的决定已在行上)。
+     */
+    record(decision: WorkflowParkDecision, condition?: {
+        readonly expect: string;
+    }): Promise<boolean>;
     /**
-     * 认领栅栏的原子段里整行写(律二,文件头):投递那一跑此刻持有宿主会话的认领且在跑 ⇒ 写(没有行插入、有行整行取代)并答 `true`;
-     * 否则什么都不写、答 `false`。
+     * 记录栅栏的原子段里判与写(律的第一个取值;`decision.deliveredTaskId` = `decision.runId` = 持有这张卡的那条 run):结局见 {@link HolderFenceVerdict}。
+     * 只有 `stands` 可能写过(行上本来没有时插入),其余零写。
      */
-    record(decision: WorkflowParkDecision): Promise<boolean>;
+    recordForRunningHolder(decision: WorkflowParkDecision, request: {
+        readonly restated: boolean;
+    }): Promise<HolderFenceVerdict>;
     get(token: CheckpointToken): Promise<WorkflowParkDecision | null>;
     /** 带着这个会话的全部决定行(顺序不承重)。 */
     listByHostSession(hostSessionId: string): Promise<WorkflowParkDecision[]>;
@@ -41,15 +84,17 @@ export interface WorkflowParkDecisionStore {
 /** 起服判官读的那几座(`ServiceDeps` 的子集)。 */
 export interface ParkDecisionLaneSeats {
     readonly runStore?: object | undefined;
+    readonly workflowRunStore?: object | undefined;
     readonly workflowAgentSessionIndex?: unknown;
     readonly workflowParkDecisions?: WorkflowParkDecisionStore | undefined;
 }
 /**
- * 🔴 **「决定店绑对了 run 店吗」的唯一判官**(`createHttpServer` 起服时调;拒 ⇒ 拒启)。判的是**递进来的对象**(按身份比),不是配置组合 ——
+ * 🔴 **「决定店绑对了两只栅栏吗」的唯一判官**(`createHttpServer` 起服时调;拒 ⇒ 拒启)。判的是**递进来的对象**(按身份比),不是配置组合 ——
  * 本服务自己那一形(SQL 后端配 `WORKFLOW_RUN_STORE=file|memory` 且开自编排)由配置不变量 `workflow-park-decision-domain` 在第 1 段、一次性迁移之前拒,走不到这里;
  * 走到这里的不相等只来自嵌入方递错了座。
- * 期望的绑定:workflow 子代停驻车道装了(park 索引在场)且部署有 run 店 ⇒ 决定店在场、绑的**就是**那只 run 店;否则不该有决定店。不相等的三形各一句:
- * ①车道与 run 店都在而决定店缺席;②决定店绑的是别的 run 店(两只店各取各的:决定写进一只库、认领与读在另一只);③有决定店,而车道没装或部署没有 run 店。
+ * 期望的绑定:workflow 子代停驻车道装了(park 索引在场)且部署有 run 店 ⇒ 决定店在场、`claims` **就是**那只 run 店、`records` **就是**本服务记录写者经它写的那只记录店
+ * ({@link recordWriterOf}:journaling 装饰器里面那一只);否则不该有决定店。不相等的四形各一句:
+ * ①车道与 run 店都在而决定店缺席;②决定店绑的是别的 run 店;③有决定店,而车道没装或部署没有 run 店;④决定店的记录栅栏不是本服务记录写者经它写的那一只。
  */
 export declare function parkDecisionStoreRefusal(seats: ParkDecisionLaneSeats): string | undefined;
 /**
@@ -68,24 +113,31 @@ export declare function parkDecisionFingerprint(outcome: WorkflowParkOutcome, re
  */
 export declare const readWorkflowParkOutcome: JsonColumnReader<WorkflowParkOutcome>;
 /**
- * 单机车道的决定店(`LocalWorkflowAgentSessionIndex` 的同室孪生),绑在进程内的 run 店上({@link InProcessClaimFence}:Memory / File run 店)。
+ * 单机车道的决定店(`LocalWorkflowAgentSessionIndex` 的同室孪生),绑在进程内的两只栅栏上:run 店({@link InProcessClaimFence}:Memory / File run 店)与
+ * 记录栅栏装饰器({@link InProcessRecordFence})。
  * `root` 在场 ⇒ 追加式 JSONL 账本(0o700 目录 + 0o600 账本,一行 = 一条决定行的整份快照,每一笔写都追加);重放按行序、**末行胜**
- * (写序就是认领栅栏的序:每一笔都在栅栏的同步段里追加,同一宿主会话上的受理由认领串行);缺席 ⇒ 纯内存(`WORKFLOW_RUN_STORE=memory` 的易失车道)。
+ * (写序就是栅栏的序:每一笔都在栅栏的段里追加);缺席 ⇒ 纯内存(`WORKFLOW_RUN_STORE=memory` 的易失车道)。
  *
  * 🔴 **坏行 fail-closed**(登记座 `workflow-park-decisions`):读不出的一行可能正是**取代**了一条旧决定的那一笔 —— 跳过它重放其余行,
- * 会把被取代的旧决定复活成当下的决定,在下一次起跑时交给引擎。闸合上之后三个动词都响亮拒,直到有人处理那只文件;
+ * 会把被取代的旧决定复活成当下的决定,在下一次交付时交给引擎。闸合上之后四个动词都响亮拒,直到有人处理那只文件;
  * 起跑读者(`parked-decide.ts`)把这一拒读成「本店没有可供的行」(F tag `server.workflow-park-decision.store-unreadable`)—— 起跑不连带拒,写与按 token 读照旧拒。
  * SQL 孪生同律:某一行 `outcome` 坏体 ⇒ 读口拒,起跑读者同一臂。
  */
 export declare class LocalWorkflowParkDecisionStore implements WorkflowParkDecisionStore {
     readonly claims: InProcessClaimFence;
+    readonly records: InProcessRecordFence;
     private readonly fsyncEnabled;
     private readonly ledgerPath;
     private readonly gate;
     private readonly rows;
     private log;
-    constructor(claims: InProcessClaimFence, root?: string, fsyncEnabled?: boolean);
-    record(decision: WorkflowParkDecision): Promise<boolean>;
+    constructor(claims: InProcessClaimFence, records: InProcessRecordFence, root?: string, fsyncEnabled?: boolean);
+    record(decision: WorkflowParkDecision, condition?: {
+        readonly expect: string;
+    }): Promise<boolean>;
+    recordForRunningHolder(decision: WorkflowParkDecision, request: {
+        readonly restated: boolean;
+    }): Promise<HolderFenceVerdict>;
     /** 整行写(同步):落盘**先于**内存翻转(调用方观察到的状态背后一定有耐久记录)。交回栅栏的落定记号(同步交回,型上不许让出)。 */
     private landNow;
     get(token: CheckpointToken): Promise<WorkflowParkDecision | null>;

package/dist/orchestration/workflow-park-decision.js

@@ -5,6 +5,14 @@ import { approvalPayloadFingerprint } from "../plugins/approval-payload-fingerpr
 import { createObjectColumnReader, isJsonObject } from "../plugins/sql-json-column.js";
 import { replayJsonlGuarded } from "../observability/corrupt-read-seat.js";
 import { FENCE_LANDED } from "../plugins/store-contracts.js";
+import { heldParksOf, readRunParks } from "./workflow-agent-session-index.js";
+import { recordWriterOf } from "./workflow-notify-journal.js";
+export function holderFenceAdmits(run, d, restated) {
+    const parks = readRunParks(run);
+    if (parks === undefined || !heldParksOf(d.runId, parks).some((p) => p.token === d.token))
+        return "not_held";
+    return restated ? "restated" : "land";
+}
 function seatName(v) {
     if (v === undefined)
         return "none";
@@ -14,7 +22,8 @@ function seatName(v) {
 export function parkDecisionStoreRefusal(seats) {
     const wanted = seats.workflowAgentSessionIndex !== undefined ? seats.runStore : undefined;
     const decisions = seats.workflowParkDecisions;
-    if (decisions?.claims === wanted)
+    const recordWriter = seats.workflowRunStore === undefined ? undefined : recordWriterOf(seats.workflowRunStore);
+    if (decisions?.claims === wanted && (decisions === undefined || decisions.records === recordWriter))
         return undefined;
     const pair = `run store: ${seatName(seats.runStore)}; workflow park decision store: ${decisions === undefined ? "none" : `${seatName(decisions)} bound to ${seatName(decisions.claims)}`}`;
     if (decisions === undefined) {
@@ -27,9 +36,14 @@ export function parkDecisionStoreRefusal(seats) {
             "a decision store is only read and written by that lane, which needs both the park index and the run store the decisions are fenced by; " +
             "wire the lane (park index and run store) or drop the decision store; refusing to start rather than keep a store no lane fences");
     }
-    return (`the workflow park decision store is not bound to this server's run store (${pair}) — ` +
-        "its writes are fenced by the run store it was built on, so a different run store means decisions recorded where the session claims are not checked; " +
-        "take runStore and workflowParkDecisions from the same store backend (run() and workflowParkDecisions()); refusing to start rather than record decisions the session claim cannot fence");
+    if (decisions.claims !== wanted) {
+        return (`the workflow park decision store is not bound to this server's run store (${pair}) — ` +
+            "its writes are fenced by the run store it was built on, so a different run store means decisions recorded where the session claims are not checked; " +
+            "take runStore and workflowParkDecisions from the same store backend (run() and workflowParkDecisions()); refusing to start rather than record decisions the session claim cannot fence");
+    }
+    return (`the workflow park decision store is not bound to the workflow record store this server writes run records through (workflow record writer: ${seatName(recordWriter)}; decision store's record fence: ${seatName(decisions.records)}) — ` +
+        "while the run that holds a card is running, a decision row is written in the same atomic step that checks the run's record still reads running and still holds the card, so the fence must be the store every record write goes through; " +
+        "pass the record store the workflow run store wraps to the store backend's workflowParkDecisions(); refusing to start rather than record decisions a run's end cannot be ordered against");
 }
 export function parkDecisionFingerprint(outcome, restatement) {
     const payload = approvalPayloadFingerprint({
@@ -76,13 +90,15 @@ function readRow(raw) {
 const LEDGER_LINE_SHAPE = { what: "a workflow park decision row", read: readRow };
 export class LocalWorkflowParkDecisionStore {
     claims;
+    records;
     fsyncEnabled;
     ledgerPath;
     gate;
     rows = new Map();
     log;
-    constructor(claims, root, fsyncEnabled = true) {
+    constructor(claims, records, root, fsyncEnabled = true) {
         this.claims = claims;
+        this.records = records;
         this.fsyncEnabled = fsyncEnabled;
         if (root === undefined) {
             this.ledgerPath = undefined;
@@ -92,14 +108,37 @@ export class LocalWorkflowParkDecisionStore {
         const dir = join(root, "workflow-park-decisions");
         ensureDir(dir);
         this.ledgerPath = join(dir, "decisions.jsonl");
-        const { records, gate } = replayJsonlGuarded(this.ledgerPath, "workflow-park-decisions", LEDGER_LINE_SHAPE);
-        this.gate = gate;
-        for (const d of records)
+        const replayed = replayJsonlGuarded(this.ledgerPath, "workflow-park-decisions", LEDGER_LINE_SHAPE);
+        this.gate = replayed.gate;
+        for (const d of replayed.records)
             this.rows.set(d.token, d);
     }
-    async record(decision) {
+    async record(decision, condition) {
+        this.gate?.assertUsable();
+        let superseded = false;
+        const held = this.claims.whileHoldingClaim(decision.hostSessionId, decision.deliveredTaskId, () => {
+            if (condition !== undefined && this.rows.get(decision.token)?.fingerprint !== condition.expect) {
+                superseded = true;
+                return FENCE_LANDED;
+            }
+            return this.landNow(decision);
+        });
+        return held && !superseded;
+    }
+    async recordForRunningHolder(decision, request) {
         this.gate?.assertUsable();
-        return this.claims.whileHoldingClaim(decision.hostSessionId, decision.deliveredTaskId, () => this.landNow(decision));
+        const fenced = await this.records.whileRunning(decision.runId, (run) => {
+            const admits = holderFenceAdmits(run, decision, request.restated);
+            if (admits !== "land")
+                return admits;
+            const existing = this.rows.get(decision.token);
+            if (existing === undefined) {
+                this.landNow(decision);
+                return "stands";
+            }
+            return existing.fingerprint === decision.fingerprint ? "stands" : "other_decision";
+        });
+        return fenced.running ? fenced.value : "not_running";
     }
     landNow(decision) {
         if (this.ledgerPath !== undefined) {