@sema-agent/server 7.150.0 → 7.152.0

package/dist/permission-mode-admission.d.ts

@@ -1,5 +1,5 @@
 /**
- * **一个调用方交来的权限模式词,本部署收不收、收成什么** —— 唯一的受理判官(规则一处、三只属主各一处、序一处)。
+ * **一个进入 run 的权限模式词(调用方交来的,或停驻 run 的存储体被重放时体上的),本部署收不收、收成什么** —— 唯一的受理判官(规则一处、三只属主各一处、序一处)。
  *
  * ## 一条规则,三只属主,本模块只排序
  *  ① 本任务 settings 的 kill-switch 折叠(`task-settings.ts` `foldDisableAutoMode`:`disableAutoMode` 在 ⇒ `auto` 折 `default`);
@@ -8,12 +8,31 @@
  * ①② 是**入口一步**({@link entryStep}:改词、不拒),③ 是**托管一步**(只拒、不改词)。顺序承重的只有「② 在 ③ 之前」(地板把 bypass 钳成 plan 之后就不开写面,不拒);
  * ① 只动 `auto`、③ 只看开写面的词,两者互不相交。
  *
- * ## 两口的调用形(同一组函数、同一个序;同一个词 × 同一份部署事实 × 同一份任务 settings ⇒ 同一个结果,钉 `test/run-permission-mode-admission.test.ts` 的两口表)
+ * ## 三口的调用形(同一组函数、同一个序;提交口与切档口:同一个词 × 同一份部署事实 × 同一份任务 settings ⇒ 同一个结果,钉 `test/run-permission-mode-admission.test.ts` 的两口表;
+ *    续跑口与它们只差一张写据,钉 `test/entry-permission-mode.test.ts` 的续跑口表)
  *  · 在飞 run 的切档口(`http/routes/run-permission-mode.ts`:`POST /v1/runs/:id/permission-mode` 的 `mode`,本任务 settings 读存储体)调整只判官 {@link admitPermissionModeWord}。
  *  · 提交口(`POST /v1/tasks|/v1/tasks/stream|/v1/runs` 的词 = 顶层 `permissionMode` ?? bundle `settings.permissions.defaultMode`)把两步落在**上一版就在的两处**:
  *    入口一步在受理门盖章({@link stampSubmissionEntryMode},`http/admission.ts`:值形门之后、装配之前 —— 首跑装配与 `buildCheckpointCtx` 读的都是盖过章的体);
  *    托管一步是装配期那一处判(`boot/resolve-spec.ts`,对盖过章的词调同一只 ③;提交腿与续跑重放腿同经)。不把整只判官提前到受理门:那会让托管拒抢在
- *    属主 / 会话 / 执行上下文与装配期其余值判之前答(拒序变了 —— 钉同一文件的拒序组)。续跑重放不再过 ②:地板是**入口**事实,热改只影响之后提交的任务。
+ *    属主 / 会话 / 执行上下文与装配期其余值判之前答(拒序变了 —— 钉同一文件的拒序组)。
+ *  · 续跑口(一条 HTTP 车道停驻 run 的存储体被重放之前;`http/resume-legs.ts` 的 `replayCtxOf`,五个续跑读点同调;leader 车道的行按那条车道「一 run 一读」照写下的体重放,
+ *    规则在 `replayCtxOf` 头注)调 {@link stampReplayEntryMode}:体上的词过与提交口**同一只**入口一步
+ *    ({@link bodyEntry}:同一只折叠、同一只 `entryPermissionMode`、地板读同一份**活** config)—— 提交之后运维把 `AUTONOMY` 改严,或体是更早的写者留下的请求原词,
+ *    重放照**现**地板钳;被钳 = 钳到地板放行(与提交口同形,不拒、不新增码),生效词由这条腿的 `wiring_manifest.permissionMode` 说;钳过的体随 CAS 赢点写回,
+ *    存储体仍是这条 run 模式词唯一的源。与提交口只差一张**写据**(不是续跑专用臂,见下一节):写据说体顶层那一格是这块地板的出口写下的、且仍是它写下的那一格 ⇒ 原样读。
+ *    托管一步照旧在装配期判。
+ *
+ * ## 写据:存储体上的模式词谁写的(一条规则)
+ * 存储体顶层 `permissionMode` 那一格谁写,谁就在同一笔写里留一张写据({@link PermissionModeWrite} `{ by, mode }`,`CheckpointCtx.permissionModeWrite`:服务端写、
+ * 客户端够不着)。写者闭集四个({@link PERMISSION_MODE_WRITERS}):`submission`(提交写口 `buildCheckpointCtx`,经 `http/submit-ctx.ts` `persistSubmissionCtx`;leader worker 的续跑体)、
+ * `switch`(在飞切档的写回)、`replay`(本模块续跑口的钳)、`plan_review`(`http/resume-legs.ts` `drivePlanReview` 批准 / 编辑把计划带出 plan 的写回 —— plan 地板的出口:一个人批了这份计划)。
+ * 新的持久化写经构造口(写据是它的必填键,漏写 = 编译红);改写那一格经一只改写口 {@link withStoredPermissionMode}(一笔换词、换写据)。
+ * 读者只有一个:续跑口。地板在场时只问「这块地板的出口是谁」({@link floorExitWriter})—— 写据的 `by` 就是它、且写据的 `mode` 仍等于体顶层的原值 ⇒ 原样;
+ * 其余一律照现地板钳(缺写据 = 7.152.0 之前写下的行,或从这样的行照抄的体;别的写者写下的同字词;bundle 拼法;kill-switch 折出来的词;词表外的串 —— 都落在这一个「否」里)。
+ * `mode` 绑定为什么承重:更早版本的副本(滚动升级窗、回滚再升回)读 ctx 时把不认识的兄弟键展开带走,把词改成另一个词却不改写据 ⇒ 写据对不上那一格 ⇒ 照钳(失效关闭,不读版本号)。
+ * ⚠️ 射程如实:旧副本把词切走又切回写据上的同一个词(批准写下 `acceptEdits` 之后在旧副本上 `acceptEdits → default → acceptEdits` 切档),写据仍对得上 ⇒ 原样 ——
+ * 与 7.151.0 同读(不比上一版宽);只看 `mode` 分不出这一形,要分开得让写据记下「最后写这一行的进程认得写据」(未闭项,MIGRATION 如实写)。
+ * 无地板时写据不参与判定;读口照样判形(读不出 = 坏体,不论地板)。写据的形只有一种读法({@link permissionModeWriteOf},续跑上下文读口经它判)。
  *
  * ## 为什么切档口必须经这只判官(而不是靠引擎的 deny 位)
  * 引擎在根腿上只认两只模式拒位(`RuntimeCaps.bypassPermissions` / `RuntimeCaps.autoMode`,本仓由 center 与本地 kill-switch 写);上面三问
@@ -26,6 +45,7 @@
  *    `foldedBy`(本判官把词改了的那一站;没改 ⇒ 缺席。① ② 都改了 ⇒ `entry_floor`:落定的词是地板给的)。
  */
 import type { PermissionMode } from "@sema-agent/core";
+import type { CheckpointCtx } from "./http/route-ctx.js";
 import { type Autonomy, type EntryPermissionMode } from "./runtime-governance.js";
 import { HOST_POSTURE_REFUSED_CODE, type TaskWriteFaceInput } from "./hosted-posture.js";
 import { type ParsedTaskSettings } from "./task-settings.js";
@@ -55,8 +75,8 @@ export type PermissionModeAdmission = {
 export declare function admitPermissionModeWord(word: PermissionMode | undefined, facts: PermissionModeAdmissionFacts): PermissionModeAdmission;
 /**
  * 提交口的入口一步(`http/admission.ts` 唯一调用;直调装配腿的测试夹具也调它 —— 少了这一步的体是部署上到不了的体):
- * 体上的词(顶层 `permissionMode` ?? bundle `settings.permissions.defaultMode`)过 {@link entryStep},本任务的 settings = 体上那一份;
- * 入口词盖进体(`task-settings.ts` `stampEntryPermissionMode`:地板在场时写顶层 `permissionMode`,缺席原物)。不拒 —— 托管一步在装配期判(见顶注「两口的调用形」)。
+ * 体上的词过 {@link bodyEntry};入口词盖进体(`task-settings.ts` `stampEntryPermissionMode`:地板在场时写顶层 `permissionMode`,缺席原物)。
+ * 不拒 —— 托管一步在装配期判(见顶注「三口的调用形」)。
  */
 export declare function stampSubmissionEntryMode<B extends {
     permissionMode?: unknown;
@@ -65,4 +85,53 @@ export declare function stampSubmissionEntryMode<B extends {
     readonly body: B;
     readonly entry: EntryPermissionMode;
 };
+/** 存储体顶层 `permissionMode` 那一格的写者闭集(顶注「写据」)。加一个写者 ⇒ 加一词;它默认不是任何地板的出口(失效关闭),要当出口必须改 {@link floorExitWriter} 的穷尽表。 */
+export declare const PERMISSION_MODE_WRITERS: readonly ["submission", "switch", "replay", "plan_review"];
+export type PermissionModeWriter = (typeof PERMISSION_MODE_WRITERS)[number];
+/**
+ * 写据:谁写了存储体顶层 `permissionMode` 那一格、写下的是什么(`mode` = 写完那一刻顶层的原值;缺席 = 那一格写完是空的,或不是引擎的模式词)。
+ * 每个写者都写自己的那一张(一条规则,不分写者);读者只在 `by` 是这块地板的出口时拿 `mode` 去对体顶层(绑定,见顶注)。
+ */
+export interface PermissionModeWrite {
+    readonly by: PermissionModeWriter;
+    readonly mode?: PermissionMode;
+}
+/**
+ * 一块入口地板的**出口写者** —— 存储体上由它写下的那一格,续跑口原样读(顶注「写据」)。闭集穷尽 switch:引擎的模式词表加一词 ⇒ 编译红,
+ * 逼着回答「这个词当地板时靠什么出口」。`plan` 的出口是人审(`plan_review` 的批准 / 编辑把计划带出 plan);其余五词今天不是任何档的地板
+ * (`runtime-governance.ts` `autonomyModeFloor` 只答 `plan` 或缺席),当地板也没有出口 ⇒ 缺席(失效关闭:比它松的词照钳)。
+ */
+export declare function floorExitWriter(floor: PermissionMode): PermissionModeWriter | undefined;
+/** 提交写者的那一张写据:`mode` = 这份要落盘的体顶层的原值(严格读;不是引擎的模式词 ⇒ 缺席)。调用点 = 两只构造口调用方(`http/submit-ctx.ts` `persistSubmissionCtx`、`leader/wire.ts` 的 worker 续跑体)。 */
+export declare function submissionPermissionModeWrite(body: {
+    readonly permissionMode?: unknown;
+}): PermissionModeWrite;
+/**
+ * **改写口**(唯一):把存储体顶层 `permissionMode` 那一格换成 `mode`,同一笔换上写者 `by` 的写据;其余位(含 bundle 拼法、无人值守标、写者版本)随行。
+ * 三个调用点:切档写回(`switch`)、续跑口的钳(`replay`,本模块 {@link stampReplayEntryMode})、`plan_review` 的出口写回(`plan_review`)。提交写者不经它(新行经构造口)。
+ */
+export declare function withStoredPermissionMode(ctx: CheckpointCtx, mode: PermissionMode, by: Exclude<PermissionModeWriter, "submission">): CheckpointCtx;
+/** {@link permissionModeWriteOf} 的结局:缺席 / 读得出 / 形不对(读口答坏体)。 */
+export type PermissionModeWriteReading = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "ok";
+    readonly write: PermissionModeWrite;
+} | {
+    readonly kind: "malformed";
+};
+/**
+ * 落盘写据(持久化 JSON,不信型面)的**唯一**读法:缺席 ⇒ `absent`;对象、键只在 `by` / `mode` 之内、`by` 在写者闭集里、`mode` 缺席或是引擎的模式词 ⇒ `ok`(交读法铸的那一份);
+ * 其余(不是对象、多键、`by` 不认得 —— 含更新版本加的写者、`mode` 在场却不是模式词)⇒ `malformed`。唯一调用方 = 续跑上下文读口(`http/resume-ctx-read.ts`:`malformed` ⇒ 坏体)。
+ */
+export declare function permissionModeWriteOf(stored: unknown): PermissionModeWriteReading;
+/**
+ * 续跑口的入口一步:一条停驻 run 的存储体被重放之前,体上的词过 {@link bodyEntry}(与提交口同一只,地板读此刻的活 config)。
+ *  · 地板缺席 ⇒ ctx **原物**(零字节变化;写据不被读);
+ *  · 写据说体顶层那一格是这块地板的出口写下的({@link floorExitWriter})、且 `mode` 仍等于顶层原值 ⇒ ctx **原物**(那一格已经过了地板);
+ *  · 其余 ⇒ 经改写口盖入口词、写据换成 `replay`(顶注「写据」:缺写据、别的写者写下的同字词、bundle 拼法、折出来的词都在这里)。
+ * 不拒:钳到地板放行,与提交口同形(见顶注「三口的调用形」)。入参是 ctx(写据是体的兄弟键)。
+ * 唯一调用点:`http/resume-legs.ts` 的 `replayCtxOf`(五个续跑读点同调;之后的存体预判、重建、plan_review 的模式词门与驱动段、CAS 赢点的写回读的都是它交回的那一份)。
+ */
+export declare function stampReplayEntryMode(ctx: CheckpointCtx, deployment: PermissionModeAdmissionFacts["deployment"]): CheckpointCtx;
 //# sourceMappingURL=permission-mode-admission.d.ts.map

package/dist/permission-mode-admission.js

@@ -1,6 +1,6 @@
 import { autonomyModeFloor, entryPermissionMode } from "./runtime-governance.js";
 import { HOST_POSTURE_REFUSED_CODE, permissionModeWriteFaceRefusal } from "./hosted-posture.js";
-import { foldDisableAutoMode, parseTaskSettings, requestedPermissionMode, stampEntryPermissionMode } from "./task-settings.js";
+import { coercePermissionModeStrict, foldDisableAutoMode, parseTaskSettings, requestedPermissionMode, stampEntryPermissionMode } from "./task-settings.js";
 export const PERMISSION_MODE_ADMISSION_FOLDS = ["entry_floor", "disable_auto_mode"];
 function entryStep(word, facts) {
     const folded = foldDisableAutoMode(word, facts.settings);
@@ -15,9 +15,62 @@ export function admitPermissionModeWord(word, facts) {
         return { kind: "refused", status: 422, code: HOST_POSTURE_REFUSED_CODE, message: why };
     return { kind: "admitted", requested: word, admitted: entry.effective, entry, ...(foldedBy !== undefined ? { foldedBy } : {}) };
 }
-export function stampSubmissionEntryMode(body, deployment) {
+function bodyEntry(body, deployment) {
     const settings = parseTaskSettings(body.settings).settings;
-    const { entry } = entryStep(requestedPermissionMode(body, settings), { deployment, settings });
+    return entryStep(requestedPermissionMode(body, settings), { deployment, settings }).entry;
+}
+export function stampSubmissionEntryMode(body, deployment) {
+    const entry = bodyEntry(body, deployment);
     return { body: stampEntryPermissionMode(body, entry), entry };
 }
+export const PERMISSION_MODE_WRITERS = ["submission", "switch", "replay", "plan_review"];
+export function floorExitWriter(floor) {
+    switch (floor) {
+        case "plan":
+            return "plan_review";
+        case "default":
+        case "acceptEdits":
+        case "auto":
+        case "bypassPermissions":
+        case "dontAsk":
+            return undefined;
+        default: {
+            const unhandled = floor;
+            throw new Error(`entry floor "${String(unhandled)}" has no exit arm`);
+        }
+    }
+}
+export function submissionPermissionModeWrite(body) {
+    const mode = coercePermissionModeStrict(body.permissionMode);
+    return { by: "submission", ...(mode !== undefined ? { mode } : {}) };
+}
+export function withStoredPermissionMode(ctx, mode, by) {
+    return { ...ctx, body: { ...ctx.body, permissionMode: mode }, permissionModeWrite: { by, mode } };
+}
+export function permissionModeWriteOf(stored) {
+    if (stored === undefined)
+        return { kind: "absent" };
+    if (typeof stored !== "object" || stored === null || Array.isArray(stored))
+        return { kind: "malformed" };
+    if (!Object.keys(stored).every((k) => k === "by" || k === "mode"))
+        return { kind: "malformed" };
+    const by = Object.hasOwn(stored, "by") ? stored["by"] : undefined;
+    const raw = Object.hasOwn(stored, "mode") ? stored["mode"] : undefined;
+    const writer = PERMISSION_MODE_WRITERS.find((w) => w === by);
+    if (writer === undefined)
+        return { kind: "malformed" };
+    if (raw === undefined)
+        return { kind: "ok", write: { by: writer } };
+    const mode = coercePermissionModeStrict(raw);
+    return mode === undefined ? { kind: "malformed" } : { kind: "ok", write: { by: writer, mode } };
+}
+export function stampReplayEntryMode(ctx, deployment) {
+    const { floor, effective } = bodyEntry(ctx.body, deployment);
+    if (floor === undefined || effective === undefined)
+        return ctx;
+    const write = ctx.permissionModeWrite;
+    if (write !== undefined && write.by === floorExitWriter(floor) && write.mode !== undefined && write.mode === ctx.body.permissionMode)
+        return ctx;
+    return withStoredPermissionMode(ctx, effective, "replay");
+}
 //# sourceMappingURL=permission-mode-admission.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -28,7 +28,7 @@
  *     先 `SELECT` 后 `UPDATE`(设计定稿 §4 原话)。
  *   - JSON 列(`card_json`/`decision_actor`)走 `dialectJsonEncoder`(TiDB verbatim `JSON.stringify`;
  *     PG 走 `pgSafeJsonStringify` 深度 sanitize——这两列是「已帽已洗后的投影」内容面 blob,不是像
- *     checkpoint 的 `tool_input` 那样跨信任边界做 hash 绑定的执行面字节,故用有损而非无损信封)。
+ *     checkpoint 列里待决动作的 `args` 那样跨信任边界做 hash 绑定的执行面字节,故用有损而非无损信封)。
  *
  * ── 施工偏离记录(设计定稿字面矛盾,未擅自改设计,如实记在这里 + 车1 最终汇报)──────────────────────
  *   - deriveAskId/deriveBatchId 的分隔符:设计定稿 §5 代码片段字面写 `.join(' ')`(单空格),但同一段
@@ -249,11 +249,17 @@ export interface AskTransitionPatch {
     provisional?: boolean;
     updatedAtMs: number;
 }
-export interface DecideAskInput {
+/**
+ * 一次人对一张卡的决定**落行的那一份记录** —— live 与停驻两形同一份、同一张列、同一只映射(SQL twin {@link SqlApprovalAskStore} 的 `decisionRecordValues`、
+ * 内存 twin 的 `applyDecisionRecord`):决议向 · 署名 · 理由 · 回决幂等键 · 出处两格(+ 决定时刻,店铸)。
+ * live 形随 `STREAM_PENDING → DECIDED` 那一笔单赢者 CAS 落({@link ApprovalAskStore.decideAsk});停驻形在停驻门受理之后落在仍 `PARKED` 的行上
+ * ({@link ApprovalAskStore.recordParkedDecision})。两形唯一的写者 = 协调器的回决写者(`ToolApprovalCoordinator.writeAskDecision`)。
+ */
+export interface AskDecisionRecord {
     decision: AskDecision;
     decisionActor?: unknown;
     decisionNote?: string | null;
-    /** 车4 §12-E:回决幂等键,赢 CAS 时随决议一起落列(见 `AskRow.idempotencyKey`)。缺席 ⇒ 列保持 NULL。 */
+    /** 车4 §12-E:回决幂等键,随决议一起落列(见 `AskRow.idempotencyKey`)。缺席 ⇒ 列 NULL。 */
     idempotencyKey?: string | null;
     /**
      * 🔴 [ref]:本次回决的**结算来源**,与决议同一条 UPDATE 落列 `settled_by`(语义/两态读法/为什么是
@@ -265,6 +271,9 @@ export interface DecideAskInput {
     settledBy?: HostSettledBy;
     /** core 7.61.0([ref]):`settledBy:"policy"` 旁的机器座位,与决议同一条 UPDATE 落列 `decided_via`(语义见 {@link AskRow.decidedVia});缺席 ⇒ 列 NULL。 */
     decidedVia?: DecidedVia;
+}
+/** live 形的决定 = 那份记录 + 随决议交给在等那条腿的编辑实参(停驻形的编辑走停驻门的绑定,不落问行)。 */
+export interface DecideAskInput extends AskDecisionRecord {
     /** [ref]:ctrl+g 编辑实参,与决议同一条 UPDATE 落列(语义三态见 {@link AskRow.updatedInput})。
      *  缺席 / `undefined` ⇒ 列 NULL(没带编辑);**`null` 是值**(编辑成 null),照存 JSON `"null"`。
      *  调用方纪律:deny 不传(店不替调用方判决议方向,写什么存什么)。 */
@@ -285,6 +294,18 @@ export type DecideResult = {
     reason: "batch_closed" | "ask_not_pending" | "idempotency_conflict";
     row: AskRow | null;
 };
+/**
+ * {@link ApprovalAskStore.recordParkedDecision} 的结局:`ok` ⇒ 落后的行;`ask_not_parked` ⇒ 行不在 / 不在 `PARKED` / 已出了门判过的属主域;
+ * `idempotency_conflict` ⇒ 这把键已被同 task 另一只问占着(UNIQUE `(task_id, idempotency_key)`)。`row` 与 {@link DecideResult} 同一只属主维投影。
+ */
+export type RecordParkedDecisionResult = {
+    ok: true;
+    row: AskRow;
+} | {
+    ok: false;
+    reason: "ask_not_parked" | "idempotency_conflict";
+    row: AskRow | null;
+};
 /**
  * 幂等键的入店卫生门(属主兜底轮 F2,三 twin 同判——SQL 双方言与 InMemory 都从这里过)。
  *
@@ -476,11 +497,16 @@ export declare function askRowOnCall(row: AskRow, call: AskCallCoordinate): bool
  * 🔴 [ref] —— **决议作用域的属主维**:这一行此刻带着的属主,是不是这次决议的门判过的那一位(逐字相等;`null` 只等于 `null`)。
  *
  * 律(一条):一次决议请求的作用域 = (ask, 批, **门判过的那位属主**)。属主的唯一来源是行上的 `owner` 列(铸行写定,只有 `/v1/adoption` 改写它);
- * 门(面表 `owner-faces.ts` 的 ask 两行:耐久回决口 `ask.decide` 属主 ∨ 无主 ∨ 运维、live 应答口 `ask.answer` 属主 ∨ 无主)照旧在门里判授权,本谓词**不复判授权**,只绑「门判的那一份属主事实」——
+ * 门(面表 `owner-faces.ts` 的 ask 两行:决断口 `ask.decide` 属主 ∨ 无主 ∨ 运维、按问读口 `ask.answer` 属主 ∨ 无主)照旧在门里判授权,本谓词**不复判授权**,只绑「门判的那一份属主事实」——
  * 门读行与 CAS 之间属主被改写,门的判断就不再是关于这一行的判断。于是这次请求拿到的**每一份**行读数(CAS 本身、CAS 输者的读数、
  * 提交歧义的确认读、幂等回放的命中)都过这一只:出域 = 缺席,门按缺席答(与行不在同体同码)。
  * InMemory twin 的判定、SQL twin 输者读数的投影、两扇门的确认读读同一只;SQL twin 的 UPDATE 谓词是它的方言镜像({@link decideOwnerWhere})。
  */
+/** {@link ApprovalAskStore.listAsksAtGate} 的行判据(三 twin 的出口对齐与 InMemory 内核同调这一只)。 */
+export declare function askAtGate(r: AskRow, sourceSessionId: string, binding: {
+    readonly boundCallId: string;
+    readonly boundInputHash: string;
+}): boolean;
 export declare function askRowCarriesOwner(row: AskRow | null, owner: string | null): row is AskRow;
 /** [ref]:决议输者读数的投影(三 twin 共用一份):行出了这次决议的属主域 ⇒ 读作缺席,不交出别人的行。 */
 export declare function projectDecideReading(row: AskRow | null, owner: string | null): AskRow | null;
@@ -513,6 +539,15 @@ export interface ApprovalAskStore {
      * 缺省等于不绑属主,安全轴上那是静默放行。
      */
     decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * **停驻形的人决落行**(一张卡一条记录:停驻卡的决定记在它的问行上,行仍 `PARKED`)—— 停驻门(checkpoint 上的那道门,单赢者是续跑腿的门 CAS)
+     * **已经受理**这次决定之后,把它的记录({@link AskDecisionRecord})落到这只问的行上。态不变:停驻形的终局恒是那道门,不是这一笔。
+     * 谓词 = 行在 ∧ `state = 'PARKED'` ∧ 门判过的那位属主还在行上([ref],与 {@link decideAsk} 同一只属主维)。
+     * **覆写**:门被引擎重开(同一把 token 翻回待决、世代号前进)之后又被受理的那一次再落一次 —— 记录恒是「门上此刻站着的那次决定」的那一份
+     * (决议向、谁、带哪把键);读者只在门已决时认它(`ToolApprovalCoordinator` 的停驻形读法)。
+     * 唯一调用方 = 协调器的回决写者,只在赎回席 2xx 之后调。三 twin 同答。
+     */
+    recordParkedDecision(askId: string, owner: string | null, record: AskDecisionRecord): Promise<RecordParkedDecisionResult>;
     /**
      * [ref]:原子终局 claim —— 把「争终局」与「读真相」并成**一次**店往返(胜负判定与败方 `current` 读数
      * 在同一原子单元内,语义见 {@link AskTerminalClaimOutcome})。[ref]-R1 的病根「CAS 与读真相是两次店
@@ -587,6 +622,21 @@ export interface ApprovalAskStore {
      * 行数随在途停驻,不随账本总量)。三 twin 同答:SQL twin 读后按发起会话逐字再滤一遍(MySQL 协议 VARCHAR 等值的 PAD SPACE,与 `listByCall` 同一条出口对齐)。
      */
     listParkingBySourceSession(sourceSessionId: string): Promise<AskRow[]>;
+    /**
+     * 「这道停驻门属于哪只问」:发起会话(列 `source_task_id`)= 给定会话,且 ① `state = 'PARKED'` ∧ 门上的绑定对(`gate_bound_call_id` / `gate_bound_input_hash`,收敛器
+     * 按停驻行的「同调用 ∧ 同展示入参摘要」绑上的那一对)逐字等于给定的一对,或 ② `state = 'PARKING'`(收敛器还没绑上)∧ 这只问自己的调用 id 与展示入参摘要
+     * (`tool_call_id` / `bound_input_hash`,收敛器绑定判的就是这两格)逐字等于给定的一对 —— 同一只问在绑定前后都是同一行、同一份 `card_json`,两个读者跨过绑定那一拍同答。按绑定对而不是令牌:运维队列行与续跑腿两个读者手里都有这一对
+     * (队列行不带令牌),同一个问题一个键、一只读口。
+     * 停驻行陈述的会话 = 铸它的那条腿的会话 = 同一次调用的问的发起会话(委派 / 后台子代 = 子代自己的会话;行上的 `sessionId` 记的是投递上下文,不是这一格)。
+     * 两个消费者(同一只协调器读口):续跑腿的规则记录读者(`http/resume-legs.ts`)与运维队列行的候选投影(`routes/approvals-assistant.ts`)—— 有问行的停驻卡读问行、
+     * 没有读停驻行;恰好一行才是这张卡的记录,零行 = 直停驻卡,多行 = 读不出记录(两个读者同答 fail-closed)。
+     * 不带租户门(内部读口,不上 wire;调用方已复核过停驻行的属主,记录读者再比一次行属主)。索引走既有 `idx_ask_source_session (source_task_id)`;零 DDL。
+     * 三 twin 同答:SQL twin 读后按发起会话与令牌逐字再滤一遍(MySQL 协议 VARCHAR 等值的 PAD SPACE,与 `listByCall` 同一条出口对齐)。
+     */
+    listAsksAtGate(sourceSessionId: string, binding: {
+        readonly boundCallId: string;
+        readonly boundInputHash: string;
+    }): Promise<AskRow[]>;
     getAsk(askId: string): Promise<AskRow | null>;
     /** 回决幂等回放的读口。🔴 `taskId` **必填**且是键的第一维——UNIQUE 已改 `(task_id, idempotency_key)`
      *  (车4 §12-E),裸按 key 全局查在多租户库上既可能回**别人 task** 的行(存在性外泄),也可能在同 key
@@ -751,6 +801,17 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     ensureAsk(row: NewAskRow): Promise<EnsureAskResult>;
     transitionAsk(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
+    /**
+     * 一份决定记录({@link AskDecisionRecord})的前五格列值,序 = `decision, decision_actor, decision_note, settled_by, decided_via` ——
+     * live 形({@link decideAsk})与停驻形({@link recordParkedDecision})两条 UPDATE 共用这**一只**映射(一个事实一处铸列值)。
+     */
+    private decisionRecordValues;
+    /**
+     * 停驻形的人决落行(接口契约见 {@link ApprovalAskStore.recordParkedDecision})。单条 UPDATE,谓词 `state='PARKED'` + 属主维([ref] 的同一只方言镜像);
+     * `rev = rev + 1` 照 CAS 铁则②(MySQL 同值 UPDATE 的 affectedRows=0 坑:覆写同一份记录时列值可以逐字节相同)。
+     * `(task_id, idempotency_key)` 撞键 ⇒ typed 臂 `idempotency_conflict`(方言错误不出店,与 `decideAsk` 同一只判别)。
+     */
+    recordParkedDecision(askId: string, owner: string | null, record: AskDecisionRecord): Promise<RecordParkedDecisionResult>;
     /**
      * [ref] 原子终局 claim(接口契约见 {@link ApprovalAskStore.claimTerminal};类型语义见
      * {@link AskTerminalClaimOutcome})。expire 意图 = 既有 `expireAsk` 事务**原体**(步⓪-③ 逐字保留,
@@ -791,6 +852,10 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
     listByCall(call: AskCallCoordinate): Promise<AskRow[]>;
     listParkingBySourceSession(sourceSessionId: string): Promise<AskRow[]>;
+    listAsksAtGate(sourceSessionId: string, binding: {
+        readonly boundCallId: string;
+        readonly boundInputHash: string;
+    }): Promise<AskRow[]>;
     getAsk(askId: string): Promise<AskRow | null>;
     getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
     deferReconcile(askId: string, expectedState: AskState, expectedRev: number, nowMs: number): Promise<boolean>;