@sema-agent/server 7.141.0 → 7.143.0

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

@@ -126,6 +126,10 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
     private replayRejectedCount;
     /** 重放期被丢弃的坏行数(撕尾不计:那是本格式存在的理由,由 {@link corruptQuarantinePath} 单独说)。 */
     private corruptLineCount;
+    /** 本次启动重放到的 v1 信封记录数(随 M34;{@link upgradeJournalEnvelope} 的读数)。 */
+    private journalV1Records;
+    /** 盘上还有 v1 信封记录(随 M34):重放到 v1 记录时置位,任何一次压实(整本重写成 v2)清位 —— 已被压实过的账本不再为升级重写第二次。 */
+    private journalV1OnDisk;
     /** 本次启动隔离出去的原件路径(无坏字节 ⇒ `undefined`)。 */
     readonly corruptQuarantinePath: string | undefined;
     /**
@@ -179,8 +183,8 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
      * 🔴 [ref] —— **出域的一次决议不落账本**。作用域的属主维(`owner`,判据 {@link askRowCarriesOwner})不在记录上:行此刻不带着门判过的那位属主
      * ⇒ 内核上这一笔必输、零写(读钟也在判定之后,不开账本窗)⇒ 没有要重放的东西,直调内核拿它的输者答案(与留存两动词「空的一次不落」同一条先例)。
      * 判定、落账、内核调用都在同一个同步前缀里,其间行不可能换属主。于是**落了账的每一条决议都在域内**,重放按行自己的属主喂属主维
-     * ({@link FileApprovalAskStore.replayOp})—— 记录形一个字节不变:升级前写下的账本、升级后写下的账本、降级回老版本时老读者读新账本,三者同读,
-     * 零迁移、零双读。
+     * ({@link FileApprovalAskStore.replayOp})—— 决议记录的形一个字节不变(没有属主格):升级前写下的决议记录与升级后写下的同读,零迁移、零双读
+     * (整本账的信封号另算 —— 见顶注「信封版本」)。
      */
     decideAsk(askId: string, batchId: string, owner: string | null, decision: DecideAskInput): Promise<DecideResult>;
     claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent, opts?: AskTerminalClaimOpts): Promise<AskTerminalClaimOutcome>;
@@ -208,14 +212,20 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
         corruptLines: number;
         records: number;
     };
-    /** 释放追加 fd(`LocalBackend.close` → 优雅重启重开)。不包 try/catch 的理由同
-     *  {@link FileApprovalNonceStore.dispose}:core 的 `AppendLog.close()` 自己就是全函数。 */
+    /**
+     * 问行成因两列的 local 腿(一次性迁移 M34,窗口见 `plugins/one-time-migrations.ts` 登记表;`LocalBackend.runOneTimeMigrations` 调):本次启动重放到的 v1 信封记录
+     * 已由读侧半场按意义译进内存({@link translateJournalV1Record}),这里**一次压实**把整本账重写成 v2 快照(压实 = 既有整本原子重写)。返回 v1 记录数;没有 ⇒ 零写、0。
+     * 本次启动里账本已被别的压实整本重写过(撕尾 / 坏行收拢、M32 的车道回填)⇒ 盘上已无 v1,不再重写,读数照报。
+     */
+    upgradeJournalEnvelope(): number;
     /**
      * 执行放置切换 ④b 的 local 腿(一次性迁移登记表 M32;`LocalBackend.runOneTimeMigrations` 在任何读者之前调):升级前写下的问(日志 `ensureAsk` 记录行 /
      * 压实快照行没有 `executionLane`)记成本部署车道表的唯一项,然后**一次压实**把整本账重写成带车道的快照(压实 = 既有整本原子重写)。
      * 没有缺车道的行 ⇒ 零写。车道表不是一元而还有缺车道的行 ⇒ 抛与 SQL 同一只拒(`backfill_ambiguous`,由调用方铸),一个字节没写。
      */
     backfillExecutionLanes(lanes: readonly ExecutionLane[], refuse: (pending: number) => never): number;
+    /** 释放追加 fd(`LocalBackend.close` → 优雅重启重开)。不包 try/catch 的理由同
+     *  {@link FileApprovalNonceStore.dispose}:core 的 `AppendLog.close()` 自己就是全函数。 */
     dispose(): void;
 }
 export {};

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

@@ -30,6 +30,41 @@ const JOURNAL_OP_WORDS = new Set(JOURNAL_OPS);
 export const JOURNAL_OP_TABLE_GATE = true;
 const JOURNAL_V1_CLAIM_INTENTS = ["expire", "cancel"];
 const JOURNAL_V1_CLAIM_INTENT_WORDS = new Set(JOURNAL_V1_CLAIM_INTENTS);
+const JOURNAL_ENVELOPE = 2;
+const JOURNAL_V1_ENVELOPE = 1;
+function askRowToDisk(row) {
+    const { sourceSessionId, ...rest } = row;
+    return { ...rest, sourceTaskId: sourceSessionId };
+}
+function askRowFromDisk(row, refuse) {
+    const sourceTaskId = row !== null && typeof row === "object" ? row.sourceTaskId : undefined;
+    if (typeof sourceTaskId !== "string")
+        return refuse("ask row without a string sourceTaskId (the on-disk name of the ask's source session)");
+    const { sourceTaskId: _onDisk, ...rest } = row;
+    return { ...rest, sourceSessionId: sourceTaskId };
+}
+const callToDisk = (call) => (call.op === "ensureAsk" ? { ...call, row: askRowToDisk(call.row) } : call);
+const V1_ENDING_STATES = new Set(["VOID", "DENIED"]);
+const V1_TRIGGER_STATES = new Set(["PARKING", "PARKED"]);
+function translateJournalV1Record(raw, refuse) {
+    const rec = raw;
+    if (rec.k === "ask" && rec.row !== null && typeof rec.row === "object") {
+        const { deniedReason, ...row } = rec.row;
+        const cause = typeof deniedReason === "string" ? deniedReason : null;
+        if (cause !== null && row.state === "STREAM_PENDING") {
+            refuse(`an envelope-1 snapshot row in STREAM_PENDING carries the single cause field ${JSON.stringify(cause)} — no released server wrote that shape and it has no two-column reading`);
+        }
+        return { ...raw, row: { ...row, endingCause: V1_ENDING_STATES.has(row.state) ? cause : null, parkTrigger: V1_TRIGGER_STATES.has(row.state) ? cause : null } };
+    }
+    if (rec.k === "op" && (rec.op === "transitionAsk" || rec.op === "resolveProvisional") && rec.patch !== null && typeof rec.patch === "object" && "deniedReason" in rec.patch) {
+        const { deniedReason, ...patch } = rec.patch;
+        if (!V1_ENDING_STATES.has(rec.to) || (typeof deniedReason !== "string" && deniedReason !== null)) {
+            refuse(`an envelope-1 ${String(rec.op)} record sets the single cause field on a transition to ${JSON.stringify(rec.to)} with ${JSON.stringify(deniedReason)} — no released server wrote that shape and it has no two-column reading`);
+        }
+        return { ...raw, patch: { ...patch, endingCause: deniedReason } };
+    }
+    return raw;
+}
 const ASK_JOURNAL_SHAPE = {
     what: "approval-ask journal record",
     read: (record) => record,
@@ -57,6 +92,8 @@ export class FileApprovalAskStore {
     pinnedNow = null;
     replayRejectedCount = 0;
     corruptLineCount = 0;
+    journalV1Records = 0;
+    journalV1OnDisk = false;
     corruptQuarantinePath;
     constructor(root) {
         const dir = join(root, APPROVAL_ASK_DIR);
@@ -95,9 +132,9 @@ export class FileApprovalAskStore {
     }
     write(call, run) {
         const t = Date.now();
-        const record = { v: 1, k: "op", t, ...call };
-        const encoded = encodeStoreJsonPayload(`${call.op} call`, record);
-        this.logFor().append(encoded, true);
+        const encoded = encodeStoreJsonPayload(`${call.op} call`, { v: JOURNAL_ENVELOPE, k: "op", t, ...call });
+        const onDisk = { v: JOURNAL_ENVELOPE, k: "op", t, ...callToDisk(encoded) };
+        this.logFor().append(onDisk, true);
         this.records += 1;
         this.pinnedNow = t;
         let out;
@@ -125,22 +162,29 @@ export class FileApprovalAskStore {
     }
     compact(snapshot = this.core.exportRows()) {
         const lines = [
-            ...snapshot.batches.map((row) => `${JSON.stringify({ v: 1, k: "batch", row })}\n`),
-            ...snapshot.asks.map((row) => `${JSON.stringify({ v: 1, k: "ask", row })}\n`),
+            ...snapshot.batches.map((row) => `${JSON.stringify({ v: JOURNAL_ENVELOPE, k: "batch", row })}\n`),
+            ...snapshot.asks.map((row) => `${JSON.stringify({ v: JOURNAL_ENVELOPE, k: "ask", row: askRowToDisk(row) })}\n`),
         ];
         this.log?.closeForSwap();
         atomicWriteFile(this.tmpDir, this.path, lines.join(""));
+        this.journalV1OnDisk = false;
         this.records = lines.length;
     }
-    replayRecord(raw) {
-        const probe = raw;
+    replayRecord(disk) {
+        const head = disk;
         const refuse = (why) => {
             throw new StoreBootRefusalError(`FileApprovalAskStore: approval ask journal ${this.path} carries a record this build cannot replay — ${why} ` +
-                `(v=${JSON.stringify(probe.v)} k=${JSON.stringify(probe.k)} op=${JSON.stringify(probe.op)}). ` +
+                `(v=${JSON.stringify(head.v)} k=${JSON.stringify(head.k)} op=${JSON.stringify(head.op)}). ` +
                 "Replaying only the records it understands would resurrect decided asks or drop a human's approval. " +
                 "Run the server version that wrote this journal, or move the file aside (every approval on it is abandoned) to continue.");
         };
-        if (probe.v !== 1)
+        if (head.v === JOURNAL_V1_ENVELOPE) {
+            this.journalV1Records += 1;
+            this.journalV1OnDisk = true;
+        }
+        const raw = head.v === JOURNAL_V1_ENVELOPE ? translateJournalV1Record(disk, refuse) : disk;
+        const probe = raw;
+        if (probe.v !== JOURNAL_ENVELOPE && probe.v !== JOURNAL_V1_ENVELOPE)
             refuse("unknown envelope version");
         if (probe.k === "ask" || probe.k === "batch") {
             const row = probe.row;
@@ -150,7 +194,7 @@ export class FileApprovalAskStore {
             if (typeof key !== "string" || key.length === 0)
                 refuse(`snapshot record without a ${probe.k === "ask" ? "askId" : "batchId"}`);
             if (probe.k === "ask")
-                this.core.importRows({ asks: [row] });
+                this.core.importRows({ asks: [askRowFromDisk(row, refuse)] });
             else
                 this.core.importRows({ batches: [row] });
             return;
@@ -168,7 +212,7 @@ export class FileApprovalAskStore {
             if (!Array.isArray(anchors) || !anchors.every((a) => typeof a === "string"))
                 refuse("reapSettledAsks record without a string-array keepAnchors");
         }
-        const rec = raw;
+        const rec = (probe.op === "ensureAsk" ? { ...raw, row: askRowFromDisk(probe.row, refuse) } : raw);
         this.pinnedNow = rec.t;
         try {
             void this.replayOp(rec).catch((e) => {
@@ -296,6 +340,15 @@ export class FileApprovalAskStore {
     replayStats() {
         return { rejected: this.replayRejectedCount, corruptLines: this.corruptLineCount, records: this.records };
     }
+    upgradeJournalEnvelope() {
+        const upgraded = this.journalV1Records;
+        if (upgraded === 0)
+            return 0;
+        if (this.journalV1OnDisk)
+            this.compact();
+        this.journalV1Records = 0;
+        return upgraded;
+    }
     backfillExecutionLanes(lanes, refuse) {
         const pending = this.core.exportRows().asks.filter((r) => !isExecutionLane(String(r.executionLane ?? ""))).length;
         if (pending === 0)

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

@@ -101,7 +101,8 @@ export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
      * 单调性论证)。
      */
     claimTerminal(askId: string, batchId: string, intent: AskTerminalClaimIntent, opts?: AskTerminalClaimOpts): Promise<AskTerminalClaimOutcome>;
-    /** `cause`(可选)= 转 park 的触发成因,赢下 PARKING 的同一步落进 `deniedReason`(SQL twin 同一条 UPDATE 的镜像;接口上的 `expireAsk` 不带它,只有 `claimTerminal(expire, { cause })` 带)。 */
+    /** `cause`(可选)= 转 park 的触发成因,赢下 PARKING 的同一步落进 `parkTrigger`(SQL twin 同一条 UPDATE 的镜像;接口上的 `expireAsk` 不带它,只有 `claimTerminal(expire, { cause })` 带)——
+     *  `parkTrigger` 的唯一写点:此后的转移(补丁里没有这一键)不再碰它。 */
     expireAsk(askId: string, batchId: string, cause?: AskTerminalClaimOpts["cause"]): Promise<ExpireResult>;
     bindBatch(batchId: string, askId: string, gate: BindGateInput): Promise<BindResult>;
     deferReconcile(askId: string, expectedState: AskState, expectedRev: number, nowMs: number): Promise<boolean>;

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

@@ -1,7 +1,7 @@
 import { ASK_TERMINAL, canAskTransition } from "../approval-ask-machine.js";
 import { isExecutionLane } from "../execution-lane-caps.js";
 import { APPROVAL_ENDING_CAUSES } from "../approval-deny-reasons.js";
-import { askRowCarriesOwner, askRowOnCall, assertDecideSettledBy, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
+import { askRowCarriesOwner, askRowOnCall, assertDecideSource, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
 function applyPatch(row, patch) {
     if (patch.decision !== undefined)
         row.decision = patch.decision;
@@ -11,8 +11,8 @@ function applyPatch(row, patch) {
         row.decisionNote = patch.decisionNote;
     if (patch.decidedAtMs !== undefined)
         row.decidedAtMs = patch.decidedAtMs;
-    if (patch.deniedReason !== undefined)
-        row.deniedReason = patch.deniedReason;
+    if (patch.endingCause !== undefined)
+        row.endingCause = patch.endingCause;
     if (patch.gateToken !== undefined)
         row.gateToken = patch.gateToken;
     if (patch.gateBoundCallId !== undefined)
@@ -58,7 +58,7 @@ export class InMemoryApprovalAskStore {
     }
     importRows(snapshot) {
         for (const r of snapshot.asks ?? [])
-            this.asks.set(r.askId, { ...r, settledBy: r.settledBy ?? null });
+            this.asks.set(r.askId, { ...r, settledBy: r.settledBy ?? null, decidedVia: r.decidedVia ?? null });
         for (const b of snapshot.batches ?? [])
             this.batches.set(b.batchId, { ...b });
     }
@@ -82,7 +82,7 @@ export class InMemoryApprovalAskStore {
         const created = {
             askId: row.askId,
             taskId: row.taskId,
-            sourceTaskId: row.sourceTaskId,
+            sourceSessionId: row.sourceSessionId,
             sessionId: row.sessionId,
             owner: row.owner ?? null,
             executionLane: row.executionLane,
@@ -98,8 +98,10 @@ export class InMemoryApprovalAskStore {
             decisionActor: null,
             decisionNote: null,
             settledBy: null,
+            decidedVia: null,
             decidedAtMs: null,
-            deniedReason: null,
+            endingCause: null,
+            parkTrigger: null,
             gateToken: null,
             gateBoundCallId: null,
             gateBoundInputHash: null,
@@ -131,7 +133,7 @@ export class InMemoryApprovalAskStore {
     async decideAsk(askId, batchId, owner, decision) {
         if (decision.idempotencyKey != null)
             assertIdempotencyKeyShape(decision.idempotencyKey);
-        assertDecideSettledBy(decision);
+        assertDecideSource(decision);
         const reading = (row) => projectDecideReading(row ? { ...row } : null, owner);
         const batch = this.batches.get(batchId);
         if (!batch || batch.state !== "OPEN") {
@@ -159,6 +161,7 @@ export class InMemoryApprovalAskStore {
         ask.decisionActor = decision.decisionActor ?? null;
         ask.decisionNote = decision.decisionNote ?? null;
         ask.settledBy = decision.settledBy ?? null;
+        ask.decidedVia = decision.decidedVia ?? null;
         if (decision.updatedInput === undefined)
             delete ask.updatedInput;
         else
@@ -181,13 +184,13 @@ export class InMemoryApprovalAskStore {
                 const scoped = this.asks.get(askId);
                 if (scoped !== undefined && scoped.batchId !== batchId)
                     return { claimed: false, current: { state: "absent" } };
-                const won = await this.transitionAsk(askId, "STREAM_PENDING", "VOID", { updatedAtMs: this.now(), ...(opts?.cause !== undefined ? { deniedReason: opts.cause } : {}) });
+                const won = await this.transitionAsk(askId, "STREAM_PENDING", "VOID", { updatedAtMs: this.now(), ...(opts?.cause !== undefined ? { endingCause: opts.cause } : {}) });
                 if (won)
                     return { claimed: true, voidedSiblings: [] };
                 break;
             }
             case "refuse": {
-                assertDecideSettledBy(POLICY_REFUSAL_DECISION);
+                assertDecideSource(POLICY_REFUSAL_DECISION);
                 const to = claimTargetState(intent);
                 if (!canAskTransition("STREAM_PENDING", to))
                     throw new Error(`InMemoryApprovalAskStore.claimTerminal: illegal terminal claim STREAM_PENDING -> ${to} (askId=${askId})`);
@@ -222,7 +225,7 @@ export class InMemoryApprovalAskStore {
             return { won: false, voidedSiblings: [] };
         ask.state = "PARKING";
         if (cause !== undefined)
-            ask.deniedReason = cause;
+            ask.parkTrigger = cause;
         ask.rev += 1;
         ask.updatedAtMs = now;
         if (batch.state === "OPEN") {
@@ -234,7 +237,7 @@ export class InMemoryApprovalAskStore {
         for (const [id, r] of this.asks) {
             if (r.batchId === batchId && r.state === "STREAM_PENDING" && id !== askId) {
                 r.state = "VOID";
-                r.deniedReason = APPROVAL_ENDING_CAUSES.BATCH_SIBLING_WITHDRAWN;
+                r.endingCause = APPROVAL_ENDING_CAUSES.BATCH_SIBLING_WITHDRAWN;
                 r.rev += 1;
                 r.updatedAtMs = now;
                 voided.push(id);
@@ -267,7 +270,7 @@ export class InMemoryApprovalAskStore {
         for (const [id, r] of this.asks) {
             if (r.batchId === batchId && r.state === "PARKING" && id !== askId) {
                 r.state = "VOID";
-                r.deniedReason = APPROVAL_ENDING_CAUSES.BATCH_BOUND_ELSEWHERE;
+                r.endingCause = APPROVAL_ENDING_CAUSES.BATCH_BOUND_ELSEWHERE;
                 r.rev += 1;
                 r.updatedAtMs = now;
                 voidedSiblings.push(id);
@@ -295,7 +298,7 @@ export class InMemoryApprovalAskStore {
         for (const [id, r] of this.asks) {
             if (r.batchId === batchId && r.state === "STREAM_PENDING") {
                 r.state = "VOID";
-                r.deniedReason = APPROVAL_ENDING_CAUSES.BATCH_ABORTED;
+                r.endingCause = APPROVAL_ENDING_CAUSES.BATCH_ABORTED;
                 r.rev += 1;
                 r.updatedAtMs = now;
                 voided.push(id);
@@ -389,7 +392,7 @@ export class InMemoryApprovalAskStore {
     }
     planReapSettledAsks(cutoffMs, limit, keepAnchors) {
         assertReapBounds(cutoffMs, limit);
-        const anchored = (r) => keepAnchors.has(r.taskId) || keepAnchors.has(r.sessionId) || keepAnchors.has(r.sourceTaskId);
+        const anchored = (r) => keepAnchors.has(r.taskId) || keepAnchors.has(r.sessionId) || keepAnchors.has(r.sourceSessionId);
         return [...this.asks.values()]
             .filter((r) => ASK_TERMINAL.has(r.state) && !r.provisional && r.updatedAtMs < cutoffMs && !anchored(r))
             .sort((a, b) => a.updatedAtMs - b.updatedAtMs || (a.askId < b.askId ? -1 : a.askId > b.askId ? 1 : 0))

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

@@ -42,14 +42,15 @@ import type { PgQueryFn } from "./pg-query.js";
 import { type SqlDriver, type SqlDialect } from "./sql-driver.js";
 import { type AskState, type BatchState } from "../approval-ask-machine.js";
 import type { HostSettledBy } from "../host-decision.js";
-import { type AskRowCause, type SettleCause } from "../approval-deny-reasons.js";
+import { type DecidedVia } from "@sema-agent/core";
+import { type AskRowEndingCause, type SettleCause, type ParkTriggerCause } from "../approval-deny-reasons.js";
 import { type IndexSpec } from "./ensure-index.js";
 import { type ExecutionLane } from "../execution-lane-caps.js";
 export type AskDecision = "approve" | "deny";
 export interface AskRow {
     askId: string;
     taskId: string;
-    sourceTaskId: string;
+    sourceSessionId: string;
     sessionId: string;
     /** 租户 scope——哨兵归一在消费层(车2+),店里存原值(设计定稿 §3)。 */
     owner: string | null;
@@ -69,7 +70,7 @@ export interface AskRow {
      * 与下面 PARKED 坐标里的 `gateBoundInputHash` 是**两件不同的东西**,别混:
      *   - `boundInputHash`(本列)= ask **铸行时**的入参摘要,一次写定永不改;对账收敛器判据 1 用它跟
      *     checkpoint 行的同名列做**硬相等**——它是**身份三元组之外的第二道等式**,身份本身是
-     *     (`sourceTaskId`, `toolCallId`, 因果下界)三维([ref] 件1 换轴,判据属主 = `approval-reconciler.ts`
+     *     (`sourceSessionId`, `toolCallId`, 因果下界)三维([ref] 件1 换轴,判据属主 = `approval-reconciler.ts`
      *     的 `classifyGateMatch`;本注上一版写的「identity 四元组」是换轴前的旧口径,`sessionId` 从来不是
      *     内存判据维)。任一侧缺席 ⇒ 判据 1 **不命中**;归因看走到哪一层:身份先判(候选集非空却没有同身份
      *     的一条 ⇒ `identity_miss`),身份这层还够得着时缺席才记 `single_mint`(禁「能取到时才比」的可选谓词
@@ -90,7 +91,7 @@ export interface AskRow {
     /**
      * 🔴 [ref]([ref] 的持久半场)—— 这条决议的**结算来源**:`null` = 一个人答的(= 缺席律,core 对
      * 不带这一格的 outcome 逐字按 `"human"` 读),非 null = 宿主自报的那个词([ref] 起写进来的只有决定体出处位
-     * `decidedBy:"policy"` 经 `liveSettledBy` 映射来的 `"policy"`,allow 与 deny 两向都写;词表属主恒是 core —— 见 {@link HostSettledBy})。
+     * `decidedBy:"policy"` 经 `liveHostSource` 映射来的 `"policy"`,allow 与 deny 两向都写;词表属主恒是 core —— 见 {@link HostSettledBy})。
      *
      * **为什么必须是行上的一格**(病灶,7.93.3 合并树 codex ① 验真):`settledBy` 此前只到达**当次**回决的
      * 即时回调,行上不留痕 ⇒ 重放 / 再入 / 同 askId 的兄弟等待者 / 歧义提交恢复读回的是裸 `false`,
@@ -113,6 +114,14 @@ export interface AskRow {
      * 三态收成两态是刻意的:`"human"` 与缺席在 core 那边逐字同义,故店只存「非人」的那些词,`null` 即人。
      */
     settledBy: HostSettledBy | null;
+    /**
+     * core 7.61.0([ref])—— `settledBy = "policy"` 旁的**机器座位**:哪一个机器座位替这台部署答的(core `DECIDED_VIA`:`"policy"` 部署自己的策略 /
+     * `"permission_request_hook"` 一只 PermissionRequest 钩子)。`null` = 没陈述(旧行同读)= 部署自己的策略。它决定模型读哪一句拒句
+     * (「这一跑没有交互审批通道」vs「一只 PermissionRequest 钩子拒了」),所以与 {@link settledBy} 同一条理由住在行上、与决议同一条 UPDATE 落列:
+     * 活卡腿的结算输入只从行读,不在行上 = 重放 / 兄弟 / 再入 / 歧义恢复 / 迟到成功 / 跨副本广播六条路把钩子的拒读回成部署策略的拒。
+     * 只在 `settledBy = "policy"` 旁(core 同一条律;店门 {@link assertDecideSource} 守)。
+     */
+    decidedVia: DecidedVia | null;
     /**
      * [ref]([ref] / [ref] 收口):人批准时带的 **ctrl+g 编辑实参**(wire `updatedInput`),与决议**同一条
      * UPDATE** 原子落列 `updated_input`。语义三态,读法**严格**:
@@ -132,7 +141,16 @@ export interface AskRow {
      */
     updatedInput?: unknown;
     decidedAtMs: number | null;
-    deniedReason: string | null;
+    /**
+     * `ending_cause` 列原值 —— **终态成因**:这一行为什么没被人答就结束了(到 `VOID` / `DENIED` 的转移带着它写:取消 claim、店内撤兄弟 / bind-once 落选 / 批中止、对账器、起服收敛;没带的转移 ⇒ 保持 `null`)。
+     * 只经 {@link askRowEndingCause} 读(词表 + 行不变式在那里);`null` = 没写归因。
+     */
+    endingCause: string | null;
+    /**
+     * `park_trigger` 列原值 —— **转 park 的触发成因**:这一行为什么被转进投递面。**唯一写者** = 赢下 `STREAM_PENDING → PARKING` 的那一次 `claimTerminal(expire, { cause })`,
+     * 此后不再被写(行走到 `PARKED` / `DENIED` / `VOID` 之后它仍在;{@link AskTransitionPatch} 没有这一键)。只经 {@link askRowParkTrigger} 读;`null` = 没写(不带 cause 的转 park)。
+     */
+    parkTrigger: string | null;
     /** PARKED 坐标三件。 */
     gateToken: string | null;
     gateBoundCallId: string | null;
@@ -177,7 +195,7 @@ export interface AskRow {
 export interface NewAskRow {
     askId: string;
     taskId: string;
-    sourceTaskId: string;
+    sourceSessionId: string;
     sessionId: string;
     owner?: string | null;
     /** 出处的执行车道(必填;语义见 {@link AskRow.executionLane})。 */
@@ -222,7 +240,9 @@ export interface AskTransitionPatch {
     decisionActor?: unknown | null;
     decisionNote?: string | null;
     decidedAtMs?: number | null;
-    deniedReason?: string | null;
+    /** 终态成因(值域与终局 claim 的 `cause` 同一型 {@link SettleCause};读口按终态成因词表读,且只在 `VOID` / `DENIED` 上作数 —— 别的转移上写了也读成缺席)。
+     *  补丁**没有**触发成因那一键:它只由 `claimTerminal(expire, { cause })` 写一次。 */
+    endingCause?: SettleCause;
     gateToken?: string | null;
     gateBoundCallId?: string | null;
     gateBoundInputHash?: string | null;
@@ -239,10 +259,12 @@ export interface DecideAskInput {
      * 🔴 [ref]:本次回决的**结算来源**,与决议同一条 UPDATE 落列 `settled_by`(语义/两态读法/为什么是
      * 自己一列,全在 {@link AskRow.settledBy})。缺席 ⇒ 列 NULL ⇒ 读回是「一个人答的」。
      *
-     * 店**不判词**(词表属主是 core):写什么存什么。店只判**形** —— `assertDecideSettledBy` 的那一条
+     * 店**不判词**(词表属主是 core):写什么存什么。店只判**形** —— `assertDecideSource` 的那一条
      * (长度 ≤ 列宽;[ref] 起 approve 行也可以带来源位),理由见那只门的顶注;三 twin 同判。
      */
     settledBy?: HostSettledBy;
+    /** core 7.61.0([ref]):`settledBy:"policy"` 旁的机器座位,与决议同一条 UPDATE 落列 `decided_via`(语义见 {@link AskRow.decidedVia});缺席 ⇒ 列 NULL。 */
+    decidedVia?: DecidedVia;
     /** [ref]:ctrl+g 编辑实参,与决议同一条 UPDATE 落列(语义三态见 {@link AskRow.updatedInput})。
      *  缺席 / `undefined` ⇒ 列 NULL(没带编辑);**`null` 是值**(编辑成 null),照存 JSON `"null"`。
      *  调用方纪律:deny 不传(店不替调用方判决议方向,写什么存什么)。 */
@@ -282,7 +304,7 @@ export declare function assertReapBounds(cutoffMs: number, limit: number): void;
 export declare function assertIdempotencyKeyShape(key: string): void;
 /** `settled_by` 列宽 = 这一格的唯一尺(两方言 DDL 与下面的形门读同一个常量,不手抄第二份)。 */
 export declare const MAX_SETTLED_BY_CHARS = 16;
-/** `settled_by` 这一列装得下这个词吗(1..{@link MAX_SETTLED_BY_CHARS})—— 店门口形门({@link assertDecideSettledBy})的**谓词本身**。
+/** `settled_by` 这一列装得下这个词吗(1..{@link MAX_SETTLED_BY_CHARS})—— 店门口形门({@link assertDecideSource})的**谓词本身**。
  *  [ref] 起决定口不再读它:wire 上的出处位是闭集(`host-decision.ts` 的 `APPROVAL_DECIDED_BY`),映射到这一列的词恒在尺内。 */
 export declare function settledByFitsColumn(v: string): boolean;
 /**
@@ -296,9 +318,11 @@ export declare function settledByFitsColumn(v: string): boolean;
  * 🔴 [ref]:此前的第二条「只与 `deny` 同行」**删了** —— 它的前提(「只有人能批准一个要执行的动作,core 对 `{allow:true,settledBy}`
  * 一律 fail-closed 拒」)自 core 7.39.0 起不成立:策略的放行铸 `policy_allowed`,决定体的出处位 `decidedBy:"policy"` 在 allow 与 deny
  * 上都落这一列,approve 行带来源位是一条合法的行(读回铸点 `outcomeOfDecidedRow` 两向都读它)。今天写这一列的只有两条路:决定口经
- * `liveSettledBy` 映射来的 `"policy"`,与 `claimTerminal(refuse)` 的 {@link POLICY_REFUSAL_DECISION} —— 都是 core 在两向上都收的词。
+ * `liveHostSource` 映射来的 `"policy"`,与 `claimTerminal(refuse)` 的 {@link POLICY_REFUSAL_DECISION} —— 都是 core 在两向上都收的词。
  */
-export declare function assertDecideSettledBy(decision: Pick<DecideAskInput, "settledBy">): void;
+export declare function assertDecideSource(decision: Pick<DecideAskInput, "settledBy" | "decidedVia">): void;
+/** `decided_via` 列宽 = 这一格的唯一尺(两方言 DDL 读同一个常量)。core `DECIDED_VIA` 今天最长 23 字符(`permission_request_hook`)。 */
+export declare const MAX_DECIDED_VIA_CHARS = 32;
 /**
  * [ref] 车3 刀 3b(§14.2 遗留记账):两条**重放读口**被调用方的 deadline 掐断时抛的具名错误。
  *
@@ -330,9 +354,10 @@ export interface ExpireResult {
  */
 export type AskTerminalClaimIntent = "expire" | "cancel" | "refuse";
 /**
- * 终局 claim 的可选实参:`cause` —— **赢下 `cancel`(VOID)/ `expire`(PARKING)时写进这一行 `denied_reason` 列的成因词**(决断口 410 / 晚答 404 / 跨副本的败方读数读同一列,
- * 所以这一行自己记着「为什么」,读面不靠任何进程内的东西)。`cancel` 写终态成因({@link SettleCause} 里的 `run_cancelled` / `run_exited`),
- * `expire` 写转 park 的触发成因({@link ParkTriggerCause}:`ttl_expired` / `broadcast_lost` / `stream_disconnected` / `undeliverable` / `shutdown_before_park`);缺席 ⇒ 列保持 NULL(读面缺席即缺席)。
+ * 终局 claim 的可选实参:`cause` —— **赢下终局的同一步写进这一行的成因词**,列由意图定({@link claimCauseColumn}):`cancel`(VOID)写 `ending_cause` = 终态成因
+ * ({@link SettleCause} 里的 `run_cancelled` / `run_exited`;决断口 410 / 晚答 404 / 跨副本的败方读数读这一列),`expire`(PARKING)写 `park_trigger` = 转 park 的触发成因
+ * ({@link ParkTriggerCause}:`ttl_expired` / `broadcast_lost` / `stream_disconnected` / `undeliverable` / `shutdown_before_park`;跨副本的悬挂腿与败方读数读这一列)。
+ * 所以这一行自己记着「为什么」,读面不靠任何进程内的东西;缺席 ⇒ 列保持 NULL(读面缺席即缺席)。
  * `refuse` 不读它(落的是一条决议,来源位 `policy`,不是结局成因);`expire` 撤兄弟时店自己写 `batch_sibling_withdrawn`(那是这条事务本身的事实)。
  */
 export interface AskTerminalClaimOpts {
@@ -341,13 +366,18 @@ export interface AskTerminalClaimOpts {
 /**
  * `refuse` 意图落行的决议(NP-2)—— **部署政策拒**:deny + 结算来源 `policy`。来源词的型取 core 的 `HostSettledBy`
  * (core 改词 / 退词 ⇒ 这里 tsc 红);协调器交给 core 的那一只(`tool-approval.ts` 的 `UnattendedPolicyRefusal`)读的是
- * **同一个**常量,于是「行上记的来源」与「首判交出去的来源」在构造上是一个词。三 twin 落行前都过 {@link assertDecideSettledBy}
+ * **同一个**常量,于是「行上记的来源」与「首判交出去的来源」在构造上是一个词。三 twin 落行前都过 {@link assertDecideSource}
  * (settled_by 的唯一形门:长度 ≤ 列宽)。
  */
 export declare const POLICY_REFUSAL_DECISION: {
     readonly decision: "deny";
     readonly settledBy: Extract<HostSettledBy, "policy">;
 };
+/**
+ * 带成因的终局 claim 把成因写进哪一列(穷举 switch:意图闭集加一个词 ⇒ 这里编译期先红)。一列一义:`cancel` 赢下的是终态(`ending_cause`),
+ * `expire` 赢下的是转 park(`park_trigger`);`refuse` 落的是一条决议,不带成因(不进本表)。SQL 两孪生读这一只;内存孪生的两臂各自落同一格(`transitionAsk` 的补丁 / `expireAsk`)。
+ */
+export declare function claimCauseColumn(intent: Exclude<AskTerminalClaimIntent, "refuse">): "ending_cause" | "park_trigger";
 /** 终局 claim 意图 → 本次 CAS 的目标态(穷举 switch:意图闭集加一个词 ⇒ 这里编译期先红)。 */
 export declare function claimTargetState(intent: AskTerminalClaimIntent): AskState;
 /**
@@ -374,10 +404,13 @@ export type AskTerminalClaimCurrent = {
     /** [ref]:赢家决议的**结算来源**(语义与两态读法见 {@link AskRow.settledBy})。**必填**(不是可选)——
      *  可选会让投影漏挑这一列时静默编译过,而漏挑的后果恰是本批要修的病:CAS 输家把赢家的策略拒读成人拒。 */
     settledBy: HostSettledBy | null;
-    /** 行上记着的成因,经问账行成因的唯一读口 `causeOfAskRow` 读出(`kind` 说它在这一行上的意思:VOID / DENIED = 终态成因,PARKING / PARKED = 转 park 的触发成因);
-     *  **只在读得出时在场**(没写 / 与 state 不配 ⇒ 缺席;DECIDED 的败方读数逐字不变)。CAS 输家据它按**行上那个成因**结算(而不是把别人撤的卡读成一次拒绝);
-     *  投影的唯一函数是 {@link projectAskTerminalClaimTruth},三 twin 不各自挑列,原始列值不出店层。 */
-    cause?: AskRowCause;
+    /** core 7.61.0([ref]):赢家决议的机器座位(语义见 {@link AskRow.decidedVia});必填,理由与 `settledBy` 同。 */
+    decidedVia: DecidedVia | null;
+    /** 行上记着的终态成因(`ending_cause` 列,经唯一读口 `askRowEndingCause` 读出)。**只在读得出时在场**(没写 / 与 state 不配 ⇒ 缺席;DECIDED 的败方读数逐字不变)。
+     *  CAS 输家据它按**行上那个成因**结算(而不是把别人撤的卡读成一次拒绝);投影的唯一函数是 {@link projectAskTerminalClaimTruth},三 twin 不各自挑列,原始列值不出店层。 */
+    endingCause?: AskRowEndingCause;
+    /** 行上记着的转 park 触发成因(`park_trigger` 列,经唯一读口 `askRowParkTrigger` 读出;行走过 PARKING 才可能在场)。在场律同 {@link endingCause}。 */
+    parkTrigger?: ParkTriggerCause;
 };
 /**
  * 单次原子往返的答案(语义律的唯一规范陈述点 = core `checkpoint-store.ts` `claimTerminal` 契约 JSDoc,
@@ -433,7 +466,7 @@ export interface BatchRow {
 }
 /** design 定稿 §4 的持久层接口。协调器接线(车2)、恢复扫描消费(车5)不在本车范围——本车只落这些方法。 */
 /** 一次调用在一条腿上的坐标({@link ApprovalAskStore.listByCall} 的四列;型从 {@link AskRow} 派生,不手抄)。 */
-export type AskCallCoordinate = Pick<AskRow, "taskId" | "legKey" | "toolCallId" | "sourceTaskId">;
+export type AskCallCoordinate = Pick<AskRow, "taskId" | "legKey" | "toolCallId" | "sourceSessionId">;
 /** 「这一行在这次调用上」的唯一判据(四列逐字相等):InMemory twin 的筛子与 SQL twin 的出口对齐读同一只。 */
 export declare function askRowOnCall(row: AskRow, call: AskCallCoordinate): boolean;
 /**
@@ -517,12 +550,12 @@ export interface ApprovalAskStore {
      *  后续件。 */
     listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
     /**
-     * 🔴 [ref] / SN-C1:**这次调用在这条腿上的全部行** —— 任意状态、任意 ask 身份(同一调用不同类集 = 不同 askId 的几只问、升级前按旧派生
+     * 🔴 [ref] / SN-C1:**这次调用在这条腿上的全部行** —— 任意状态、任意 ask 身份(同一调用不同类集 / 不同展示动作 = 不同 askId 的几只问、升级前按旧派生
      * 写的行,都在其中)。坐标 = {@link AskCallCoordinate} 四列**精确**匹配;序 = `created_at_ms ASC, ask_id ASC`(确定性)。
      *
      * 唯一消费者 = 会话授权短路的争议判据(`tool-approval.ts` `sessionGrantUncontestedByRow`):「这次调用在腿内有行 ⇒ 一揽子放行不得代答」。
      * 为什么按调用而不是按 askId 点读:争议的真源是**调用**(人对这次调用说过什么 / 这次调用还有一张卡挂着),ask 身份只是其中一问的主键;
-     * 身份可以加轴([ref] 加了类集),争议判据不得依赖身份 —— 按身份点读在身份加轴的那一刻就把同调用的别的问、旧派生的行读成「不存在」。
+     * 身份可以加轴([ref] 加了类集,7.143.0 加了展示的动作),争议判据不得依赖身份 —— 按身份点读在身份加轴的那一刻就把同调用的别的问、旧派生的行读成「不存在」。
      *
      * 三 twin 同答:SQL twin 读后按四列逐字再滤一遍 —— MySQL 协议的 VARCHAR 等值带 PAD SPACE(`'tc'` = `'tc '`),PG(`COLLATE "C"`)与
      * InMemory 严格比较;不在入口拒(调用 id 是引擎铸的原值,首尾空白不归本店判),在出口对齐。索引:走 `idx_ask_task_state`
@@ -550,7 +583,7 @@ export interface ApprovalAskStore {
     /**
      * **审批账本留存律的问账半场之一:问行**(律、节律与「还能动的 run」一处成文在 `approval-ask-retention.ts`;维护 tick 是唯一调用方)。
      * 删至多 `limit` 只**结了**的问行 —— `state ∈ ASK_TERMINAL` ∧ `provisional = false`(provisional 行还能被 {@link resolveProvisional} 改判,没结)
-     * ∧ `updatedAtMs < cutoffMs` ∧ 行挂靠的三格(`taskId` / `sessionId` / `sourceTaskId`)都不在 `keepAnchors`(还能动的东西的挂靠集:
+     * ∧ `updatedAtMs < cutoffMs` ∧ 行挂靠的三格(`taskId` / `sessionId` / `sourceSessionId`)都不在 `keepAnchors`(还能动的东西的挂靠集:
      * 它还会回读这些行 —— 会话授权的争议判据 {@link listByCall} 把「这次调用在腿内没有行」读成可以代答)。非终态行多老都不删(它们归对账器
      * 与起服收敛)。只删不改。
      * 一条语句:要么删了并交回删掉的行数,要么一行没删就抛。三形同答(InMemory = 内核;File 形把这次调用照常落成一条账本动词,
@@ -578,6 +611,20 @@ export declare const APPROVAL_ASK_EXECUTION_LANE_COLUMN: {
     readonly mysql: "execution_lane VARCHAR(32) NOT NULL DEFAULT ''";
     readonly pg: "execution_lane VARCHAR(32) COLLATE \"C\" NOT NULL DEFAULT ''";
 };
+/**
+ * 问行两列成因的列定义(两方言;唯一属主 —— 建表 DDL 内联它们,存量库的改名 / 加列只由一次性迁移做,那一步也读这里:窗口见 `plugins/one-time-migrations.ts` 登记表 M34)。
+ * 宽度 64 = 成因闭集里最长的词有余(钉在 `test/approval-reconciler.test.ts`)。语义见 {@link AskRow.endingCause} / {@link AskRow.parkTrigger}。
+ */
+export declare const APPROVAL_ASK_ENDING_CAUSE_COLUMN: {
+    readonly name: "ending_cause";
+    readonly mysql: "ending_cause VARCHAR(64) NULL";
+    readonly pg: "ending_cause VARCHAR(64) COLLATE \"C\"";
+};
+export declare const APPROVAL_ASK_PARK_TRIGGER_COLUMN: {
+    readonly name: "park_trigger";
+    readonly mysql: "park_trigger VARCHAR(64) NULL";
+    readonly pg: "park_trigger VARCHAR(64) COLLATE \"C\"";
+};
 export declare const APPROVAL_BATCH_TABLE = "approval_batch";
 /**
  * TiDB/MySQL-protocol 侧的两条建表语句,**抽成导出数组**(车3 刀 3a):`tidb-pool.ts` 的