@sema-agent/server 7.145.0 → 7.146.0

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

@@ -4,6 +4,7 @@ import { buildFleetWorkflowRow } from "../fleet/fleet-bus.js";
 import { isTerminalWorkflowRowStatus, seedTerminalWorkflowRow } from "../fleet/fleet-terminal-window.js";
 import { buildParkSessionRows } from "./workflow-agent-session-index.js";
 import { recordFailOpen } from "../observability/fail-open.js";
+import { seatText } from "../trace/exit-seat.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
 export const WORKFLOW_NOTIFY_KEY_DISPOSITION = {
     runId: "carry",
@@ -25,10 +26,8 @@ export function recoverySummary(status, error) {
     if (status === "completed")
         return "workflow completed";
     const base = error ? `workflow failed: ${error}` : "workflow failed";
-    const redacted = base
+    const redacted = seatText("workflow-recovery-summary", base)
         .replace(/https?:\/\/[^\s"'`]+/gi, REDACTION_MARKS.url)
-        .replace(/\b(?:Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi, "[redacted-token]")
-        .replace(/\b(?:api[_-]?key|secret|token|password|authorization)\b\s*[:=]\s*"?[^\s"',}]+/gi, "[redacted-secret]")
         .replace(/(?:\/[A-Za-z0-9_.-]+){2,}/g, REDACTION_MARKS.path)
         .replace(/(?:[A-Za-z]:)?(?:\\{1,2}[A-Za-z0-9_.$-]+){2,}/g, REDACTION_MARKS.path);
     return redacted.length > SUMMARY_MAX ? `${redacted.slice(0, SUMMARY_MAX)}…[+${redacted.length - SUMMARY_MAX} chars]` : redacted;

package/dist/org-delivery-gate.js

@@ -1,6 +1,6 @@
 import { CrossSessionCodecError, MAILBOX_TOMBSTONED_RECIPIENT_CODE, PRINCIPAL_INBOX_HANDLE, peerSessionBoxHandle, mintCrossPrincipalRecord, uuidv7, } from "@sema-agent/core";
 import { principalShapeProblem } from "./security.js";
-import { mailboxKeyProblem } from "./plugins/mailbox-store-sql.js";
+import { mailboxKeyProblem } from "./stores-sql/mailbox-store-sql.js";
 export const ORG_DELIVERY_QUOTA = Object.freeze({ windowMs: 3_600_000, attemptsPerSender: 60, perPair: 10, perRecipient: 30 });
 export const PRINCIPAL_INBOX_BOUND = 50;
 export const ORG_DELIVERY_REFUSAL_MESSAGES = Object.freeze({

package/dist/peer-directory.d.ts

@@ -63,6 +63,9 @@
  *  · `tempo` = `sessionTempoOfRunStatus(lastStatus)`(`plugins/store-contracts.ts` 的那**一张**表,
  *    `GET /v1/sessions` 的 `tempo` 列读的是同一只函数 —— 一处定义两处读);
  *  · `inboundPosture` = managed 层 `crossSessionInbound === "refuse"` ⇒ `"unavailable"`,否则 `"available"`;
+ *  · `occupant` = 会话行的化身(`session_meta.incarnation`,与列表行**同一次读** —— lister 交 `{ row, occupant }`,化身从不进行本身)= 会话腿 acquire
+ *    读到的那一位(core 7.64.0 起跨会话信与回执按 (会话 id, 住客) 投:目录投的若是别的一格,寄往这只会话的每封信都会被判成「给另一位住客的」而丢弃);
+ *    行上没有化身(本仓的店每建一行铸一枚,只有坏行 / 人为改库才缺)⇒ `null`。令牌只进引擎(`ListAgents` 不渲染它),本仓不把它投上 wire / 日志正文;
  *  · `pid` / `procStartMs` / `sockPath` / `cwd` = **恒缺席**(server 会话是耐久可寻址实体,不是进程;
  *    缺席即 core 的探活臂按 `isPeerSessionProcessAlive` 直接跳过);
  *  · `peerProtocol` / `peerFeatures` = 不铸(v1 不声明 CC 能力位;core 侧全 optional)。
@@ -71,18 +74,9 @@ import { type PeerDirectory } from "@sema-agent/core";
 import type { CrossSessionInboundSettingLayers } from "@sema-agent/core";
 import type { Logger } from "./observability/logger.js";
 import type { MailboxRecipientLifecycle } from "./plugins/mailbox-recipient-lifecycle.js";
-import { type SessionListItem } from "./security.js";
-/** 会话枚举面(= `GET /v1/sessions` 用的那只 `OwnerAwareSessionStore.listSessions`)。 */
-export type PeerSessionLister = (opts: {
-    owner?: string;
-    includeUnowned?: boolean;
-    cursor?: {
-        lastActivityAt: string;
-        sessionId: string;
-    };
-    limit: number;
-    q?: string;
-}) => Promise<SessionListItem[]>;
+import { type OwnerAwareSessionStore } from "./security.js";
+/** 会话枚举面(= `GET /v1/sessions` 用的那只列表面的带住客形 `OwnerAwareSessionStore.listSessionRows`:每行配读到它时的住客)。 */
+export type PeerSessionLister = NonNullable<OwnerAwareSessionStore["listSessionRows"]>;
 /**
  * 一次 `listPeerSessions` 最多铸多少行。
  *

package/dist/peer-directory.js

@@ -14,7 +14,9 @@ export function createPeerDirectory(ctx) {
         listPeerSessions: async (access) => {
             const scope = access.scope;
             const includeUnowned = legacyUnownedAmnestyOpen({ requirePrincipal }, scope);
-            const rows = await lister({ owner: scope, ...(includeUnowned ? { includeUnowned: true } : {}), limit: PEER_DIRECTORY_CAP + 1 });
+            const answers = await lister({ owner: scope, ...(includeUnowned ? { includeUnowned: true } : {}), limit: PEER_DIRECTORY_CAP + 1 });
+            const rows = answers.map((a) => a.row);
+            const occupantOf = new Map(answers.map((a) => [a.row.sessionId, a.occupant.incarnation ?? null]));
             const truncated = rows.length > PEER_DIRECTORY_CAP;
             if (truncated) {
                 logger.warn("peer_directory_truncated", {
@@ -88,6 +90,7 @@ export function createPeerDirectory(ctx) {
                     where: "hosted",
                     ...(tempo !== undefined ? { tempo } : {}),
                     inboundPosture: posture,
+                    occupant: occupantOf.get(r.sessionId) ?? null,
                 });
             }
             if (ungrammatical > 0) {
@@ -129,6 +132,7 @@ export function createPeerDirectory(ctx) {
                     where: "hosted",
                     diedAt: t.retiredAt,
                     inboundPosture: posture,
+                    occupant: null,
                 });
             }
             return out;

package/dist/plugins/caching-session-store.d.ts

@@ -68,7 +68,9 @@ export declare class CachingSessionStore implements SessionStore {
         limit: number;
         q?: string;
     }) => Promise<SessionListItem[]>;
-    readonly fork?: (sourceId: string, owner: string | null) => Promise<string | null>;
+    /** 带住客的同一只列表面(原样转发;理由同 listSessions)。 */
+    readonly listSessionRows?: OwnerAwareSessionStore["listSessionRows"];
+    readonly fork?: OwnerAwareSessionStore["fork"];
     /** fork 续写的店契约(原样转发;与 fork 同理绕过暖缓存 —— 读写的是持久行,新 id 本来就不在缓存里)。 */
     readonly forkTo?: OwnerAwareSessionStore["forkTo"];
     /** 执行席(原样转发:放置是会话**行**上的一格,缓存只缓存会话日志的暖句柄,不缓存行格 —— 读与写都直达内层店)。 */

package/dist/plugins/caching-session-store.js

@@ -10,6 +10,7 @@ export class CachingSessionStore {
     headOf;
     register;
     listSessions;
+    listSessionRows;
     fork;
     forkTo;
     executionPlacement;
@@ -58,6 +59,8 @@ export class CachingSessionStore {
             this.register = ownerAware.register.bind(inner);
         if (ownerAware.listSessions)
             this.listSessions = ownerAware.listSessions.bind(inner);
+        if (ownerAware.listSessionRows)
+            this.listSessionRows = ownerAware.listSessionRows.bind(inner);
         if (ownerAware.sessionSummaryOf)
             this.sessionSummaryOf = ownerAware.sessionSummaryOf.bind(inner);
         if (ownerAware.writeSessionRowCells)

package/dist/plugins/checkpoint-store-face.d.ts

@@ -0,0 +1,426 @@
+/**
+ * 检查点店的**服务面**:两只孪生(SQL 孪生 `stores-sql/checkpoint-store-sql.ts`、LOCAL 孪生 `local-checkpoint-store.ts`)共同实现、服务的读点
+ * (运维队列 / 审批决断 / 续跑腿 / 流内审批收敛器 / 起服普查)共同读的那一层 —— 引擎的 `CheckpointStore` 契约之外、本服务自己定的东西:
+ *  · 行形:运维队列行 {@link PendingCheckpoint}、流内审批候选行 {@link CheckpointAskCandidate}、已决回放行 {@link DecidedApprovalRecord};
+ *  · 读口的行绑定 {@link PendingRowBinding} 与门型两分({@link LIVE_RUN_GATE_KINDS} / {@link TERMINAL_PARK_GATE_KINDS}),两孪生同序判据 {@link pendingRowPrecedes};
+ *  · 两孪生同调的纯判据与投影:{@link queueRowGateKind}、{@link boundedToolInput}、{@link boundedRuleOffers}、
+ *    {@link approvalDecisionOfWinner}、{@link candidateIdentityOf};常量 {@link TERMINAL_BACKSTOP_MS} / {@link TERMINAL_GRACE_MS} / {@link DECIDED_REPLAY_SCAN_CAP};
+ *  · ctx 两口的结局词 {@link CtxClaimRewrite} 与一次性迁移的 ctx 行改写店腿的型(随最后一条用它的迁移删,见 {@link CheckpointCtxRowsRewriter});
+ *  · 店拒绝契约里「一行字节读不成检查点」那一只 {@link UnreadableCheckpointRowError}(SQL 孪生抛、续跑腿认)。
+ *
+ * 为什么单成一只模块(依赖方向律 R8,`test/dependency-direction-gate.test.ts`):SQL 孪生住在 `src/stores-sql/`,那只目录要能原样搬进引擎侧的包,
+ * 目录外除组合座外**谁也不得直引它**。这一层的读者遍布服务(LOCAL 孪生、HTTP 续跑腿、审批决断、收敛器、运维队列的 wire 键表),所以它不能住在
+ * SQL 孪生的文件里;它住这里,SQL 孪生经一条点名的已知欠边借它 —— 这一条边就是阶段三搬家时「服务特有面」的清单(向引擎请托的候选,只列不发)。
+ * 这里零 SQL:SQL 文本、列读法与行投影仍在 SQL 孪生里。
+ */
+import { type Checkpoint, type CheckpointGate, type CheckpointRowVerdict, type GateOutcome, type ResolvedOutcome, type RiskDescriptor, type ToolApprovalCard } from "@sema-agent/core";
+import { type ParkRowFacts, type RuleOfferProjection, type SkillCardFacts } from "../approval-card.js";
+import { StoreCorruptError } from "./sql-json-column.js";
+import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
+/** ctx 行改写店腿的读数(两孪生同形):扫到的可读行 · 回写成的行 · 回写成的行里改写函数报的改动数 · 读不出的行 · 改写之后一行装不下的行。 */
+export interface CtxRowsRewrite {
+    readonly scanned: number;
+    readonly rewritten: number;
+    readonly valuesRewritten: number;
+    readonly unreadable: number;
+    readonly tooLarge: number;
+}
+/** 一行的改写:交回新的落盘形(只有封口模块的铸点产得出 —— 品牌型)与这一行的改动数;`undefined` = 这一行不写。 */
+export type CtxRowRewrite = (sessionId: string, ctx: object) => {
+    readonly ctx: SealedCheckpointCtx;
+    readonly values: number;
+} | undefined;
+/**
+ * 🔴 **一次性迁移的 ctx 行改写店腿**(两孪生:`SqlCheckpointStore` / `LocalCheckpointStore` 的 `rewriteCtxRows`;逐行判词两孪生同):扫全部 `checkpoint_ctx` 行、
+ * 交给 `rewrite`、交回新体的行原地回写(续跑时钟不动)。店不知道改写是什么 —— 用它的迁移各自带行改写:M28(凭据位明文封好)、M30(退役请求键改写)。
+ * 窗与删法逐条在 `plugins/one-time-migrations.ts` 登记表;登记表里最后一条用它的迁移删码时,本腿、读数型与扫描页一起删。
+ */
+export interface CheckpointCtxRowsRewriter {
+    rewriteCtxRows(rewrite: CtxRowRewrite): Promise<CtxRowsRewrite>;
+}
+/**
+ * [ref] D-1 (§3 invariant #3 — crash-safe reaper backstop): an ABSOLUTE upper bound on a pending
+ * checkpoint's lifetime, stamped at put() into `terminal_at_ms` INDEPENDENT of the per-approval `deadline`. The
+ * SLA-timer (D-D) does the fine, per-gate-kind resolve-deny; THIS coarse backstop ensures even a pending row
+ * with a NULL `deadline` (no approval TTL configured) is eventually GC'd if the SLA service dies — closing a
+ * forever-leak of a never-resolved suspension (the current `reap`/`reapExpired` only catch non-NULL deadlines).
+ * Generous (default 30d) so it never pre-empts a legitimately long-lived human/irreversible_ask gate;
+ * env-overridable. Clamped ≥1min so a misconfig can't expire live suspensions instantly.
+ */
+export declare const TERMINAL_BACKSTOP_MS: number;
+/**
+ * [ref] D-D (cross-review fix): the crash-safe `terminal_at_ms` backstop must fall STRICTLY AFTER any SLA
+ * `deadline`, never AT it. `terminal_at_ms = max(createdAt+backstop, deadline)` made the two coincide whenever an
+ * operator tuned APPROVAL_TERMINAL_BACKSTOP_MS at/below the SLA — and reapExpired's terminal_at_ms-branch (which
+ * has NO gate_kind filter) then abort-EXPIRED a human/irreversible_ask gate in the SAME tick the deny-sweep
+ * wanted to gracefully DENY it, racing it away. Adding this grace to the deadline term guarantees the deny-sweep
+ * at least this window of clean ticks before the absolute backstop can fire. Far smaller than the backstop, so
+ * it never meaningfully delays the eventual crash-safe GC.
+ */
+export declare const TERMINAL_GRACE_MS = 3600000;
+/** Non-secret view of a pending checkpoint for the operator approval queue — deliberately NO token.
+ *
+ *  🔴 [ref]:行**顶层**另带 {@link ParkRowFacts}(`requiresRealApproval` / `ruleOffersAbsence`,真才带、缺席 ≠ false)——
+ *  型与值都只有一个来源:`approval-card.ts` 的 {@link parkRowFacts}(两只店各读自己手里的那只寄存行 `pendingAction`,
+ *  交给它、原样展开)。继承而不是在这里逐键再写一遍:core 给这一臂再加一位同类事实时,改的只有那张 Pick 表。
+ *
+ *  [ref]:授予绑定那一臂(`boundGrantDigest` / `boundGrantAbsence` 恰带其一)是 {@link ParkRowFacts} 的一部分,同样读自寄存行。
+ *  技能卡两位({@link SkillCardFacts}:`boundGrants` / `classifierNoRuling`)另有一只投影 {@link skillCardFacts},输入是 core 的检查点摘要而不是
+ *  寄存行原值(清单只在哈希等于摘要时才配上 wire,校验点单点在 core —— 见 {@link skillCardFacts} 顶注);同一张行上与收件箱行逐字同值,在场才带。 */
+export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
+    sessionId: string;
+    /**
+     * 这道停驻门的**非秘密稳定身份**(core `Checkpoint.checkpointId`,引擎每次停驻铸)—— 三处 durable 读面(本行 = `GET /v1/approvals` 的 `pending[]`
+     * 与 `/v1/approvals/stream` 的 `pending` 帧;停驻收件 `GET /v1/assistant/inbox` 的 `inbox[]`)共用的 **join 键**,也是 409 载体 A
+     * `pendingGate.checkpointId` / `terminal.paused.checkpointId` 的同一个值。**在场就是可信的那一个值,缺席就是缺席**:读法唯一 = `checkpoint-identity.ts` 的
+     * `durableRowIdentity`(过信任边界 —— 不含 token、有界),没有它的行(core 5.42.0 之前停驻的老行 / 没过边界的值)**照列**、键缺席(这一行没有可 join 的身份)、
+     * 每行计一次 `server.approvals.durable-row-checkpoint-id-missing`。两只店各读自己手里的那一份(SQL 孪生读 `checkpoint` 列的成员,LOCAL 孪生读 blob)。
+     */
+    checkpointId?: string;
+    scope: string;
+    toolName: string | null;
+    toolCallId: string | null;
+    /** [ref] D-1: the decision-action binding fields the operator/portal must ECHO back on /decide so the
+     *  resume binds to the EXACT action they saw (a stale view is then rejected fail-closed PRE-CAS). `boundCallId`
+     *  === `toolCallId` (the pending tool call); `boundInputHash` is the server-minted opaque hash of the shown
+     *  input (NEVER recomputed by the portal — echoed verbatim). Surfacing them here is what makes the D-1 TOCTOU
+     *  guard REACHABLE by the portal (without it the portal can only do the unbound legacy fallback).
+     *  🔴 [ref]②: ABSENT (key omitted, never `null`) on a park with no tool action (plan_review /
+     *  resource_limit / task_done) or a pre-D-1 legacy row ⇒ the consumer falls back to the unbound resolve.
+     *  The wire contract (§1) is "an absent nullable field is OMITTED, not null" — a `null` here invited a
+     *  consumer to treat the key's PRESENCE as "there is a binding" and echo `null` back into /decide. */
+    boundCallId?: string;
+    boundInputHash?: string;
+    /** 🔴 [ref]③: the checkpoint's gate kind — the operator queue mixes tool approvals with
+     *  plan_review / resource_limit / task_done parks (all of which carry `toolName: null`), so a durable-recovery
+     *  consumer needs this to ROUTE a row to the right wire (`/decide` vs `/plan_review` vs `/resume`). ALWAYS present
+     *  ([ref], 7.132.0): every park stamps it, the one-time migration M21 filled any row without it from the row's gate,
+     *  and a SQL row that still carries none is not listed by `listPending` (counted: `server.approvals.queue-row-gate-kind-missing`; no decide route binds it either). */
+    gateKind: CheckpointGate["kind"];
+    /** The suspended run's taskId (task_active join) — the key to the run/trace ("view task context"). */
+    taskId: string | null;
+    /** The pending tool call's args (post-hook), redacted + bounded — for tool_approval the write payload, for a
+     *  durable AskUserQuestion the question itself. Lets the approval card render WITHOUT an N+1 trace.turns
+     *  fetch. `null` for pre-migration rows (suspended before the column existed) ⇒ consumer falls back. */
+    input: unknown;
+    createdAt: number;
+    deadline: number | null;
+    /** [ref] riskDescriptor inbox: core's INERT triage descriptor ({severity 1-5, axes, toolName, redacted
+     *  summary, touchedPaths}) for human/irreversible_ask gates. listPending returns the queue severity-sorted
+     *  (DESC) so the supervisor inbox triages high-risk asks first. `null` for gates with no descriptor. */
+    riskDescriptor: RiskDescriptor | null;
+    /**
+     * [ref]-2 / [ref]② 起役;core 5.58.0([ref])换 OFFER 判别联合形:这条 park 的「不再询问」
+     * offers —— core 在 mint 这道门时挂到 `pendingAction.ruleOffers` 上的那一份(core
+     * `checkpoint-store.d.ts` 明写与同步腿的 `AskRequest.ruleOffers` 是**同一条契约**:序即契约——
+     * whole-string exact `single` 在场时恒 index 0、`batch` 恒末位,core 契约基数 ≤2 —— server 侧执法帽
+     * 是 `MAX_RULE_OFFERS`=4 的容忍余量,两个数的分工见该常量顶注)。
+     *
+     * 🔴 **本腿的下标不是 core 的 offer index,别把它当选择键**(5.58 复审 F-3,与契约文同批改准)。
+     * core 的契约原话是:丢掉不认识的成员时**必须保住每个留下来成员的原始 wire 下标**,做不到的消费端
+     * 「must suppress its persistence actions entirely (fail toward asking)」。本腿走的是**后者** ——
+     * {@link boundedRuleOffers} 对形不合的 offer 是**逐条丢弃并压紧**的(一条坏 offer 不该让另一条真 offer
+     * 消失,这条不变量本身有它自己的红格),压紧就意味着中间剔除会让后面的下标整体前移。之所以站得住,
+     * 是因为**本腿没有兑付口**:durable 回决体(`/v1/approvals/:id/decide`)不带规则位,选择键一次都没有
+     * 用到本腿的下标。⇒ **硬条款**:哪天 durable 腿真要开兑付位,先把「原始下标随行」显式加进本投影
+     * (或按 core 的另一半整格不投),而不是默默拿压紧后的下标当选择键。
+     * 与**同步腿**刻意分家:`buildRuleLaneMaterial` 那侧是**纯前缀截、零逐条丢弃**,所以活卡帧 /
+     * `card_json` / 重放帧上的下标**恒等于** core 的 offer index —— 兑付真发生在那条腿上。
+     *
+     * 🔴 **混舰队旧行(pre-5.58 的 `ruleSuggestions` 数组,无 `kind` 判别位)**:按新 Raw 形逐条不合
+     * ⇒ 整格落「无供给」——与 [ref] 升级单的舰队条款一致(旧建议面丢失只影响展示,ask 安全面照常;
+     * pending 审批短命,重触发即得新形卡)。**不做兼容读**(schema stale=重问,core 同款纪律)。
+     *
+     * 🔴 **无供给 ≠ 丢失**(本键存在的全部理由):同步腿的卡带这一格(`card_json` 里逐字在),而耐久腿
+     * (park 行 → `GET /v1/approvals`)此前**根本没投**,于是同一张卡走 durable 路时「不再询问」那一格
+     * 恒空 —— 消费端只能读成「本部署不供候选」。本键把 core 真给的那份带上 wire,缺席从此是**真的**没有
+     * 候选(规则车道没武装 / 命令说不出规则 / 这只 ask 规则清不掉),而不是投影层漏了。
+     *
+     * 🔴 **只在为真时在场**:core 不给 ⇒ 键**缺席**(不铸 `null`、不铸 `[]`)——与 `boundCallId`/`gateKind`
+     * 同一条 wire 纪律([ref]②「absent nullable field is OMITTED, not null」)。存量行(本列存在之前
+     * park 的)读回同样是缺席,与「这只 ask 没有候选」在消费端读法一致:本卡无此选项。
+     *
+     * 🔴 **展示用,永不参与 resume**:core 侧同款定性(「never read by the resume path, and never a rule by
+     * itself」)。本仓耐久腿今天也没有兑付口(`/v1/approvals/:id/decide` 的体不带规则位),所以它是**分诊
+     * 材料**不是承诺 —— 消费端渲这一格时要按「同副本活卡腿才兑得动」读(同 `ApprovalCardSchema.ruleOffers`
+     * 顶注那条射程说明)。
+     */
+    ruleOffers?: readonly RuleOfferProjection[];
+    /**
+     * [ref]①([ref]② / [ref];core 5.60.0 [ref]):**bidi 在场位**的耐久运维队列投影 —— 这条 park 行的
+     * 执行载荷里含至少一个 DIRECTIONAL 格式控制符(人眼读到的顺序与真正执行的字节顺序可能不同)。
+     *
+     * 值**完全由 core 供**:park mint 时 core 写在 `pendingAction`(tool_approval 臂)上的那一位
+     * (`PendingAction.hasBidiControls`,core [ref]),`put()` 在铸行
+     * 这一刻反范式成 `checkpoint.has_bidi_controls` 列(同行 `tool_input` / `bound_input_hash` / `gate_kind` /
+     * `risk_descriptor` / `rule_suggestions` 五列同一条「铸行时一格、读口零 blob」先例),server 不重算。
+     * ([ref] 起本读口**确实**逐行读 blob —— 只为 {@link ParkRowFacts} 那几位,且是按「本仓不发 ALTER TABLE、
+     * 加列 = 删库丢在飞 park」裁出来的代价,见 `listPending` 那一段;本位与五列的「铸行时一格」形不变。)
+     *
+     * 🔴 `true` **或缺席,恒不写 `false`/`null`**(core d.ts 的 OMIT 契约逐字点名 BFF:「never null, never
+     * present-but-undefined, never false」):缺席 = **没检出**(干净 / core 的有界扫描没够着 / 本列诞生前
+     * park 的老行),消费端**禁**读成「已确认干净」。与 `/v1/assistant/inbox` 那面的同名键同一份语义
+     * (那面由 `summarizeCheckpoint` 对老行做投影期回填;本面读列不读 blob,老行恒缺席 —— 两面的缺席
+     * 集合因此不完全相等,但两面对「缺席」的读法逐字相同)。同步腿(`tool_approval` 帧 / `approval_request`
+     * 卡)的对应键是 `inputHasBidi`(E-14),名字刻意不同:那一位是 server 对帧自身序列化后的 args 算的。
+     *
+     * 展示/分诊用,永不参与 resume / gate / CAS(core 同款 ECHO-ONLY 定性)。
+     */
+    hasBidiControls?: true;
+    /**
+     * core 7.49.0 [ref]:**这一行渲在哪张卡上** —— 门上引擎铸的 `gate.approvalCard`(闭集 core `TOOL_APPROVAL_CARDS`;`question` = 问用户的
+     * 问题,不是副作用工具),即 core `summarizeCheckpoint` 投给 `CheckpointSummary.approvalCard` 的同一个词。读法单点 = `approval-content-kind.ts`
+     * 的 `parkedApprovalCard`(只在审批门型上读、闭集窄读;两只店同调它:SQL 孪生读 `checkpoint` 列的 `gate` 子树,LOCAL 孪生读 blob 上的门)。
+     * 🔴 缺席即缺席([ref]② OMIT 纪律):非审批门、7.49.0 之前停驻的存量行(门上无卡 —— core 的读法「无卡 = 不是一问」,本仓**不**从
+     * 工具名回推)。两条 durable 读面(`GET /v1/approvals` 行 + `/stream` `pending` 帧)经同一投影同时携带;live 腿的同名键在
+     * `LivePendingRow.approvalCard`。展示/分诊用,永不参与 resume / gate / CAS。(此前此处是按 `tool_name` 列派生的 `contentKind`,随 [ref] 删。)
+     */
+    approvalCard?: ToolApprovalCard;
+    /**
+     * 这一行**本引擎续不续得了** —— core 判官 `judgeCheckpointRow` 对这一行盘上字节的判决(core 7.62.0 [ref];与助手收件箱行的 `rowVerdict`、
+     * 续跑在第一级读到的拒同一个读者、同一答),逐字投、本服务不重算不筛。判官要整行:SQL 孪生按 (库内算的 `checkpoint` 文本 sha256, 引擎构建)
+     * 记忆({@link StoredRowProjectionMemo}),未命中才按令牌批读整行;LOCAL 孪生取 core 店摘要上的同一位。
+     * 盘上字节读不成一只检查点的行(体是 `{}`、缺 `state`、JSON 字面 `null` / 标量 / 数组 / 非 JSON)同样判:判官对任何值都答,这种行答 `damaged`,
+     * 行照列(计 `server.approvals.park-row-blob-unreadable`)—— 一行坏字节只坏它自己那一行,见 {@link SqlCheckpointStore.readStoredRow}。
+     * **在场 ⇔ 这一次列表判过这一行**:缺席只在 SQL 孪生上出现 —— 两次读之间行已离开待决,或两次读之间行的字节变了(判过的是另一份,
+     * 不拼到这一行上;下一次列表即带)。缺席**不是** `ok`。非 `ok` 的行照列(人要看到它停在哪)。
+     */
+    rowVerdict?: CheckpointRowVerdict;
+}
+/**
+ * [ref]([ref] / DEBTS [ref]):session 键读口(`findPendingTokenBySession` / `peekPendingScope`)的**行绑定**。
+ *
+ * 病灶(本仓自己两处成文:`server.ts` mintFreshRun 腿 409 段、`active-run-conflict.ts` `checkpointId` 顶注):
+ * `checkpoint` 表**没有** per-session pending 唯一约束 —— 同一 session 下 `task_done` 纯 park(行已终局、
+ * `task_active` claim 已释放)与下一条 run 的门 park **合法并存**;而两条读口此前是**无序 `LIMIT 1`**,同
+ * session 两条 pending 时选中哪一条由存储引擎的扫描序决定:同一情形两次调用可能答出两张不同的门,路由层
+ * 的 owner 门(`peekPendingScope`)与 `resumeCheckpoint` 的载入(`findPendingTokenBySession`)更可能各读到
+ * 一条([ref] codex R3 揭的 tokenless TOCTOU 同源;[ref] 在取用点加了行级属主复核 = 下游兜底,本件是源头)。
+ *
+ * 为什么不是加唯一约束:那两条行的并存是**设计内**的形(见上),约束会把新 run 的 park `put()` 当场打死
+ * (core 的 `CheckpointStore.put` 契约不允许);且 MySQL-protocol 侧没有部分唯一索引,TiDB 上要靠生成列
+ * 绕,两方言分歧成本高于收益。
+ *
+ * 修法 = **读口带 gate 坐标 + 显式序**:
+ *  · `gateKinds` 在场 ⇒ 只认这些门型的 pending 行(每条 resume 腿本来就只服务一种门型 —— decide 只解
+ *    审批门、wake 只解 `task_done`、preempt 只解 `resource_limit`、plan_review 只解 `plan_review`;把
+ *    这条已成文的守卫**前移到读口**,选错行这件事结构上不再发生)。**空数组 = 什么都不认**(显式 `1=0`,
+ *    不静默退化成「任意门型」)。缺席 ⇒ 任意门型(存在性读口:boot reclaim / reaper probe / 断连竞态卫兵)。
+ *  · 无论绑不绑,序恒为 `created_at_ms DESC, token DESC`(**最新优先**,主键兜平局):同一情形下每次读
+ *    都答同一行;两条读口共用同一段谓词 + 同一段序({@link SqlCheckpointStore.pendingRowQuery} 单一属主),
+ *    路由门与载入点结构上选中同一行。最新优先的理由:并存形里**老**的那条恒是终局后的 `task_done` 纯 park,
+ *    活 run 的门在它之后铸。
+ *
+ * SQL twin 与 LOCAL twin 同判(local 侧按 `cp.gate.kind` 过滤、按 `createdAt`/token 同序取最新)。
+ */
+export interface PendingRowBinding {
+    /** gate 坐标:只认这些门型的 pending 行(core `CheckpointGate["kind"]` 闭集)。缺席 ⇒ 任意门型。 */
+    gateKinds?: readonly CheckpointGate["kind"][];
+    /**
+     * 并存候选里取哪一端(缺省 `"newest"`)。两个取向各有一个**结构性**的消费者,别混用:
+     *  · `"newest"`(缺省)—— 「活 run 的门」族:并存形里老的那条恒是终局 task_done 纯 park,活 run 的门
+     *    在它之后铸 ⇒ 最新即正解;
+     *  · `"oldest"` —— **跨副本收敛**族(wake-mint 赢家复核 + wake 消费腿;codex 审批面轮 R2-[medium],
+     *    验真后修):收敛要的是一个**与自己的铸行时刻无关**的不动点。最新优先下「后铸者恒自选」——两副本
+     *    并发铸 task_done park 时,后铸的 B 复核必选中刚铸的自己,先铸的 A 若在 B 落盘前复核也选中自己,
+     *    两行双双留存、消息被拆到两张卡上。最老优先没有这个洞:**后铸者复核时先铸行必然已在**(它比自己老
+     *    ⇒ 选中它、expire 自己),先铸者无论何时复核都选中自己 ⇒ 不动点唯一。消费腿(/wake)取同端,
+     *    赢家卡与被消费卡恒同一张(FIFO 顺带成立)。
+     */
+    pick?: "newest" | "oldest";
+}
+/** [ref]:一条**仍持有 claim 的 run** 可能停在的全部门型(= 除 `task_done` 外全部;派生自上表,不手抄)。
+ *  给「按 run 行动」的读口用:cancel / steer 的 park 落点、409 `pendingGate` 材料 —— 这些腿手里有 run 行,
+ *  而 run 行一旦 parked 就绝不是 `task_done`,绑上它就把同 session 那条终局 park 排除在候选之外。 */
+export declare const LIVE_RUN_GATE_KINDS: readonly CheckpointGate["kind"][];
+/** [ref]:终局后纯 park 的门型(wake 腿 / wake-mint 赢家复核只认它)。 */
+export declare const TERMINAL_PARK_GATE_KINDS: readonly CheckpointGate["kind"][];
+/**
+ * [ref]:LOCAL twin 与测试共用的**同序判据**——「候选集里哪一条是读口该答的那条」。与 SQL 的
+ * `ORDER BY created_at_ms {DESC|ASC}, token {DESC|ASC} LIMIT 1` 逐字同义(token 列两方言都是二进制序 ——
+ * MySQL `utf8mb4_bin` / PG `COLLATE "C"`,token 是 ASCII ⇒ JS 字符串比较与之同序)。
+ * 返回 `true` 表示 `a` 应排在 `b` 前面(缺省最新优先;`pick:"oldest"` 时最老优先,取向语义见
+ * {@link PendingRowBinding.pick})。
+ */
+export declare function pendingRowPrecedes(a: {
+    createdAt: number;
+    token: string;
+}, b: {
+    createdAt: number;
+    token: string;
+}, pick?: "newest" | "oldest"): boolean;
+/**
+ * `pendingAction.ruleOffers` 的**铸行侧**投影(mint 面,与 {@link boundedToolInput} 同位同待遇)。
+ *
+ * 四件事,一件都不能少:
+ *  1. **读**(宪法 [ref] 边界必判形 / 禁裸 as-cast):blob 里的这一格是 `unknown`(旧 core / 坏行 / 未来加字段都可能)。读者只有一只 =
+ *     core `readRuleOffers`(经 `approval-card.ts` 的 {@link readRuleOfferList};core 7.55.0 [ref] P1 阶段二起,修前本仓自己一份 zod 形):读不出的**整条丢弃**
+ *     (不是整只丢弃)——一条坏 offer 不该让另一条真 offer 消失;多余键逐级剥、不拒收(上游 additive 加一键是 core 的常规做法,拒收会把「有供给」静默变成「无供给」);
+ *     丢弃**响亮**(`server.rule-offers.offer-dropped`,修前这一腿静默)。
+ *  2. **脱敏**:offer 文本是从**命令原文**铸出来的(`Bash(curl -H "Authorization: Bearer …")` 这种 exact
+ *     形拼得出秘密),而 `GET /v1/approvals` 是**跨租户可见**的运维队列。落列前过 `redactSecrets` ——
+ *     与同行 `tool_input` 在 mint 就 `redactDeep` 是**同一条**纪律(秘密从此连**落库**都不落,不是落了库再在两条读面各洗一遍)。
+ *  3. **脱敏之后**才截长(codex 交叉复审 [medium],验真后修):`redactSecrets` 会**变长**,先按限长校验
+ *     原文再脱敏会产出超限文本,而 SQL 腿有**回读**(列 → 本函数再跑一遍)、LOCAL 腿没有 ⇒ 同一份素材
+ *     两个后端给出不同卡面。顺序反过来之后本函数对自己的输出**幂等**,两条腿同形。
+ *  4. **限基数**:core 契约今天 ≤2,这里按 {@link MAX_RULE_OFFERS}(=4,server 侧容忍帽,两个数的
+ *     分工逐字见该常量顶注)截;`batch.rules` 成员另按 {@link MAX_RULE_OFFER_BATCH_MEMBERS}(=8)截 ——
+ *     一条被改坏/未来放宽的上游不该把运维队列的一行撑爆。两个截都是**前缀截**(保序)。
+ *     ⚠️ **但本函数整体不保原始下标**:第 1 条的「坏的逐条丢」会压紧数组 ⇒ 中间剔除后下标前移。
+ *     本腿因此是**纯展示腿**,下标不得当选择键 —— 硬条款与它站得住的理由逐字见
+ *     {@link PendingCheckpoint.ruleOffers} 顶注(同步腿相反:那侧零逐条丢弃,下标恒等于 core 的 offer index)。
+ *     🔴 **成员帽扣在读之前**(5.58 复审 F-2):见 {@link preboundBatchMembers} —— offer 条数那一维由
+ *     {@link MAX_RULE_OFFER_SCAN} 管,成员那一维在那之前是**无界**的。
+ *     🔴 **扣预算在读出之后**(合并码重扫):旧序先 `slice` 再判形,于是 ≥MAX 条坏 offer 能把唯一的真
+ *     offer 挤出预算,读数是 `undefined` —— 与上面第 1 条自证的不变量(坏的丢、好的照投)正相反。扫描窗
+ *     {@link MAX_RULE_OFFER_SCAN} 仍是有界的:一条被改坏成上万条的行不该让每 3s 一拍的读路径去逐条判形。
+ *
+ * 🔴 `opts.countRedactions`:**两条腿都照常脱敏,只有回读腿不计数**(合并码重扫;codex 复审第一轮
+ * 指出「回读不脱敏」会把纵深防御一起关掉,验真后按这条收)。`redactSecrets` 对自己的输出是**值幂等、
+ * 计数不幂等**(URL-userinfo / JSON 秘密字段两条 pattern 会命中自己的输出并再计一次),而回读腿正是
+ * `/v1/approvals/stream` 每 3s 一拍的热路径 ⇒ 每条订阅每行每拍给 `redactions_applied_total` +1,把那个
+ * 用来识别「过度脱敏 / pattern 从不触发」的指标灌成不可读。关掉的是**计数**:重扫仍在,手改过的行 /
+ * 将来某条写路径漏了脱敏,读面照样兜住(运维队列跨租户可见,少脱一次的代价永远不能省)。
+ *
+ * 返回 `undefined` = **无供给**(键不落列):core 没给、给了空数组、或整只读不出。
+ */
+export declare function boundedRuleOffers(raw: unknown, opts?: {
+    countRedactions?: boolean;
+}): RuleOfferProjection[] | undefined;
+/**
+ * {@link SqlCheckpointStore.get} 读到的 `checkpoint` 列字节读不成一只检查点(JSON 字面 `null` / 标量 / 数组 / 非 JSON)时抛的拒 —— 就是店的拒绝契约类
+ * {@link StoreCorruptError}(`kind:"corrupt"` + 坐标,所有认它的读口原样认它),外加**引擎判官对这一格原样字节的判决**:列表面对同一格答的就是它
+ * ({@link verdictOfUnreadableBody},`rowVerdict`),所以决断口("行自己拒")说的出路句取这一只判决的 `sentence`、不另铸(决断口 {@link rowRefusalMessageOf})。
+ * 判决在抛的这一拍现算(纯函数、全函数,不读钟不读库);店自己的诊断(`message`:坐标 + 体的问题)原样保留。
+ */
+export declare class UnreadableCheckpointRowError extends StoreCorruptError {
+    /** 判官对这份字节的判决(读不成检查点的字节判官恒答 `damaged`;类型面不替它断言)。 */
+    readonly rowVerdict: CheckpointRowVerdict;
+    constructor(corrupt: StoreCorruptError, rowVerdict: CheckpointRowVerdict);
+}
+/**
+ * [ref] —— 运维队列行的门型:**两只孪生同一只判官**(SQL 孪生读 `gate_kind` 列 —— put 时从同一只门反范式下来的那一格,每次停驻都盖,一次性迁移 M21 把没有它的
+ * 存量行从门子树补齐;local 孪生读快照上的门 `cp.gate.kind`)。
+ * 读到的值是 NULL / 缺席 / 不是 core 登记的门型 ⇒ `undefined`:这一行**不列**(响亮:计一次 `server.approvals.queue-row-gate-kind-missing`)—— 与每一条决断口同一个读法:
+ * 按门型绑定取行的读口对这种行本来就不命中(`pendingRowQuery` 的 `gate_kind IN (…)`,证不出门型就不当它是这道门),队列不再把一行谁也决不了的行投出去,
+ * 也不按缺键投(消费方按 `gateKind` 路由、缺键即 fail-closed)。不整只拒:一行坏行不许让整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧)消失。
+ * 按构造不可达(写口恒盖、M21 补齐);计数非零 = 写腿或手改出了错,按 `SELECT … WHERE status = 'pending' AND gate_kind IS NULL` 查那一行。
+ */
+export declare function queueRowGateKind(kind: unknown): CheckpointGate["kind"] | undefined;
+/** Redact + size-bound a pending tool call's args for persistence/serving. JSON-roundtrips so the stored shape
+ *  matches what the operator queue serves; oversized payloads collapse to a marker rather than bloating the row.
+ *  Exported for the LOCAL twin (local-checkpoint-store.ts) so the operator-queue projection can't drift. */
+export declare function boundedToolInput(args: unknown): unknown;
+/**
+ * 🔴 [ref] 车5 §9 C4:`findCheckpointCandidatesForAsk` 的 typed 候选行。刻意只有对账收敛器判据 1 真需要的
+ * 五件——**没有 token 之外的任何凭据面**,`token` 本身是 resume 凭据、只在服务端内部流转(同
+ * `findPendingTokenBySession`:它从不出网,§12-C「checkpointToken 从不外发」)。
+ */
+export interface CheckpointAskCandidate {
+    token: string;
+    /** `checkpoint.status` 列(权威;`pending` | `resolved` | `expired`)。不做过滤,由收敛器判活性。 */
+    status: string;
+    createdAtMs: number;
+    /**
+     * 🔴 和解三元组的第一维([ref] 件1,黑板 [ref]③①)—— checkpoint 自己带的 `sourceSessionId`(core 在
+     * suspendAsk 铸行时恒填该腿的 `sessionId`)。**没有对应的列**,只能从 blob 窄读;读不出/缺席 = null。
+     *
+     * 为什么必须进候选集:读口按 `(scope, session_id, tool_call_id)` 查,而委派子代那条腿的 ask 落行时
+     * `session_id` 记的是**投递上下文**(根会话),park 却发生在**子代自己**的 sessionId 上 —— 只靠
+     * (toolCallId, hash) 两维,一条根腿的 park 会被一只子代的 ask 认领(摘要相同的两次同 args 调用完全
+     * 正常)。三元组全同才算同一件事。
+     */
+    sourceSessionId: string | null;
+    /** 该 park 绑定的 tool call(= `pendingAction.toolCallId`)。`unparseable` 行为 null。 */
+    boundCallId: string | null;
+    /** 服务端铸的入参摘要——判据 1 的第二道硬等式(与 `approval_ask.bound_input_hash` 相等才算命中)。 */
+    boundInputHash: string | null;
+    /** 在场 ⇒ 这行读不出(blob 版本超前 / JSON 坏)。收敛器视同不匹配;**从不是** false,缺席即可读。 */
+    unparseable?: true;
+}
+/**
+ * [ref] 件1 —— legacy `/v1/approvals/:sessionId/decide` 腿的**幂等回放**判别行(窄读,非凭据面)。
+ *
+ * 刻意**不带 token**:回放只需要「这条已决的行归谁、绑的是哪一次调用、判词是什么」三件,而 token 是
+ * resume 凭据(§12-C「checkpointToken 从不外发」;`CheckpointAskCandidate` 带它是因为收敛器要拿它去
+ * `bindBatch`,本口没有那个用途 ⇒ 不给)。
+ */
+export interface DecidedApprovalRecord {
+    /** 行的属主 scope 列(`encodeCheckpointScope` 的产物:principal 或匿名哨兵 `"_"`)。回放属主门的输入。 */
+    scope: string;
+    /** 行上的 D-1 入参摘要(`bound_input_hash` 列);pre-D-1 行为 null。 */
+    boundInputHash: string | null;
+    /**
+     * 这条已决行的**工具审批判词**,或 `null` = **判别不出**(codex R1-[medium] 四的收敛形):
+     * outcome 读不出 / 没有 winner / winner 绑的是**另一个** callId / 判词是 REVIEW 门那三个词。
+     *
+     * 🔴 `null` **不是**「无所谓」:调用方必须把它当「这条命中的行我读不懂」⇒ **整次回放拒绝**。
+     * 一条读不懂的已决行与一条判词相反的已决行在风险上同级 —— 都意味着这只 callId 上的持久事实
+     * 不是本次回放能如实复述的。
+     */
+    decision: "approve" | "deny" | null;
+    /**
+     * 判词**之外**的决议载荷指纹(codex R2-[high] 一,验真后补):`updatedInput` / `answer` / `reason`
+     * 三件都在 core 的持久 winner 里,而**同判词不等于同决议** —— 「approve + 编辑后的实参 A」与
+     * 「approve + 实参 B」是两次不同的放行,只比判词就会把后者谎报成「你的请求已被处理」(而 B 从未执行)。
+     * 调用方按**同一份请求重发**的语义要求它与本次请求的同三件逐字相等。
+     * `null` = 算不出(载荷序列化不了)⇒ 与 `decision: null` 同判:整次拒绝。
+     * 铸法见 {@link approvalPayloadFingerprint}(两条车道共用同一只,免得指纹口径漂)。
+     */
+    payloadFp: string | null;
+    /**
+     * [ref](core 7.7.0 [ref])—— 这条已决行上**已决动作最后被怎么处置**的结算记录,`null` = **未知**。
+     *
+     * 🔴 缺席只有一个含义:未知,**绝不是**「放行过」。`decision` 说的是决定(人批了没有),这一格说的是
+     * 那次决定在 resume 腿上执行时的处置(部署自己的复核可能在 post-CAS 把人批过的、改过参数的调用否掉,
+     * 于是 `decision: "approve"` 与 denied/policy 的处置**同时**在一行上成立)。[ref] 的病正是「流断之后
+     * 从行重建这条 run 的消费者只读得到前半句」——decide 幂等回放正是那种消费者。
+     *
+     * 铸法 = core 的 {@link executionVerdict} **单口**(两条车道共用),不许任何读点自己判列的在场性。
+     */
+    executionOutcome: GateOutcome | null;
+}
+/**
+ * [ref] 件1 —— {@link SqlCheckpointStore.findDecidedApprovalsForBinding} 的扫描上界。
+ *
+ * 🔴 它**同时是判据**,不只是一道 LIMIT:调用方按「命中集里每条判词都一致才回放」判,而一次被截断的
+ * 集合可能把分歧藏在第 N+1 行 ⇒ 消费点约定「**回满 = 判别不出**」,整次拒绝回放(回落 404)。现网正常形
+ * 恒 0 或 1 行,回满只可能是数据异常。
+ */
+export declare const DECIDED_REPLAY_SCAN_CAP = 8;
+/**
+ * [ref] 件1 —— core 的 `ResolvedOutcome` → 本腿(工具审批 decide)的二值词表。**闭集穷举**([ref]):
+ * core 哪天给 `ResolvedOutcome.decision` 加员,下面的 `never` 当场编译期红,而不是让一个新判词被
+ * 静默折成 `deny` 或漏成「没有决议」。
+ *
+ * 三条判据,缺一即 `null`(= 不回放,调用方逐字回落修前 404 —— **绝不**把 not-found 洗成成功):
+ *  ① 有 winner —— `resource_limit` / `wake` / `task_done` 的 resolve 不记 winner(core 契约),那些行
+ *     不是「一次人给的工具审批」,没有可回放的判词;
+ *  ② winner 绑的正是这次请求回显的那个 `boundCallId` —— 身份第二锚(列谓词是第一锚),两锚同意才算同一件事;
+ *  ③ 判词属于**工具审批**那两个词(`allow`/`deny`)—— `approve`/`reject`/`edit` 是 REVIEW 门
+ *     (plan_review / dry_run_review)的判词,那些门的决议入口不是本腿,回放它们等于跨门作答。
+ */
+export declare function approvalDecisionOfWinner(winner: ResolvedOutcome | undefined, boundCallId: string): "approve" | "deny" | null;
+/** 收敛器读口对一行的身份判词(三态 + 读不出;读法见 {@link pendingActionToolCallId} / {@link candidateIdentityOf})。 */
+export type CandidateIdentity = {
+    readable: true;
+    toolCallId: string | null;
+    boundInputHash: string | null;
+    kind: string | null;
+    sourceSessionId: string | null;
+} | {
+    readable: false;
+};
+/**
+ * 收敛器读口的**身份判词**(两只孪生同一只;`findCheckpointCandidatesForAsk` 的 SQL / LOCAL 两形都只经这里):先问 core 判官 `judgeCheckpointRow`
+ * (core 7.62.0 [ref],[ref])—— 判 `lacking`(更新的引擎能续它、本引擎缺读法:格式版本超上限,或要求表点名了本引擎不认的读法词)⇒ `{ readable: false }`:
+ * 本副本读不准这一行,交给收敛器当「不确定」,留给能续它的副本去绑(修前 SQL 孪生按 `version` 列比 `MAX_SUPPORTED_CHECKPOINT_VERSION`,
+ * 射程只有版本一轴,LOCAL 孪生没有这一臂)。`damaged` **不是**这一臂:本引擎不续这些字节(别的副本续不续,引擎没有说、本服务不替它们断言),身份读得出就照常判 —— 绑上之后续跑由判官给那句固定的拒,
+ * 比让 ask 停在 PARKING 诚实。其余三态见 {@link pendingActionToolCallId}。
+ */
+export declare function candidateIdentityOf(cp: Checkpoint): CandidateIdentity;
+/** 认领栅栏下改写一行 ctx 的结局(闭集;SQL / local 两孪生同词):`written` 写了;`claim_released` 接下改写的那条腿此刻已不持有这条 run(认领放了 / 不在跑 / 腿判据答否)⇒ 零写;
+ *  `context_absent` 持有、但会话没有 ctx 行 ⇒ 零写(不建行)。 */
+export declare const CTX_CLAIM_REWRITES: readonly ["written", "claim_released", "context_absent"];
+export type CtxClaimRewrite = (typeof CTX_CLAIM_REWRITES)[number];
+//# sourceMappingURL=checkpoint-store-face.d.ts.map