@sema-agent/server 7.93.3 → 7.93.5

package/dist/boot/exit-boundary.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from "../observability/logger.js";
+/** {@link installProcessExitBoundary} 的把手。 */
+export interface ProcessExitBoundary {
+    /**
+     * **优化点**,不承担不变量:受控退的收尾链在它自己的终点早按一次子进程腿(理由逐字写在
+     * `boot/shutdown.ts` 的调用点上 —— 那之后进程还活十秒量级,后台腿的软→硬梯子跑得完)。
+     * 工作区腿**刻意不给**这条早按:停机中段 `rm -rf` 会把在飞 turn 正在写的目录从它脚下抽掉。
+     */
+    reapChildProcessesEarly(): void;
+    /** 摘掉本次装配的 `exit` 钩。幂等(同进程内反复装配的调用方=测试必须用它收尾)。 */
+    dispose(): void;
+}
+/**
+ * 装上本进程的退出边界(`process.once("exit")`)。返回 {@link ProcessExitBoundary}。
+ *
+ * **进程级注册表是全局单例** ⇒ 装两次就是两只钩(两个写者)。生产里每条车道只装一次、装到死;
+ * 同进程内反复装配的调用方(测试)必须 `dispose()`。
+ */
+export declare function installProcessExitBoundary({ logger }: {
+    logger: Logger;
+}): ProcessExitBoundary;
+//# sourceMappingURL=exit-boundary.d.ts.map

package/dist/boot/exit-boundary.js

@@ -0,0 +1,73 @@
+import { defaultTaskRegistry } from "@sema-agent/core";
+import { liveHostForegroundChildCount, reapHostForegroundChildren } from "../plugins/host-platform.js";
+import { liveEphemeralHostWorkspaceCount, reapEphemeralHostWorkspaces } from "../plugins/host-workspace-registry.js";
+export function installProcessExitBoundary({ logger }) {
+    const reapOwnChildProcesses = () => {
+        try {
+            const reaped = defaultTaskRegistry.reapAllSessionBackground();
+            if (reaped > 0)
+                logger.info("shutdown_background_reaped", { reaped });
+        }
+        catch (err) {
+            logger.warn("shutdown_background_reap_failed", { err: String(err) });
+        }
+        try {
+            const fg = reapHostForegroundChildren();
+            if (fg.signalled > 0 || fg.alreadyDead > 0)
+                logger.info("shutdown_foreground_reaped", { signalled: fg.signalled, alreadyDead: fg.alreadyDead });
+            if (fg.failed.length > 0)
+                logger.warn("shutdown_foreground_reap_incomplete", { groups: fg.failed });
+        }
+        catch (err) {
+            logger.warn("shutdown_foreground_reap_failed", { err: String(err) });
+        }
+    };
+    const reapOwnHostWorkspaces = () => {
+        try {
+            const { removed, failed } = reapEphemeralHostWorkspaces();
+            if (removed.length > 0)
+                logger.info("shutdown_host_workspaces_reaped", { removed: removed.length });
+            if (failed.length > 0)
+                logger.warn("shutdown_host_workspace_reap_incomplete", { dirs: failed.map((f) => f.dir) });
+        }
+        catch (err) {
+            logger.warn("shutdown_host_workspace_reap_failed", { err: String(err) });
+        }
+    };
+    const onProcessExit = () => {
+        const onBooks = { foregroundChildren: liveHostForegroundChildCount(), hostWorkspaces: liveEphemeralHostWorkspaceCount() };
+        try {
+            reapOwnChildProcesses();
+        }
+        catch (err) {
+            console.error("shutdown_exit_boundary_child_reap_threw", err);
+        }
+        try {
+            reapOwnHostWorkspaces();
+        }
+        catch (err) {
+            console.error("shutdown_exit_boundary_workspace_reap_threw", err);
+        }
+        const left = { foregroundChildren: liveHostForegroundChildCount(), hostWorkspaces: liveEphemeralHostWorkspaceCount() };
+        try {
+            logger.info("shutdown_exit_boundary", { ...onBooks, leftForegroundChildren: left.foregroundChildren, leftHostWorkspaces: left.hostWorkspaces });
+            if (left.foregroundChildren > 0 || left.hostWorkspaces > 0)
+                logger.warn("shutdown_exit_boundary_incomplete", left);
+        }
+        catch (err) {
+            console.error("shutdown_exit_boundary_log_threw", err);
+        }
+    };
+    process.once("exit", onProcessExit);
+    let disposed = false;
+    return {
+        reapChildProcessesEarly: reapOwnChildProcesses,
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            process.removeListener("exit", onProcessExit);
+        },
+    };
+}
+//# sourceMappingURL=exit-boundary.js.map

package/dist/boot/shutdown.d.ts

@@ -12,8 +12,8 @@
  *     "第二个信号"的语义读数。
  *  3. `clearInterval(reaper)` 必须是 hardShutdown 的第一件事(在 `server.close()` 之前),否则
  *     收尾期还会有 reaper tick 打向正在关闭的池。
- *  4. **进程级监听一律成对**([ref] 二轮件4):本函数装的六只(三信号 + [ref]① 双钩 + S-557 退出边界钩)
- *     只能经返回的
+ *  4. **进程级监听一律成对**([ref] 二轮件4):本函数装的六只(三信号 + [ref]① 双钩 + S-557 退出边界钩
+ *     —— S-560 起后者由 {@link installProcessExitBoundary} 代装,摘除仍并进同一把手)只能经返回的
  *     {@link ShutdownHandle} 摘 —— 调用方手写「摘三信号」的收尾会把双钩漏在进程上,而陈旧的那只
  *     rejection 钩仍握着 `process.exit(1)`,会对后续无关的 rejection 把进程打掉。
  */

package/dist/boot/shutdown.js

@@ -1,9 +1,8 @@
-import { Runner, defaultTaskRegistry } from "@sema-agent/core";
+import { Runner } from "@sema-agent/core";
 import { writeCrashLast, clearCrashLast, readCrashLast } from "./crash-last.js";
 import { createSighupIdleHandler } from "../sighup-idle.js";
 import { createParentWatch } from "../parent-watch.js";
-import { liveHostForegroundChildCount, reapHostForegroundChildren } from "../plugins/host-platform.js";
-import { liveEphemeralHostWorkspaceCount, reapEphemeralHostWorkspaces } from "../plugins/host-workspace-registry.js";
+import { installProcessExitBoundary } from "./exit-boundary.js";
 import { createEngineLeaseTracker } from "./engine-lease.js";
 import { writeExitLast, readExitLast, clearExitLast } from "./exit-last.js";
 import { isScriptRealmRejection, describeRejectionReason } from "../orchestration/hardened-vm-runner.js";
@@ -32,63 +31,7 @@ export function installShutdownHandlers(ctx) {
         if (dataRoot)
             writeCrashLast(dataRoot, { version, inflight: drainState.inflight?.(), err });
     };
-    const reapOwnChildProcesses = () => {
-        try {
-            const reaped = defaultTaskRegistry.reapAllSessionBackground();
-            if (reaped > 0)
-                logger.info("shutdown_background_reaped", { reaped });
-        }
-        catch (err) {
-            logger.warn("shutdown_background_reap_failed", { err: String(err) });
-        }
-        try {
-            const fg = reapHostForegroundChildren();
-            if (fg.signalled > 0 || fg.alreadyDead > 0)
-                logger.info("shutdown_foreground_reaped", { signalled: fg.signalled, alreadyDead: fg.alreadyDead });
-            if (fg.failed.length > 0)
-                logger.warn("shutdown_foreground_reap_incomplete", { groups: fg.failed });
-        }
-        catch (err) {
-            logger.warn("shutdown_foreground_reap_failed", { err: String(err) });
-        }
-    };
-    const reapOwnHostWorkspaces = () => {
-        try {
-            const { removed, failed } = reapEphemeralHostWorkspaces();
-            if (removed.length > 0)
-                logger.info("shutdown_host_workspaces_reaped", { removed: removed.length });
-            if (failed.length > 0)
-                logger.warn("shutdown_host_workspace_reap_incomplete", { dirs: failed.map((f) => f.dir) });
-        }
-        catch (err) {
-            logger.warn("shutdown_host_workspace_reap_failed", { err: String(err) });
-        }
-    };
-    const onProcessExit = () => {
-        const onBooks = { foregroundChildren: liveHostForegroundChildCount(), hostWorkspaces: liveEphemeralHostWorkspaceCount() };
-        try {
-            reapOwnChildProcesses();
-        }
-        catch (err) {
-            console.error("shutdown_exit_boundary_child_reap_threw", err);
-        }
-        try {
-            reapOwnHostWorkspaces();
-        }
-        catch (err) {
-            console.error("shutdown_exit_boundary_workspace_reap_threw", err);
-        }
-        const left = { foregroundChildren: liveHostForegroundChildCount(), hostWorkspaces: liveEphemeralHostWorkspaceCount() };
-        try {
-            logger.info("shutdown_exit_boundary", { ...onBooks, leftForegroundChildren: left.foregroundChildren, leftHostWorkspaces: left.hostWorkspaces });
-            if (left.foregroundChildren > 0 || left.hostWorkspaces > 0)
-                logger.warn("shutdown_exit_boundary_incomplete", left);
-        }
-        catch (err) {
-            console.error("shutdown_exit_boundary_log_threw", err);
-        }
-    };
-    process.once("exit", onProcessExit);
+    const exitBoundary = installProcessExitBoundary({ logger });
     const onUncaughtException = (err) => {
         try {
             writeLastWords(err);
@@ -151,7 +94,7 @@ export function installShutdownHandlers(ctx) {
         subRunner.sessions.dispose();
         void lspManager?.dispose?.();
         void workflowNotifyJournal?.close?.();
-        reapOwnChildProcesses();
+        exitBoundary.reapChildProcessesEarly();
         void fleetClient?.stop();
         server.close(() => {
             void retentionTeardown.then(() => (backend ? backend.close() : Promise.resolve())).finally(() => process.exit(0));
@@ -248,7 +191,7 @@ export function installShutdownHandlers(ctx) {
             if (disposed)
                 return;
             disposed = true;
-            process.removeListener("exit", onProcessExit);
+            exitBoundary.dispose();
             process.removeListener("uncaughtException", onUncaughtException);
             process.removeListener("unhandledRejection", onUnhandledRejection);
             process.removeListener("SIGTERM", drainThenShutdown);

package/dist/host-decision.d.ts

@@ -14,7 +14,7 @@
  * ⇒ 本仓的规则从「记住一张词×决定的相容表」变成「说出你知道的那两件事」。相容性也不再靠记忆:一次
  * sweep 不可能 `allow`,core pre-CAS 拒。
  */
-import { type ResumeOutcome } from "@sema-agent/core";
+import { type AskOutcome, type ResumeOutcome } from "@sema-agent/core";
 /**
  * 谁结束了这次等待,以及通道自报的归属。
  *  · `decidedBy: "person"` —— 运维经审批通道做的决定(两条 HTTP `/decide` 腿);
@@ -25,6 +25,33 @@ import { type ResumeOutcome } from "@sema-agent/core";
  *    并把结算记成 `policy_refused`(`who.party:"none"`)。`allow` 侧结构上不可(core pre-CAS 拒:只有人批准)。
  *  · `approver` —— 通道自报的结算方标识串。**缺席永不读成**「没人批」或「有人批」,只意味着通道没报名字。
  */
+/**
+ * core 5.23.0([ref]/[ref]②)—— **宿主自报**的结算来源,`AskOutcome` 对象臂那一格的型。本仓在这一格上有
+ * **两种身份**,合成一只座是刻意的(两只座 = 同一个 wire 位的两个写者):
+ *  · **铸**(本仓自己观察到的事实):只有 `"timeout"` —— 同步 `onAsk` 腿的等待窗归**宿主**所有(引擎不为
+ *    一个它没排程的回调起表),所以「本仓的 TTL 窗走完了、没人答」这件事引擎结构上观察不到,不自报就
+ *    永远被记成「一个人拒绝了」;
+ *  · **转**(调用方在回决体里自报的事实,core 7.26.2 / #1016 起):`settledBy:"policy"` = 答这张卡的是
+ *    **这台部署自己的策略**,不是人。本仓**零判据、原样过境**:词的拒绝逻辑归引擎(`resolveAsk` 对
+ *    自报词表外的值是响亮 fail-closed deny),本仓抄一份词表的那天 core 加词就会被静默 400 掉。
+ * 逐词(词表属主恒是 core):
+ *  · `"human"` —— 与「不铸这个键」逐字同义(core 缺席即按人处理);
+ *  · `"aborted"` —— core **明令拒收**宿主自报(那是引擎自家 fail-closed 端的词,宿主自报等于把自己的
+ *    拒绝改标成引擎故障),所以它**不在** `AskOutcome` 的这一格上,本型也就够不着它。
+ * 类型从 core 的**同步 outcome 面**推导(不手抄):`AskOutcome` 的对象臂上 `settledBy` 是**宿主报的事实**,
+ * core 7.6.0([ref] S6-A)删掉的是那张**结算词表**(`ApprovalSettledBy`),不是这一格 —— 词由 core 从
+ * 这个事实铸(`human_refused` / `approval_window_expired` / `policy_refused`)。core 若改这一格的词表,
+ * 读它的每一处编译期先红。
+ *
+ * 🔴 **S-558:为什么这一格住在本叶子模块**(此前是 `tool-approval.ts` 的模块私有型):来源位随决议
+ * **落持久行**之后,店(`src/plugins/approval-ask-store-sql.ts` 的 `AskRow.settledBy` /
+ * `DecideAskInput.settledBy`)与协调器都要说同一个型 —— 而店不能反向依赖协调器。本模块只依赖
+ * `@sema-agent/core`,与同住的 {@link HostDecidedBy}(耐久腿的同位事实)恰好是一对:一条决议的来源
+ * 在两条腿上是同一件事,型也该在同一处。
+ */
+export type HostSettledBy = NonNullable<Extract<AskOutcome, {
+    allow: boolean;
+}>["settledBy"]>;
 /** 直接取 core `ResumeOutcome` policy_ask 臂的 `hostDecision` 型 —— 本仓不复述那几个词(第二铸点)。 */
 export type HostDecision = Extract<ResumeOutcome, {
     gate: "policy_ask";

package/dist/http/routes/runs.js

@@ -16,7 +16,7 @@ import { scopedIdempotencyKey } from "../idempotency.js";
 import { streamSseLog } from "../sse-log.js";
 import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames } from "../../approval-card.js";
-import { ASK_DECISION_CONSUMER_ABSENT, resolveStreamApprovalGate } from "../../tool-approval.js";
+import { ASK_DECISION_CONSUMER_ABSENT, outcomeOfDecidedRow, resolveStreamApprovalGate } from "../../tool-approval.js";
 import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
 import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
 import { sendJson, sendError, httpErrorCode, sseHeaders } from "../send.js";
@@ -1321,7 +1321,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 return true;
             if (deps.toolApproval?.editedDecisionInFlight(row.askId) === true)
                 return true;
-            const settled = deps.toolApproval?.notifyExternalDecision(row.askId, row.decision === "approve", row.updatedInput);
+            const settled = deps.toolApproval?.notifyExternalDecision(row.askId, outcomeOfDecidedRow(row));
             observedSettled.set(row.askId, settled?.settled ?? 0);
             return true;
         };
@@ -1431,7 +1431,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                         confirmed.decision === body.decision &&
                         confirmed.idempotencyKey === body.idempotencyKey &&
                         !confirmed.provisional) {
-                        const settledNow = deps.toolApproval.notifyExternalDecision(askId, confirmed.decision === "approve", confirmed.updatedInput).settled;
+                        const settledNow = deps.toolApproval.notifyExternalDecision(askId, outcomeOfDecidedRow(confirmed)).settled;
                         deps.logger?.warn?.("ask_decision_edit_settled_after_ambiguous_commit", { taskId, askId, settled: settledNow });
                     }
                 }
@@ -1470,11 +1470,11 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         if (outcome.row.decision !== body.decision) {
             deps.logger?.error?.("ask_decision_row_diverged", { taskId, askId, requested: body.decision, stored: outcome.row.decision });
-            deps.toolApproval?.notifyExternalDecision(outcome.row.askId, outcome.row.decision === "approve", outcome.row.updatedInput);
+            deps.toolApproval?.notifyExternalDecision(outcome.row.askId, outcomeOfDecidedRow(outcome.row));
             sendError(res, 500, "internal.error", "the ask row was rewritten between commit and read-back — the decision that stands is not the one this request submitted; re-read the ask before acting on it");
             return;
         }
-        const settled = deps.toolApproval?.notifyExternalDecision(outcome.row.askId, outcome.row.decision === "approve", outcome.row.updatedInput).settled ?? 0;
+        const settled = deps.toolApproval?.notifyExternalDecision(outcome.row.askId, outcomeOfDecidedRow(outcome.row)).settled ?? 0;
         const forwarded = outcome.row.decision === "approve" && outcome.row.updatedInput !== undefined && settled > 0;
         sendJson(res, 200, {
             askId: outcome.row.askId,

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

@@ -1,5 +1,5 @@
 import { canAskTransition } from "../approval-ask-machine.js";
-import { assertIdempotencyKeyShape, assertIntegralEpochMs, ApprovalAskReadAbortedError, projectAskTerminalClaimTruth } from "./approval-ask-store-sql.js";
+import { assertDecideSettledBy, assertIdempotencyKeyShape, assertIntegralEpochMs, ApprovalAskReadAbortedError, projectAskTerminalClaimTruth } from "./approval-ask-store-sql.js";
 function applyPatch(row, patch) {
     if (patch.decision !== undefined)
         row.decision = patch.decision;
@@ -42,7 +42,7 @@ export class InMemoryApprovalAskStore {
     }
     importRows(snapshot) {
         for (const r of snapshot.asks ?? [])
-            this.asks.set(r.askId, { ...r });
+            this.asks.set(r.askId, { ...r, settledBy: r.settledBy ?? null });
         for (const b of snapshot.batches ?? [])
             this.batches.set(b.batchId, { ...b });
     }
@@ -80,6 +80,7 @@ export class InMemoryApprovalAskStore {
             decision: null,
             decisionActor: null,
             decisionNote: null,
+            settledBy: null,
             decidedAtMs: null,
             deniedReason: null,
             gateToken: null,
@@ -113,6 +114,7 @@ export class InMemoryApprovalAskStore {
     async decideAsk(askId, batchId, decision) {
         if (decision.idempotencyKey != null)
             assertIdempotencyKeyShape(decision.idempotencyKey);
+        assertDecideSettledBy(decision);
         const now = this.now();
         const batch = this.batches.get(batchId);
         if (!batch || batch.state !== "OPEN") {
@@ -139,6 +141,7 @@ export class InMemoryApprovalAskStore {
         ask.decision = decision.decision;
         ask.decisionActor = decision.decisionActor ?? null;
         ask.decisionNote = decision.decisionNote ?? null;
+        ask.settledBy = decision.settledBy ?? null;
         if (decision.updatedInput === undefined)
             delete ask.updatedInput;
         else

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

@@ -41,6 +41,7 @@ import type { Pool as PgPool } from "pg";
 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 IndexSpec } from "./ensure-index.js";
 export type AskDecision = "approve" | "deny";
 export interface AskRow {
@@ -79,6 +80,32 @@ export interface AskRow {
     /** 171 ActorAssertion JSON(车4 才消费,列先在——JSON.parse 后的裸值,类型未知)。 */
     decisionActor: unknown | null;
     decisionNote: string | null;
+    /**
+     * 🔴 S-558(#1016 的持久半场)—— 这条决议的**结算来源**:`null` = 一个人答的(= 缺席律,core 对
+     * 不带这一格的 outcome 逐字按 `"human"` 读),非 null = 宿主自报的那个词(今天 wire 上只开
+     * `"policy"`,词表属主恒是 core —— 见 {@link HostSettledBy})。
+     *
+     * **为什么必须是行上的一格**(病灶,7.93.3 合并树 codex ① 验真):`settledBy` 此前只到达**当次**回决的
+     * 即时回调,行上不留痕 ⇒ 重放 / 再入 / 同 askId 的兄弟等待者 / 歧义提交恢复读回的是裸 `false`,
+     * 而裸 `false` 在 core 那边逐字是「**一个人**拒绝了」—— 模型于是又读到那句「用户不想继续,停下来等他」,
+     * 在一条根本没有人的 run 里。不变量:**一条决议的来源在所有读回路径上是同一个事实**;唯一读回铸点 =
+     * `tool-approval.ts` 的 `outcomeOfDecidedRow`。
+     *
+     * 🔴 **为什么是自己一列,不是塞进 `decision_actor` 那只袋**(S-558 取舍,亲读后定):
+     *  · 那只袋是**自由载荷**——型是 `unknown`(见上一格),读回不过任何 schema(`parseJsonColumn` 返回
+     *    `unknown`),schema 属主在别处([ref] ActorAssertion),`adoption/plan.ts` 的裁定 D2 把它连同
+     *    `decision_note` 一起定为**史实字段,永不改写**。往一只没有属主、没有类型化读回的袋里塞一个
+     *    **执行面**的判别位 = 让一格决定「工具跑不跑、模型读哪一句」的事实寄生在一个只做审计的载荷上。
+     *  · 更硬的一条:**live 回决腿根本不写那只袋**(`respondWithCas` 的 `decideAsk` 入参里没有
+     *    `decisionActor`,列恒 NULL)。来源位进袋 ⇒ 那条腿得为了捎一个词现铸一只它压根没有的 actor
+     *    ——凭空发明「谁按的」,正是 `hostDecisionFacts` 顶注禁的那件事。
+     *  · 一列的代价已经由本仓的 SCHEMA POLICY 定死且**与既有两批加列同形**([ref] 两列、[ref] 一列):
+     *    改 CREATE + 启动期响亮拒(见 {@link assertApprovalAskRuleMaterialSchema}),零 ALTER、零双读、
+     *    老行 NULL 恒读成「人决」。
+     *
+     * 三态收成两态是刻意的:`"human"` 与缺席在 core 那边逐字同义,故店只存「非人」的那些词,`null` 即人。
+     */
+    settledBy: HostSettledBy | null;
     /**
      * [ref]([ref] / [ref] 收口):人批准时带的 **ctrl+g 编辑实参**(wire `updatedInput`),与决议**同一条
      * UPDATE** 原子落列 `updated_input`。语义三态,读法**严格**:
@@ -199,6 +226,14 @@ export interface DecideAskInput {
     decisionNote?: string | null;
     /** 车4 §12-E:回决幂等键,赢 CAS 时随决议一起落列(见 `AskRow.idempotencyKey`)。缺席 ⇒ 列保持 NULL。 */
     idempotencyKey?: string | null;
+    /**
+     * 🔴 S-558:本次回决的**结算来源**,与决议同一条 UPDATE 落列 `settled_by`(语义/两态读法/为什么是
+     * 自己一列,全在 {@link AskRow.settledBy})。缺席 ⇒ 列 NULL ⇒ 读回是「一个人答的」。
+     *
+     * 店**不判词**(词表属主是 core):写什么存什么。店只判**形** —— `assertDecideSettledBy` 的两条
+     * (长度 ≤ 列宽、只与 `deny` 同行),理由见那只门的顶注;三 twin 同判。
+     */
+    settledBy?: HostSettledBy;
     /** [ref]:ctrl+g 编辑实参,与决议同一条 UPDATE 落列(语义三态见 {@link AskRow.updatedInput})。
      *  缺席 / `undefined` ⇒ 列 NULL(没带编辑);**`null` 是值**(编辑成 null),照存 JSON `"null"`。
      *  调用方纪律:deny 不传(店不替调用方判决议方向,写什么存什么)。 */
@@ -233,6 +268,24 @@ export type DecideResult = {
  *  的 deadline 铸点)负责给整数,本守卫只拦漏网。 */
 export declare function assertIntegralEpochMs(field: string, value: number): void;
 export declare function assertIdempotencyKeyShape(key: string): void;
+/** `settled_by` 列宽 = 这一格的唯一尺(两方言 DDL 与下面的形门读同一个常量,不手抄第二份)。 */
+export declare const MAX_SETTLED_BY_CHARS = 16;
+/**
+ * S-558 的**入店卫生门**(三 twin 同判,与 {@link assertIdempotencyKeyShape} / {@link assertIntegralEpochMs} 同族)。
+ * 判的是**形**,不是**词** —— 词表属主恒是 core(`resolveAsk` 对自报词表外的值是响亮 fail-closed deny),
+ * 本层一个词都不认识。两条:
+ *
+ * ① **长度 ≤ 列宽**。`settled_by` 是 `VARCHAR(16)` 的闭集词列,而值来自 wire(两条回决腿只证得出「它是个串」)。
+ *    不拦的话:MySQL 协议侧非严格模式**静默截断**、PG 侧直接报错 —— 同一份调用方代码在两个后端拿到两种
+ *    答案(`assertIdempotencyKeyShape` 的 PAD SPACE 论证逐字同源),而**被截断过的词与原词是两个词**:
+ *    一条决议的来源在库里变成了另一件事。空串同拒(core 那边它不是词,存进去只会读成一个假的「非人」)。
+ * ② **只与 `deny` 同行**。core 的契约明写两个非人词只在 `allow:false` 上合法(`{allow:true,settledBy}` 是
+ *    fail-closed 拒),两条回决腿也都在**裁决之前**照此响亮拒(`tool-approval.ts` 的
+ *    `SETTLED_BY_DENY_ONLY`,两腿共用一份文案)。在店门口再执行一次不是「第二个判官」:判的不是词而是**这一对列能不能共存**。
+ *    收益是结构性的 —— 「approve 行带来源位」从此在写面不可表示,读回铸点(`outcomeOfDecidedRow`)的 allow 臂
+ *    因此**证得出**不会丢掉任何真事实,而不是靠记性。
+ */
+export declare function assertDecideSettledBy(decision: Pick<DecideAskInput, "decision" | "settledBy">): void;
 /**
  * [ref] 车3 刀 3b(§14.2 遗留记账):两条**重放读口**被调用方的 deadline 掐断时抛的具名错误。
  *
@@ -277,6 +330,9 @@ export type AskTerminalClaimCurrent = {
     decision: AskDecision | null;
     /** [ref] 三态读法照 {@link AskRow.updatedInput}:键缺席 = 没带编辑;`null` 是编辑成 null 的值。 */
     updatedInput?: unknown;
+    /** S-558:赢家决议的**结算来源**(语义与两态读法见 {@link AskRow.settledBy})。**必填**(不是可选)——
+     *  可选会让投影漏挑这一列时静默编译过,而漏挑的后果恰是本批要修的病:CAS 输家把赢家的策略拒读成人拒。 */
+    settledBy: HostSettledBy | null;
 };
 /**
  * 单次原子往返的答案(语义律的唯一规范陈述点 = core `checkpoint-store.ts` `claimTerminal` 契约 JSDoc,
@@ -459,7 +515,7 @@ export declare function ensurePgApprovalAskSchema(q: PgQueryFn): Promise<void>;
  *
  * 病:本仓不发 `ALTER TABLE`(SCHEMA POLICY:改列就改 CREATE + 删库重建)。于是一台**没删表**就升上来
  * 的部署,`CREATE TABLE IF NOT EXISTS` 对存量 `approval_ask` 是空操作 —— 本车新加的
- * `rule_command` / `rule_scope_root` 两列不在,而 `ensureAsk` 的 INSERT 与 `ASK_COLS` 的每一条读
+ * `rule_command` / `rule_scope_root` 两列不在,而 `ensureAsk` 的 INSERT 与 `askCols` 的每一条读
  * **无条件**引用它们。后果不是「少一个新功能」,是**整条流内审批协议**在那台机器上是坏的:
  *  · 每一只 ask 的 `ensureAsk` 撞 unknown column ⇒ 被 `noteStoreError` 吞掉 ⇒ 整只 ask 退回 park 路由
  *    (卡不落库、`GET /v1/approvals` 的重放面恒空、迟到决议腿恒 404);