@sema-agent/server 7.150.0 → 7.151.0

package/dist/terminal.js

@@ -1,10 +1,11 @@
 import { writeLogText } from "./observability/logger.js";
 import { terminalProjection } from "@sema-agent/core";
-import { errorCodeOf } from "./observability/err-text.js";
+import { errorCodeOf, errorMemberOf } from "./observability/err-text.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { redactSecrets } from "./trace/redact.js";
 import { seatText } from "./trace/exit-seat.js";
-import { storeFaultSentenceOfCode } from "./plugins/store-fault.js";
+import { STORE_FAULT_CLASSES, StoreBoundaryFault, outwardStoreSentence, storeFaultClassOf } from "./plugins/store-fault.js";
+import { errorOriginOf } from "./plugins/error-origin.js";
 import { readDenyFloorRefusalMessage, readDenyFloorSummaryOf } from "./read-deny-floor-notice.js";
 export function failureCodeOf(terminal) {
     return terminal.kind === "failed" ? terminal.code : undefined;
@@ -93,10 +94,13 @@ function foldCauseCode(terminal, at) {
 function outwardStoreFailure(code, message, at) {
     const outward = outwardFailureCode(code);
     reportFold(code, outward, message, at);
-    return { code: outward, message: outwardStoreMessage(code) };
+    return { code: outward, message: outwardStoreMessageOf(code, message) };
 }
-function outwardStoreMessage(code) {
-    return `${storeFaultSentenceOfCode(code)} [original code: ${code}]`;
+export function outwardStoreMessageOf(code, message) {
+    return isOutwardStoreSentence(message, code) ? message : outwardStoreSentence(storeFaultClassOf({ code }), code);
+}
+function isOutwardStoreSentence(message, code) {
+    return typeof message === "string" && STORE_FAULT_CLASSES.some((cls) => message === outwardStoreSentence(cls, code));
 }
 export function outwardThrownMessage(err, message) {
     const code = errorCodeOf(err);
@@ -104,6 +108,123 @@ export function outwardThrownMessage(err, message) {
         return message;
     return outwardStoreFailure(code, message, "exit").message;
 }
+export function storeBoundaryFault(err, site) {
+    if (err instanceof StoreBoundaryFault)
+        return err;
+    const origin = errorOriginOf(err);
+    switch (origin) {
+        case "caller":
+            return err;
+        case "driver":
+        case undefined:
+            break;
+        default: {
+            const unhandled = origin;
+            throw new Error(`store boundary: unknown error origin ${String(unhandled)}`);
+        }
+    }
+    if (isTypedFailure(err))
+        return rewriteDriverCause(err, site) ? err : reportedBoundaryForm(err, site);
+    if (!carriesDriverFault(err))
+        return err;
+    return reportedBoundaryForm(err, site);
+}
+const CAUSE_CHAIN_DEPTH = 8;
+function boundaryFormOf(err) {
+    const coded = driverCodeOf(err);
+    return new StoreBoundaryFault(storeFaultClassOf(err), coded.code, coded.errno);
+}
+function reportBoundary(err, fault, site) {
+    reportFold(fault.code, fault.code === undefined ? "-" : outwardFailureCode(fault.code), errorMemberOf(err, "message"), { at: "store", site, faultClass: fault.faultClass, layers: chainSentences(err) });
+}
+function reportedBoundaryForm(err, site) {
+    const fault = boundaryFormOf(err);
+    reportBoundary(err, fault, site);
+    return fault;
+}
+function isTypedFailure(err) {
+    const code = errorMemberOf(err, "code");
+    return typeof code === "string" && code !== "" && outwardFailureCode(code) === code && errorOriginOf(err) !== "driver";
+}
+function carriesDriverFault(err) {
+    const coded = driverCodeOf(err);
+    return (coded.code !== undefined && outwardFailureCode(coded.code) !== coded.code) || driverOriginOnChain(err) || causeChainBeyondDepth(err);
+}
+function causeChainBeyondDepth(err) {
+    let cur = err;
+    for (let depth = 0; depth < CAUSE_CHAIN_DEPTH; depth++) {
+        if (cur === null || typeof cur !== "object")
+            return false;
+        cur = errorMemberOf(cur, "cause");
+    }
+    return cur !== null && typeof cur === "object";
+}
+function rewriteDriverCause(top, site) {
+    let parent = top;
+    for (let depth = 0; depth < CAUSE_CHAIN_DEPTH; depth++) {
+        const cur = errorMemberOf(parent, "cause");
+        if (cur === null || typeof cur !== "object" || cur instanceof StoreBoundaryFault || errorOriginOf(cur) === "caller")
+            return true;
+        if (isTypedFailure(cur)) {
+            parent = cur;
+            continue;
+        }
+        if (!carriesDriverFault(cur))
+            return true;
+        const fault = boundaryFormOf(cur);
+        if (!Reflect.defineProperty(parent, "cause", { value: fault, writable: true, configurable: true, enumerable: false }))
+            return false;
+        reportBoundary(cur, fault, site);
+        return true;
+    }
+    return false;
+}
+let storeBoundaryObserver;
+export function setStoreBoundaryObserver(fn) {
+    storeBoundaryObserver = fn;
+}
+function driverCodeOf(err) {
+    let cur = err;
+    let fallback;
+    let errnoLink;
+    for (let depth = 0; cur !== null && typeof cur === "object" && depth < CAUSE_CHAIN_DEPTH; depth++) {
+        const code = errorMemberOf(cur, "code");
+        const errno = errorMemberOf(cur, "errno");
+        const integerErrno = typeof errno === "number" && Number.isInteger(errno) ? errno : undefined;
+        if (typeof code === "string" && code !== "") {
+            const link = { code, ...(integerErrno !== undefined ? { errno: integerErrno } : {}) };
+            if (code !== "unknown")
+                return link;
+            fallback ??= link;
+        }
+        if (integerErrno !== undefined)
+            errnoLink ??= { code: String(integerErrno), errno: integerErrno };
+        cur = errorMemberOf(cur, "cause");
+    }
+    return fallback ?? errnoLink ?? {};
+}
+function driverOriginOnChain(err) {
+    let cur = err;
+    for (let depth = 0; cur !== null && typeof cur === "object" && depth < CAUSE_CHAIN_DEPTH; depth++) {
+        if (errorOriginOf(cur) === "driver")
+            return true;
+        cur = errorMemberOf(cur, "cause");
+    }
+    return false;
+}
+function chainSentences(err) {
+    const layers = [];
+    let cur = err;
+    for (let depth = 0; cur !== null && typeof cur === "object" && depth < CAUSE_CHAIN_DEPTH; depth++) {
+        const message = errorMemberOf(cur, "message");
+        if (typeof message === "string" && message !== "")
+            layers.push(seatText("operator-log-text", message));
+        cur = errorMemberOf(cur, "cause");
+    }
+    if (layers.length === 0 && typeof err === "string" && err !== "")
+        layers.push(seatText("operator-log-text", err));
+    return layers.join(" | cause: ");
+}
 function foldAttemptCodes(attempts, at) {
     if (!Array.isArray(attempts))
         return attempts;
@@ -123,15 +244,24 @@ function foldAttemptCodes(attempts, at) {
     return folded ?? attempts;
 }
 const STORED_RESULT_FOLD_TAG = "server.terminal.stored-result-code-folded";
-function reportFold(code, outward, message, at) {
+function reportFold(code, outward, message, sighting) {
     const messageBytes = typeof message === "string" ? Buffer.byteLength(message, "utf8") : 0;
-    const fields = `original=${isCodeToken(code) ? code : "<not-a-code>"} outward=${outward} messageBytes=${messageBytes} at=${at}`;
+    const at = typeof sighting === "string" ? sighting : sighting.at;
+    const original = code === undefined ? "<uncoded>" : isCodeToken(code) ? code : "<not-a-code>";
+    const fields = `original=${original} outward=${outward} messageBytes=${messageBytes} at=${at}`;
     switch (at) {
         case "exit": {
             const sentence = typeof message === "string" && message !== "" ? ` message=${JSON.stringify(seatText("operator-log-text", message))}` : "";
             writeLogText("stderr", `[terminal] outward_failure_code_folded ${fields}${sentence}`);
             return;
         }
+        case "store": {
+            const where = sighting;
+            const layers = where.layers !== "" ? ` message=${JSON.stringify(where.layers)}` : "";
+            writeLogText("stderr", `[terminal] outward_failure_code_folded ${fields} site=${where.site} class=${where.faultClass}${layers}`);
+            storeBoundaryObserver?.(where.site, where.faultClass);
+            return;
+        }
         case "run.result":
         case "ev.done.result":
             recordFailOpen(STORED_RESULT_FOLD_TAG, fields);
@@ -160,7 +290,7 @@ function outwardProjection(terminal, at) {
         const presented = at === "exit" && plane.status === "failed" ? readDenyFloorRefusalMessage(plane.errorCode) : undefined;
         return presented === undefined ? plane : { ...plane, errorMessage: presented };
     }
-    return plane.status === "failed" ? { ...plane, errorCode: outward, errorMessage: outwardStoreMessage(plane.errorCode) } : { ...plane, errorCode: outward };
+    return plane.status === "failed" ? { ...plane, errorCode: outward, errorMessage: outwardStoreMessageOf(plane.errorCode, plane.errorMessage) } : { ...plane, errorCode: outward };
 }
 export function nestedPauseOf(terminal) {
     return terminal.kind === "failed" ? terminal.nestedPause : undefined;
@@ -200,7 +330,7 @@ export function persistedPlaneOf(result) {
     return {
         ...(typeof r.status === "string" ? { status: r.status } : {}),
         ...(typeof r.errorCode === "string" ? { errorCode: outwardFailureCode(r.errorCode) } : {}),
-        ...(typeof r.errorMessage === "string" ? { errorMessage: flatFolded && typeof r.errorCode === "string" ? outwardStoreMessage(r.errorCode) : r.errorMessage } : {}),
+        ...(typeof r.errorMessage === "string" ? { errorMessage: flatFolded && typeof r.errorCode === "string" ? outwardStoreMessageOf(r.errorCode, r.errorMessage) : r.errorMessage } : {}),
         ...(typeof r.blockedReason === "string" ? { blockedReason: r.blockedReason } : {}),
     };
 }

package/dist/tool-approval.d.ts

@@ -6,7 +6,7 @@ import { type CardRulePersisted, type RuleConsentLane } from "./rules-consent.js
 import type { GateCurrencyStore } from "./approval-gate-currency.js";
 import { type HitlTransport } from "./hitl-delivery.js";
 import { type AllowRuleShadowProjection, type DenialLimitFallback, type RuleOffersAbsence, type ApprovalRequestFrame, type ApprovalRevokeFrame, type ApprovalCardLegFrame, type ApprovalCompleteFrame, type RuleEvidenceProjection } from "./approval-card.js";
-import { type ApprovalAskStore, type AskRow } from "./plugins/approval-ask-store-sql.js";
+import { type ApprovalAskStore, type AskDecision, type AskDecisionRecord, type AskRow, type DecideResult, type RecordParkedDecisionResult } from "./plugins/approval-ask-store-sql.js";
 import type { ApprovalAskAuditSink } from "./approval-ask-audit-store.js";
 import { type AskRowEndingCause, type SettleCause, type SettleOutcome } from "./approval-deny-reasons.js";
 import type { ParkCommitWatch } from "./plugins/park-commit-watch.js";
@@ -36,7 +36,7 @@ export declare const MAX_ALLOW_SESSIONS = 4096;
 export declare function approvalDecidePath(sessionId: string): string;
 /**
  * 一只转停驻的问**去哪只会话决** —— 它的停车行(检查点卡)落在哪只会话上,耐久回决口 `POST /v1/approvals/:sessionId/decide` 就按这只会话找卡(卡自己的会话,
- * 决断口的地址;不是卡归属的 run 会话 —— cascade 级上的卡归调用方的 run,却只能在级自己的会话上决)。三处同读这一只:决断口对 PARKED 行的 `410 gone.ask_parked`
+ * 决断口的地址;不是卡归属的 run 会话 —— cascade 级上的卡归调用方的 run,却只能在级自己的会话上决)。三处同读这一只:决断口对 PARKED 行在这台部署交不了停驻赎回时(直连门)的 `410 gone.ask_parked`
  * 回显、迟到回决口对 PARKING 行的 `202` 与按问读口 `parked` 的 `decidePath`。
  * 停车行落在**铸它那条腿**的会话上 = 行上的发起会话 `sourceSessionId`(core 铸停车行的 `sessionId` 与铸这一问的发起会话是同一只变量;根腿 = 行上的会话,
  * 委派 / 后台子代腿 = 子代自己的会话,不是行上记的投递会话):
@@ -93,6 +93,14 @@ export type ToolApprovalReadBody = ({
     state: "void";
     cause?: AskRowEndingCause;
 } & AskRowReadProjection);
+/** 一条行的**可读决议**(权威四合取:二值 ∧ 非 provisional ∧ 有 `decidedAtMs` ∧ 态确为 DECIDED;四合取各自的来由见耐久决断口 `decidedRowIsAuthoritative`
+ *  的顶注)。**这是那只判据的唯一读法** —— 读口、晚答口、唯一写者的迟到臂、耐久决断口的守卫都读它。读不出 ⇒ `undefined`(各口按「不是一条可用的人的决议」
+ *  处置,绝不把坏行包装成首决交出去)。 */
+export declare function decidedRowFacts(row: AskRow): {
+    decision: "allow" | "deny";
+    decidedAtMs: number;
+    decisionNote?: string;
+} | undefined;
 /**
  * 结算一张卡的**判决** —— 判别联合,逼每个调用点说清「这次等待是怎么结束的」:
  *  · `by:"human"` —— 一次**决议**到了(人答,或从问账行读回来的决议,含部署政策拒落成的 `DECIDED` 行,`hostSource` 记它的来源词与机器座位):`allowed` 说方向;审计 settle 行
@@ -169,10 +177,71 @@ export interface ParkedAskRedeemRequest {
      *  **checkpoint 当下的 scope** 对一次(codex R1-[high] 一:收编改写身份之后,任何缓存的属主判据都
      *  过期;门必须贴在当下的持久事实上)。 */
     principal?: string;
+    /** 调用方的**运维身份**(交来这一问的那扇门已判过的那一格;[ref] α):席复核 checkpoint 当下的 scope、续跑腿复核载入行时按它读面表 `scope.decide` 的运维列。
+     *  耐久决断口 = 它的面表 `ask.decide` 运维列读到的那位(显式运维代决别人的卡,live 与停驻两形同放);应答口恒 `false`(面表 `ask.answer` 没有运维列)。
+     *  必填:缺省等于替门作答「不是运维」或「是运维」—— 两个方向都是同一扇门对两形说两种话。 */
+    operator: boolean;
     /** 发起本次 respond 的真实 HTTP 请求。赎回腿据它做准入解析与舰队 scope(与 `/decide` 腿同姿势);
      *  缺席 ⇒ 那条腿按「无请求」形处置(它自己的成文语义,本席不替它决定)。 */
     httpReq?: IncomingMessage;
 }
+/**
+ * 一次对停驻卡的决定 —— 两扇门(应答口 PARKED 臂、耐久决断口)交给**同一只**赎回(`ToolApprovalCoordinator` 的 `runParkedFlight`)的那一份。
+ * 门各自已过属主门、把自己的词映进来:`write` = 这次决定的记录(决议向 · 出处 · 理由 · 署名 · 键 —— 停驻门受理之后落在问行上的就是它),其余是停驻门要的余项。
+ */
+export interface ParkedDecisionRequest {
+    readonly write: AskDecisionWrite;
+    /** 「本会话放行」(应答口的 `allow_session`;与 `/decide` 的 `remember:"session"` 同一只请求、同一个铸点)。耐久决断口的体今天没有这一位(随 live 词表一起收)。 */
+    readonly remember?: "session";
+    /** 「不再询问」的规则位(应答口体上的 `persistRule`;素材取行,{@link ToolApprovalCoordinator} 的 `persistRuleFromRow`)。耐久决断口的体今天没有这一位。 */
+    readonly persistRule?: ParsedPersistRule;
+    /** ctrl+g 编辑实参(只 approve 交给门的绑定;不落问行)。 */
+    readonly updatedInput?: unknown;
+    readonly principal?: string;
+    /** 见 {@link ParkedAskRedeemRequest.operator}(同一格,原样交席)。 */
+    readonly operator: boolean;
+    /** 要人门([ref])的判词,由口按这张卡与决定者位判好交来(`true` ⇒ 这一形的放行不归策略答)。只在「这一次要写」时读:门上已站着决定 ⇒ 先回放 / 冲突。 */
+    readonly policyMayNotApprove?: boolean;
+    readonly httpReq?: IncomingMessage;
+}
+/** 耐久决断口对一只停驻的问拿到的答案(`ToolApprovalCoordinator.decideParkedAsk`;口按自己的 wire 律渲染,与 `DECIDED` 行同一条回放 / 冲突律)。 */
+export type ParkedAskAnswer = 
+/** 本次请求被停驻门受理(赎回席的受理恒是 `200`:`acceptedResumingReceipt` 一只铸点;`body` = 那只受理体;`recorded` = 受理之后落了记录的那一行,没落成 ⇒ 缺席)。 */
+{
+    readonly kind: "accepted";
+    readonly body: Record<string, unknown>;
+    readonly recorded?: AskRow;
+}
+/** 没生效(门 / 席 / 准入的拒,原样)。 */
+ | {
+    readonly kind: "refused";
+    readonly status: number;
+    readonly body: Record<string, unknown>;
+}
+/** 门上已站着一次决定(向 / 时刻 / 理由取门;署名取行上的记录 —— 只在记录说的就是门上这一向时;`byThisRequest` = 本次请求的键就是记录上那把)。 */
+ | {
+    readonly kind: "standing";
+    readonly decision: AskDecision;
+    readonly decidedAtMs: number;
+    readonly decisionNote?: string;
+    readonly actor?: unknown;
+    readonly byThisRequest: boolean;
+}
+/**
+ * 这台部署上停驻形**只有耐久审批门收**:赎回席没接(直连门部署 —— 停驻门的决定要签名信封,而这扇口没有决策证明;fail-closed,接线处 `boot/late-binds.ts`),
+ * 或行上没有门坐标(受损行,没有门可交)。口按自己的词指路那道门。
+ */
+ | {
+    readonly kind: "gate_only";
+}
+/** 重判那一读读不出 / 行已不在门判过的属主域(门读之后被收编改写)⇒ 与查无同答(口按自己的词)。 */
+ | {
+    readonly kind: "gone";
+}
+/** 要写的是一次策略对要人的卡的放行(`ParkedDecisionRequest.policyMayNotApprove`)⇒ 写之前拒(口按自己的词;与 live 形同一道门、同一个位置)。 */
+ | {
+    readonly kind: "policy_refused";
+};
 /** [ref]:赎回席的结局 = 赎回腿的原始 HTTP 结果面 + 请求带了 `remember` 时铸点的真答(`rememberApplied`:落没落;不进 `body` —— 首次受理的回执挂它,
  *  受理回执(幂等回放的那一份)不存它)。 */
 export interface ParkedAskRedeemResult {
@@ -1017,6 +1086,35 @@ export declare function parseToolApprovalResponse(body: unknown): ParsedToolAppr
     ok: false;
     error: string;
 } & Partial<RetiredDecisionKeyFacts["extra"]>);
+/**
+ * **一次人对一张卡的决定** —— 两扇门(live 应答口 `POST /v1/tool-approvals/:id/respond`、耐久决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`)
+ * 两形(live / 停驻)落行的唯一入参形;{@link ToolApprovalCoordinator.writeAskDecision} 是它唯一的写者,{@link askDecisionRecordOf} 是它到店记录的唯一映射。
+ * `actor` = 耐久决断口铸的署名(审计投影,恒由已验证主体派生;应答口不铸,列 NULL);`idempotencyKey` = 耐久决断口的回决幂等键(应答口没有这一位)。
+ */
+export interface AskDecisionWrite {
+    readonly decision: AskDecision;
+    readonly decider: ApprovalDecider;
+    readonly note?: string;
+    readonly actor?: unknown;
+    readonly idempotencyKey?: string;
+}
+/** live 形的决定另带 ctrl+g 编辑实参(`undefined` = 没带;**`null` 是值**,语义三态的属主 = `AskRow.updatedInput`):随决议同一条 CAS 落列、交给在等的那条腿。
+ *  停驻形的编辑走停驻门的绑定(`DecideBinding.updatedInput`),不落问行。 */
+export interface LiveAskDecisionWrite extends AskDecisionWrite {
+    readonly updatedInput?: unknown;
+}
+/** 一张卡的人决落在哪一形上:live = `STREAM_PENDING → DECIDED` 的单赢者 CAS(带批维);停驻 = 停驻门受理之后落在仍 `PARKED` 的行上。 */
+export type AskDecisionForm = {
+    readonly kind: "live";
+    readonly batchId: string;
+} | {
+    readonly kind: "parked";
+};
+/**
+ * {@link AskDecisionWrite} → 店的那份记录({@link AskDecisionRecord})—— **唯一映射**(两形同读)。出处两格经同步座映射 {@link liveHostSource}
+ * (`person` ⇒ 不写 = 列 NULL = 人决;`policy` ⇒ `"policy"` + 座位),理由空 ⇒ NULL,署名 / 键缺席 ⇒ NULL。
+ */
+export declare function askDecisionRecordOf(write: AskDecisionWrite): AskDecisionRecord;
 /**
  * [ref] R-13 C —— `UNATTENDED_APPROVAL_POLICY` 的**闭集**词表([ref]Q1「裁2:A+C」/[ref] 裁②)。
  *
@@ -1378,9 +1476,9 @@ export declare class ToolApprovalCoordinator {
     /** [ref] F4:悬挂决议轮询腿的**轮转游标**(整数偏移,与集合成员无关 —— 理由见
      *  `pollSuspendedDecisions` 里那段:按 askId 记的形会在「上一拍最后碰的那条被结算掉」时塌回队首,
      *  构造出永久饥饿的前缀)。只回答「上一拍扫到第几个」,单调推进、按当前长度取模。 */
-    private suspendedPollOffset;
-    /** [ref]:悬挂轮询腿第二层(接管登记)的轮转游标 —— 与 {@link suspendedPollOffset} 同一条理由,两层各一只。 */
-    private adoptedPollOffset;
+    private readonly suspendedPollCursor;
+    /** [ref]:悬挂轮询腿第二层(接管登记)的轮转游标 —— 与 {@link suspendedPollCursor} 同一条理由,两层各一只。 */
+    private readonly adoptedPollCursor;
     /** [ref] + codex R3-[critical]:askId → **此刻正带着 `updatedInput` 决它的请求数**(见
      *  {@link markEditedDecisionInFlight} 顶注)。只在 `decideAsk` 那一次调用期间非空,故天然有界。 */
     private readonly editedDecisionsInFlight;
@@ -2158,7 +2256,7 @@ export declare class ToolApprovalCoordinator {
      * 同向迟到答与**反向**迟到答同判:都是 200 回放**首决**。反向不是 409、不是报错、更不改判 —— 那是
      * 一个 CAS 败者的诚实答:决议早已由首决落定,这次请求只是晚到,响应体把首决交回去,消费端自判向。
      *
-     * 权威性四合取与 durable 回决腿的 `decidedRowIsAuthoritative` **同判据**(那处顶注是唯一真源):
+     * 权威性四合取 = {@link decidedRowFacts}(唯一读法;四合取的来由见 durable 回决腿 `decidedRowIsAuthoritative` 的顶注):
      * 决议二值 ∧ 非 provisional ∧ 有 `decidedAtMs` ∧ 态确为 DECIDED。不合形 ⇒ 退回修前 404(绝不把一条
      * 坏行包装成「人的首决」交出去);此处比那条腿更保守地不铸 500,理由是本腿的客户端是壳上那张卡,
      * 它对 404 有成文处置(消卡),对 500 没有。
@@ -2175,6 +2273,27 @@ export declare class ToolApprovalCoordinator {
      * 非 2xx 原样透出(gate 被别人收走 ⇒ 409 等),绝不粉饰成受理。
      */
     private redeemParkedAsk;
+    /**
+     * 🔴 **停驻卡的那一只赎回**(两扇门同一只;[ref] α):准入 → 开格(单飞句柄)→ 一飞(赎回席 → 落行 → 规则位)→ 收格 / 留回执。
+     * 两扇门各自先过自己的属主门、把这一问的词映成 {@link ParkedDecisionRequest},然后都交这里 —— 计费 / 就绪 / 服务凭据三道门、checkpoint 当下的 scope 复核、
+     * 「本会话放行」的铸点、规则位的兑付、决定的落行,一处一份。
+     *
+     * 句柄内的序是硬的(与 live 腿同一条纪律):赎回席非 2xx ⇒ 什么都不落(一次没生效的决定不留记录、不留规则);2xx ⇒ **先**落行(停驻卡的决定记在它的问行上,
+     * 唯一写者 {@link writeAskDecision} 的停驻形),**再**兑规则位。两件都在句柄之内:单飞的后到者 `await` 的就是这枚句柄,它拿到的答案与行上的记录同时成立。
+     * 落行失败(店错 / 超时 / 键被同 task 另一只问抢先占了)不改判:这次决定已经被停驻门受理、续跑已经开始 —— 记一笔 fail-open(登记 tag),回执照常;
+     * 代价是这一问的耐久回放(同键重发)读不到这把键,重发不是回放(店错 ⇒ 首决回显的冲突句;键被另一只问占着 ⇒ 决断口幂等预查的跨问冲突句)。
+     */
+    private runParkedFlight;
+    /** 停驻门受理之后落行(唯一写者的停驻形)。落成 ⇒ 落后的行;没落成 ⇒ `undefined` + 一笔 fail-open(这次决定照常生效,见 {@link runParkedFlight} 顶注)。 */
+    private recordParkedOutcome;
+    /**
+     * 🔴 **耐久决断口对一只停驻的问**([ref] α:留下的那扇口吃下停驻形;此前这里答 `410 gone.ask_parked` 指路 `/decide`)。属主门 `ask.decide` 与体门在调用方
+     * (`routes/runs.ts`)已过;要人门的判词由调用方判好交进来({@link ParkedDecisionRequest.policyMayNotApprove}),这里在「这一次要写」时用。停驻形的两件:
+     *  ① **门上已站着一次决定吗**({@link standingParkedDecision}:读停驻门 + 行上的记录)⇒ 站着 ⇒ 交回它(调用方按与 `DECIDED` 行同一条律答:同键 ⇒ 200 回放;否则 409 首决回显)。
+     *  ② 没站着(门仍开着 —— 从没被决过,或被引擎重开过)⇒ 交**同一只**赎回({@link runParkedFlight}),受理后决定落行。
+     * 判只在本副本上没有这只问的赎回在飞时做(有 ⇒ 等它落定、从头再读再判);赎回没生效而门此刻已决 ⇒ 也从头再判(答案是门上那一次)。不读应答口的进程内回执:本口的回放律读行 + 门。
+     */
+    decideParkedAsk(store: ApprovalAskStore, row: AskRow, request: ParkedDecisionRequest, idempotencyKey: string | undefined): Promise<ParkedAskAnswer>;
     /**
      * [ref] —— **durable 回决腿的规则位**:PARKED 行的迟到决议携 `persistRule` 时,用**行上**的素材兑付。
      *
@@ -2223,6 +2342,21 @@ export declare class ToolApprovalCoordinator {
      * 放行凭空消失。诚实的形是 200 + `rulePersisted:false`(壳据它告诉人「这次放行了,但『不再询问』没存上」)。
      */
     private persistRuleAfterDecision;
+    /**
+     * 🔴 **一张卡的人决的唯一写者**(两扇门 × 两形同一只;店上两只动词 `decideAsk` / `recordParkedDecision` 在 src 里只有这里调 —— 钉 `test/ask-decision-single-writer.test.ts`)。
+     *  · live 形:`STREAM_PENDING → DECIDED` 的单赢者 CAS(批维 + [ref] 属主维),套墙钟上限;**迟到的成功**(这次调用报了超时,决议其实落了盘)⇒
+     *    行过了权威四合取({@link decidedRowFacts})才把同 askId 下还挂着的本地条目按**行**结清(结算取行,[ref]),不让它们等自己的窗再绕一圈。应答口(`respondWithCas`)与耐久决断口(`routes/runs.ts`)都经这里 ——
+     *    此前两口各自拼一份入参、各打一次 `decideAsk`,出处 / 编辑 / 理由的映射是两份,超时与迟到收尾只有一口有。
+     *  · 停驻形:停驻门(续跑腿的门 CAS)**已经受理**之后把记录落在仍 `PARKED` 的行上(态不变,终局恒是那道门);只由停驻赎回的那一飞调({@link runParkedFlight})。
+     * 入参映射只有一只({@link askDecisionRecordOf} / {@link liveDecideInputOf})。抛 = 店错 / 超时(调用方各自的歧义臂接)。
+     */
+    writeAskDecision(store: ApprovalAskStore, askId: string, form: {
+        readonly kind: "live";
+        readonly batchId: string;
+    }, owner: string | null, write: LiveAskDecisionWrite): Promise<DecideResult>;
+    writeAskDecision(store: ApprovalAskStore, askId: string, form: {
+        readonly kind: "parked";
+    }, owner: string | null, write: AskDecisionWrite): Promise<RecordParkedDecisionResult>;
     /** store 在场时的回决 CAS 门(D2)——`respond()` 的异步分支,拆出以保持 `respond()` 本身在 store 缺席
      *  时仍是纯同步函数(D1)。`askStore`/`askId`/`batchId` 由调用方在已窄化的分支里传入(避免非空断言）。 */
     private respondWithCas;