@sema-agent/server 7.143.0 → 7.144.0

package/dist/peer-inbound-face.d.ts

@@ -23,33 +23,28 @@
  *    成因会在重判时移动,列 / 决每次都读卡上**当下**的成因。
  *  · **一个调用方、一张卡、一个答案**:决断口只认列表会列出的卡(`decision === "held"` ∧ 可审成因);已批待投(`approved`)/ 已交接(`delivered`)的卡不列、不收。
  *
- * ## 索引(🚧 待 core 的枚举口到货即退役)
- * core 的队列注册表是模块私有的,只能按 (scope, 会话, 箱) 查 —— 宿主拿不到「这个进程里有哪些队列」。本面因此记一张**坐标表**:
- * (会话 id, 车道) —— 只是「去哪儿查」,不是卡,不含任何卡的事实。喂它的是 core 自己的两条通告(经部署级通告转发席,
- * `boot/runner-deps.ts` 的 `createEngineNoticeForwarder`):`peer.inbound_disposition{disposition:"held"}`(成因可审)进表,
- * `peer.held_settled{heldCount:0}` 出表。读的时候每一行都回 core 的队列取当下的卡,表里多一行 = 多查一次空队列,少一行 = 那张卡不列
- * (信仍按 core 的期限带回执过期 —— 安全默认)。退役条件:core 导出进程内 held 队列的枚举(连同各队列的 scope)。
- * 🚧 **坐标不带 scope**(通告 detail 里没有):同一会话 id 在本进程里被两个主体各排空出一只队列时(无主会话行 / 别的主体跑了这只会话),
- * 一只队列清空的那条 `heldCount:0` 把坐标带出表,另一只队列里的卡就不再列出,直到它的下一条 `held`(失败方向 = 上一句的安全默认)。
- * 钉 = `test/peer-inbound-approvals.test.ts` 的 🚧 R2 特征化格;core 请托 = 两条通告的 detail 带队列 scope(或上面的枚举口)。
+ * ## 枚举(core 7.62.0 `listPeerHeldQueues`)
+ * 列与关停都读 core 进程注册表的快照(`listPeerHeldQueues()`:每只队列的 scope / 打开它的会话 / 卡来自哪只箱 / 同一时刻的卡),本面不记任何表 ——
+ * 一张卡在不在、属于哪个 scope、哪只箱,全是那一读。决断口按行 id 的 (会话, 车道, seq) 回 `peerHeldQueueIfAny(调用方 scope, …)` 取同一只队列。
+ * 箱只有两种(会话自己的箱 / 它也排空的 principal 收件箱,core 的快照注逐字);读到第三种 ⇒ 那只队列的卡不列(没有车道就拼不出决断口 id)+ F 类
+ * `server.peer-inbound.queue-box-unknown` 留痕 —— 信仍被扣、按 core 的期限带回执过期(安全默认)。
+ *
+ * ## 到期
+ * 卡上的到期时刻是 core 的 `PeerHeldEntry.deadlineAt`(到期计时武装时在场:可审成因 ∧ 有限 `dialogExpiry` ∧ 卡仍 `held`;成因一动 core 重武装或清掉它)。
+ * 行的 `deadline` 就是它的原值,本仓不按 `heldAt + dialogExpiry` 自算(成因一动就是第二份、错的读法)。
  *
  * ## 关停
  * CC `HBe` 在宿主:core 不调 `PeerHeldQueue.shutdown()`(全库零生产调用点)。{@link PeerInboundFace.shutdown} 在有序关停的审批收尾那一拍
- * (`boot/shutdown.ts`,关池之前)对坐标表里每只队列调它 —— 仍被扣的信按 core 的规则带 `expired` 回执结清(reason `shutdown`)。
- * scope 读自会话行属主(`owner ?? "default"`,与 `boot/session-faces.ts` 信箱腿同读),调用方给读口。
- * 🚧 core 的队列 scope 是排空那条 run 的主体(`spec.principal ?? "default"`):无主会话被具名主体跑过时两者不同,关停找不到那只队列
- * (失败方向同崩溃:信仍被扣在箱里,下一位消费者重新领它)。钉 = 🚧 R4 特征化格;core 请托同上。
- * 🚧 core 的结清回执是投出即返(排空汇点 `void routePeerDeliveryReceipt(…)`):`shutdown()` 兑现时回执可能还没落箱,关池在它之后 ⇒ 那一条回执可能丢
- * (信本身已结清)。宿主没有可等的句柄;core 请托 = `shutdown()` 等回执落箱再兑现。
- */
+ * (`boot/shutdown.ts`,关池之前)对注册表里**每只**队列调它(进程的队列都是本进程的;不求 scope)—— 仍被扣的信按 core 的规则带 `expired` 回执结清
+ * (reason `shutdown`)。core 的 `shutdown()` 等它发出的每条回执落箱再兑现,没落的点名 seq 拒(卡照样全结);各队列互不等,一只拒不挡别的
+ * (`Promise.allSettled`),拒句进读数 `receiptFaults`,由关停链写一行 warn。
+  */
 import { type PeerHeldEntry, type PeerHeldSettleOutcome } from "@sema-agent/core";
 import { type PeerInboundLane } from "./org-delivery-gate.js";
 /**
- * 一个 principal(或会话行属主)的信箱 scope —— core 写侧 `taskScope = spec.principal ?? "default"` 的同一条读法(无主 ⇒ `"default"`)。
- * 列 / 决用调用方的 principal,关停用会话行属主;两者在属主围栏下同值(`resolve-spec.ts` 的 `fenceSessionOwner`),
- * 无主存量会话被具名壳续聊的混属主形是既有残余(`boot/session-faces.ts` 信箱腿同一条登记)。
+ * 调用方 principal 的信箱 scope —— core 写侧 `taskScope = spec.principal ?? "default"` 的同一条读法(无主 ⇒ `"default"`)。列 / 决都按它找队列。
  */
-export declare function peerBoxScope(principalOrOwner: string | null | undefined): string;
+export declare function peerBoxScope(principal: string | null | undefined): string;
 /** 决断口 id 的坐标(id 是它的唯一拼法,见 {@link peerInboundIdOf})。 */
 export interface PeerInboundCoord {
     readonly sessionId: string;
@@ -68,9 +63,9 @@ export declare function parsePeerInboundId(id: string): PeerInboundCoord | undef
  *  · `cause` —— core 的扣信成因(`PeerHeldEntry.cause`,`CrossSessionHoldCause` 闭集);
  *  · `content` / `fromName` —— 信的存储正文(`[summary] message`,core 的规范存储形)与发信方的显示名,**过凭据脱敏**(显示面;与停驻行的工具入参同一条);
  *  · `fromSession` / `fromScope` —— 发信会话 / 跨 principal 投递的发信 scope(core 的 typed 归属锚),在场才带;
- *  · `sentAt` / `heldAt` —— epoch ms。
- * 🚧 **没有 `deadline`**:到期计时在 core 队列里(在扣信、成因变动、换绑时各自起表),卡上不带它;本仓若按 `heldAt + dialogExpiry` 自算,
- * 成因一动就是一个错的截止时刻(第二份读法)。core 给卡加上到期时刻即补上(请托见 [ref] 收车档)。
+ *  · `sentAt` / `heldAt` —— epoch ms;
+ *  · `deadline` —— core 卡上的到期时刻 `deadlineAt` 原值(绝对 epoch ms,与停驻行 `deadline` 同名同义;壳用 `deadline − serverNowMs` 渲倒计时),
+ *    到期计时没武装(`dialogExpiry` 为 `null`)⇒ 缺席。
  */
 export interface PeerInboundPendingRow {
     readonly kind: "peer_inbound";
@@ -81,6 +76,7 @@ export interface PeerInboundPendingRow {
     readonly content: string;
     readonly sentAt: number;
     readonly heldAt: number;
+    readonly deadline?: number;
     readonly fromSession?: string;
     readonly fromName?: string;
     readonly fromScope?: string;
@@ -103,25 +99,24 @@ export type PeerInboundDecideResult = {
     readonly kind: "unrecorded";
     readonly error: unknown;
 };
-/** 关停读数:结清了几只队列、几只会话的 scope 读不出(那几只的卡随进程离开 —— 信仍在箱里被扣着,下一位消费者重新领它)。 */
+/**
+ * 关停读数:`queues` = 关了几只队列(注册表里的每一只,含空的);`cards` = 关停那一刻快照里的卡数;`receiptFaults` = 各只拒了的队列的拒句
+ * (core 点名回执没落箱的 seq —— 卡已结清,只是发信方可能没收到那条 `expired`)。
+ */
 export interface PeerInboundShutdownReading {
     readonly queues: number;
-    readonly scopeUnresolved: number;
+    readonly cards: number;
+    readonly receiptFaults: readonly string[];
 }
 export interface PeerInboundFace {
-    /** 部署级通告转发席的观察口:只读两条码的坐标,其余一概不看。永不抛(转发席不许把异常回抛给引擎)。 */
-    observe(notice: {
-        readonly code: string;
-        readonly detail?: Record<string, unknown>;
-    }): void;
-    /** `scope` 里此刻等人审的信({@link awaitsReview} 的卡),按 `heldAt` 升序(同刻按 id)。 */
+    /** `scope` 里此刻等人审的信({@link awaitsReview} 的卡;读 core 的队列枚举),按 `heldAt` 升序(同刻按 id)。 */
     list(scope: string): PeerInboundPendingRow[];
     /** 决断转发:只认 `scope` 里此刻等人审的那张卡(与 {@link list} 同一只判据);`settle` 抛(店拒了 CAS)⇒ `unrecorded`。 */
     decide(scope: string, coord: PeerInboundCoord, decision: PeerInboundDecision): Promise<PeerInboundDecideResult>;
-    /** 有序关停:坐标表里每只队列 `shutdown()`(core 的规则:仍 held 的卡带 `expired` 回执结清,reason `shutdown`)。 */
-    shutdown(scopeOfSession: (sessionId: string) => Promise<string | undefined>): Promise<PeerInboundShutdownReading>;
+    /** 有序关停:core 注册表里每只队列 `shutdown()`(core 的规则:仍 held 的卡带 `expired` 回执结清,reason `shutdown`;等回执落箱)。永不抛。 */
+    shutdown(): Promise<PeerInboundShutdownReading>;
 }
 export declare function createPeerInboundFace(): PeerInboundFace;
-/** 进程单例 —— 与 core 的 held 队列注册表同一个寿命(进程级);部署级通告转发席与审批路由读的是同一只。 */
+/** 进程单例 —— 决断尾(一张卡一次只过一只决断)是进程级的;审批路由与关停链读的是同一只。 */
 export declare const defaultPeerInboundFace: PeerInboundFace;
 //# sourceMappingURL=peer-inbound-face.d.ts.map

package/dist/peer-inbound-face.js

@@ -1,10 +1,10 @@
-import { PEER_HELD_REVIEW_CAUSES, isPeerSessionId, peerHeldQueueIfAny, } from "@sema-agent/core";
+import { PEER_HELD_REVIEW_CAUSES, isPeerSessionId, listPeerHeldQueues, peerHeldQueueIfAny, } from "@sema-agent/core";
 import { PEER_INBOUND_LANES, boxOfLane, laneOfBox } from "./org-delivery-gate.js";
 import { PEER_INBOUND_ID_PREFIX } from "./approval-queue-kind.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { seatText } from "./trace/exit-seat.js";
-export function peerBoxScope(principalOrOwner) {
-    return principalOrOwner ?? "default";
+export function peerBoxScope(principal) {
+    return principal ?? "default";
 }
 export function peerInboundIdOf(c) {
     return `${PEER_INBOUND_ID_PREFIX}${c.sessionId}:${c.lane}:${c.seq}`;
@@ -39,23 +39,18 @@ function rowOf(sessionId, lane, card) {
         content: seatText("peer-inbound-card-text", card.content),
         sentAt: card.sentAt,
         heldAt: card.heldAt,
+        ...(card.deadlineAt !== undefined ? { deadline: card.deadlineAt } : {}),
         ...(fromSession !== undefined ? { fromSession } : {}),
         ...(card.from !== undefined ? { fromName: seatText("peer-inbound-card-text", card.from) } : {}),
         ...(fromScope !== undefined ? { fromScope } : {}),
     };
 }
-function coordinatesOf(code, detail) {
-    const sessionId = detail?.sessionId;
-    const box = detail?.box;
-    if (typeof sessionId === "string" && typeof box === "string" && isPeerSessionId(sessionId)) {
-        const lane = laneOfBox(box, sessionId);
-        if (lane !== undefined)
-            return { sessionId, lane };
-    }
-    recordFailOpen("server.peer-inbound.notice-coordinates-unreadable", `code=${code}`);
-    return undefined;
+function laneOfQueue(q) {
+    const lane = laneOfBox(q.box, q.sessionId);
+    if (lane === undefined)
+        recordFailOpen("server.peer-inbound.queue-box-unknown", `cards=${q.size}`);
+    return lane;
 }
-const indexKey = (e) => JSON.stringify([e.lane, e.sessionId.toLowerCase()]);
 function awaitsReview(card) {
     return card.decision === "held" && isReviewCause(card.cause);
 }
@@ -66,7 +61,6 @@ function queueOf(scope, e) {
     return peerHeldQueueIfAny(scope, e.sessionId, boxOfLane(e.lane));
 }
 export function createPeerInboundFace() {
-    const index = new Map();
     const tails = new WeakMap();
     const serially = (q, seq, step) => {
         const perQueue = tails.get(q) ?? new Map();
@@ -80,37 +74,19 @@ export function createPeerInboundFace() {
         });
     };
     return {
-        observe(notice) {
-            switch (notice.code) {
-                case "peer.inbound_disposition": {
-                    if (notice.detail?.disposition !== "held" || !isReviewCause(notice.detail.cause))
-                        return;
-                    const e = coordinatesOf(notice.code, notice.detail);
-                    if (e !== undefined && !index.has(indexKey(e)))
-                        index.set(indexKey(e), e);
-                    return;
-                }
-                case "peer.held_settled": {
-                    if (notice.detail?.heldCount !== 0)
-                        return;
-                    const e = coordinatesOf(notice.code, notice.detail);
-                    if (e !== undefined)
-                        index.delete(indexKey(e));
-                    return;
-                }
-                default:
-                    return;
-            }
-        },
         list(scope) {
             const rows = [];
-            for (const e of index.values()) {
-                const q = queueOf(scope, e);
-                if (q === undefined)
+            for (const q of listPeerHeldQueues()) {
+                if (q.scope !== scope)
+                    continue;
+                const reviewable = q.entries.filter(awaitsReview);
+                if (reviewable.length === 0)
+                    continue;
+                const lane = laneOfQueue(q);
+                if (lane === undefined)
                     continue;
-                for (const card of q.list())
-                    if (awaitsReview(card))
-                        rows.push(rowOf(e.sessionId, e.lane, card));
+                for (const card of reviewable)
+                    rows.push(rowOf(q.sessionId, lane, card));
             }
             return rows.sort((a, b) => a.heldAt - b.heldAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
         },
@@ -131,26 +107,15 @@ export function createPeerInboundFace() {
                 return outcome === "gone" ? { kind: "not_found" } : { kind: "settled", outcome };
             });
         },
-        async shutdown(scopeOfSession) {
-            let queues = 0;
-            let scopeUnresolved = 0;
-            const scopes = new Map();
-            for (const e of [...index.values()]) {
-                const sid = e.sessionId.toLowerCase();
-                if (!scopes.has(sid))
-                    scopes.set(sid, await scopeOfSession(e.sessionId).catch(() => undefined));
-                const scope = scopes.get(sid);
-                if (scope === undefined) {
-                    scopeUnresolved += 1;
-                    continue;
-                }
-                const q = queueOf(scope, e);
-                if (q === undefined)
-                    continue;
-                await q.shutdown();
-                queues += 1;
-            }
-            return { queues, scopeUnresolved };
+        async shutdown() {
+            const snapshots = listPeerHeldQueues();
+            const queues = snapshots.flatMap((s) => {
+                const q = peerHeldQueueIfAny(s.scope, s.sessionId, s.box);
+                return q === undefined ? [] : [q];
+            });
+            const settled = await Promise.allSettled(queues.map((q) => q.shutdown()));
+            const receiptFaults = settled.flatMap((r) => (r.status === "rejected" ? [r.reason instanceof Error ? r.reason.message : String(r.reason)] : []));
+            return { queues: queues.length, cards: snapshots.reduce((n, s) => n + s.size, 0), receiptFaults };
         },
     };
 }

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

@@ -4,7 +4,6 @@ import type { StagingHandle } from "../session-sync-kernel.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import type { InstructionSourceStore } from "../instruction-source-notice.js";
 import type { SessionWorkspaceStore } from "../session-workspace.js";
-import type { OwnerlessClaim } from "../delegated-session-owner.js";
 export interface CachingOptions {
     /** Idle seconds a woken session is kept warm. 0 disables caching (pure passthrough). */
     ttlSec: number;
@@ -57,8 +56,6 @@ export declare class CachingSessionStore implements SessionStore {
      *  k8s 工作区空间 / SSE 探针 / resume-at 读的都是本类。 */
     readonly headOf: SessionHeadReader["headOf"];
     readonly register?: (sessionId: string, owner: string | null) => Promise<void>;
-    /** [ref] 委派继承律的认领口,纯转发(写的是行上的属主那一格 —— 只 CAS 子行自己,不碰暖缓存里的会话;停驻挂点在默认部署上读的就是本类 —— 与 `placementOf` 同转发同缺:内店记录委派树 ⇒ 两只都在)。 */
-    readonly claimOwnerless?: OwnerlessClaim;
     /** Delegated SessionRepo seam (§0.5) — list/fork/delete operate on the DURABLE tables directly (they bypass the
      *  warm cache by design; a fork/delete must read/write durable state, not a possibly-stale cached view). */
     readonly listSessions?: (opts: {

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

@@ -9,7 +9,6 @@ export class CachingSessionStore {
     onStaleHit;
     headOf;
     register;
-    claimOwnerless;
     listSessions;
     fork;
     forkTo;
@@ -56,8 +55,6 @@ export class CachingSessionStore {
         const ownerAware = inner;
         if (ownerAware.register)
             this.register = ownerAware.register.bind(inner);
-        if (ownerAware.claimOwnerless)
-            this.claimOwnerless = ownerAware.claimOwnerless.bind(inner);
         if (ownerAware.listSessions)
             this.listSessions = ownerAware.listSessions.bind(inner);
         if (ownerAware.sessionSummaryOf)

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

@@ -1,6 +1,6 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import { type ExecutionOutcomeRecordWord, type GateOutcome, type Checkpoint, type CheckpointGate, type CheckpointState, type CheckpointStore, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ResumeOutcome, type ResolvedOutcome, type ResolveExpectation, type ReopenReason, type RiskDescriptor, type StoreDurability, type StoreFidelity, type ToolApprovalCard } from "@sema-agent/core";
+import { type ExecutionOutcomeRecordWord, type GateOutcome, type Checkpoint, type CheckpointGate, type CheckpointRowVerdict, type CheckpointState, type CheckpointStore, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ResumeOutcome, type ResolvedOutcome, type ResolveExpectation, type ReopenReason, type RiskDescriptor, type StoreDurability, type StoreFidelity, type ToolApprovalCard } from "@sema-agent/core";
 import { type ParkRowFacts, type RuleOfferProjection, type SkillCardFacts } from "../approval-card.js";
 import type { KindlessBatchRowSource, KindlessBatchScan } from "../approval-batch-census.js";
 import { type SqlDialect, type SqlDriver } from "./sql-driver.js";
@@ -174,6 +174,14 @@ export interface PendingCheckpoint extends ParkRowFacts, SkillCardFacts {
      * `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 店摘要上的同一位。
+     * **在场 ⇔ 这一次列表判过这一行**:缺席只在 SQL 孪生上出现 —— 整行解不出(行照列,计 `server.approvals.park-row-blob-unreadable`,续跑面
+     * 对同一行响亮拒)、两次读之间行已离开待决,或两次读之间行的字节变了(判过的是另一份,不拼到这一行上;下一次列表即带)。缺席**不是** `ok`。非 `ok` 的行照列(人要看到它停在哪)。
+     */
+    rowVerdict?: CheckpointRowVerdict;
 }
 /**
  * [ref]([ref] / DEBTS [ref]):session 键读口(`findPendingTokenBySession` / `peekPendingScope`)的**行绑定**。
@@ -422,24 +430,8 @@ export declare const DECIDED_REPLAY_SCAN_CAP = 8;
  *     (plan_review / dry_run_review)的判词,那些门的决议入口不是本腿,回放它们等于跨门作答。
  */
 export declare function approvalDecisionOfWinner(winner: ResolvedOutcome | undefined, boundCallId: string): "approve" | "deny" | null;
-/**
- * checkpoint blob → `pendingAction.toolCallId`。
- *
- * 🔴 三态、**不是**两态(真双库实跑抓到的缺陷,2026-08-06):「读不出」与「读出来了、但这条 park 本来就
- * 没有 toolCallId」是两件事,压成同一个 `undefined` 会把每一条 `plan_review`/`task_done`/`resource_limit`
- * 腿(core 的 `PendingAction` 联合里三个成员结构上就没有 toolCallId)都误报成坏行。前者应标 `unparseable`
- * 交给收敛器当「不确定」,后者是**确定的不匹配**——干净地不是候选。
- *  - `{ readable: false }`        —— JSON 坏 / 形状根本不是对象:真的读不出。
- *  - `{ readable: true, toolCallId: null }` —— 读出来了,这条 park 无工具动作:确定不匹配。
- *  - `{ readable: true, toolCallId: "…" }`  —— 读出来了,拿去比。
- *
- * 逐层 `typeof` 收窄,不做裸 `as` 断言:blob 是持久层读回来的 `unknown`,是信任边界(宪法 [ref])。
- *
- * 🔴 [ref]:入参是**已经解过码的体**,不是一格列文本 —— 本函数不再自己 `JSON.parse`(SQL 车道的解码
- * 唯一属主是 `sql-json-column.ts`,见 {@link pendingActionOfColumn};local 孪生本来就递一只对象进来)。
- * 于是「串就再解一次」这条读法在这里按构造消失,两条车道递进来的东西同形。
- */
-export declare function pendingActionToolCallId(body: unknown): {
+/** 收敛器读口对一行的身份判词(三态 + 读不出;读法见 {@link pendingActionToolCallId} / {@link candidateIdentityOf})。 */
+export type CandidateIdentity = {
     readable: true;
     toolCallId: string | null;
     boundInputHash: string | null;
@@ -448,6 +440,14 @@ export declare function pendingActionToolCallId(body: unknown): {
 } | {
     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;
 /** `pending_steer_queue` 列承载的 CheckpointState 字段(= core `appendPendingSteer` / `readPendingSteerQueue`
  *  的入参形)。列是**唯一**权威(suspend 时写的 blob 从不带它)。 */
 type SteerColumnState = Pick<CheckpointState, "pendingSteerQueue">;
@@ -536,6 +536,8 @@ export declare class SqlCheckpointStore implements CheckpointStore, KindlessBatc
     /** ctx 改写的认领栅栏({@link SqlCheckpointStore.rewriteCtxWhileClaimed}):后端装配绑**同一只池**上的 run 店(`plugins/store-backend.ts` 的 `checkpoint()`)。
      *  缺席 ⇒ 那一口响亮抛(装配缺陷),其余口不读它。 */
     private readonly claims;
+    /** 停驻行投影记忆([ref] ④;运维队列与调度视图共用,见 {@link StoredRowProjectionMemo})。进程内、按店实例。 */
+    private readonly storedRowMemo;
     constructor(db: SqlDriver, logger?: {
         info?(msg: string, meta?: unknown): void;
     } | undefined, opts?: SqlCheckpointStoreOptions);
@@ -711,21 +713,26 @@ export declare class SqlCheckpointStore implements CheckpointStore, KindlessBatc
      */
     listPending(scope?: string): Promise<PendingCheckpoint[]>;
     /**
-     * 🔴 [ref] —— 运维队列行的**技能卡两位**({@link SkillCardFacts}:清单 / 成因词)。值与收件箱行同源:core `summarizeCheckpoint` 对同一行投的摘要,经 {@link skillCardFacts} 这一只投影。
-     * (授予绑定那一臂 —— 摘要 / 缺席词 —— 不在这里:[ref] 起由 {@link parkRowFacts} 读子树投出,本读口失败时它照在。)
+     * 运维队列 / 调度视图要的**整行事实**({@link StoredRowProjection}:判官的判决 + 技能卡两位),按令牌交回。
      *
-     * 为什么不像 {@link parkRowFacts} 那几位一样直接读 `pendingAction` 子树原值:**清单** `boundGrants` 在寄存行上是未经哈希校验的原值,core 只在摘要里「哈希等于摘要」
-     * 才发布它(「never a list beside a digest that binds another」);校验读口与哈希函数都不在 core 的公开导出面上,本仓既算不出也不该再写一份 ——
-     * 于是要拿到校验过的清单,只有对这一行跑 core 的 `summarizeCheckpoint`,而它吃的是整只 {@link Checkpoint}(不是子树)。
+     * 为什么要整行:判官 `judgeCheckpointRow` 读要求表要整只用(词集 + 摘要重算读整个 `state` 的表键路径,core [ref] ③);技能卡**清单**
+     * `boundGrants` 在寄存行上是未经哈希校验的原值,core 只在摘要里「哈希等于摘要」才发布它,校验读口不在 core 的公开导出面上 —— 两者都只能对整只
+     * {@link Checkpoint} 跑 core 的函数(摘要 `summarizeCheckpoint` 一次给两样)。
      *
-     * 读放大(如实):**只对行上可能带两位之一的行**(摘要是串,或成因词键在场 —— {@link parkRowCarriesSkillCardFacts})多读该行一次整只快照;普通卡(绝大多数行)零额外读,
-     * 主 SELECT 仍只取 `pendingAction` 子树(NP-3 不退)。这是一个**只增不改的代价**:带两位之一的待决行数 × 读次数(`/stream` 每连接每 3s 一拍)。
-     * 🚧 清单校验读口成为 core 公开导出的那一版,本读口与门一并退役,两位改走 `parkRowFacts` 读原值经 core 的读口 —— 零额外读。
+     * 读放大(如实):记忆命中零整行读;未命中的行按令牌**批**读(`IN (…)`,每批 ≤ {@link STORED_ROW_READ_BATCH}),每份字节每个进程一次 ——
+     * 起服后第一次列表把全部待决行读一遍,此后只有字节变了 / 被挤出记忆的行再读(修前:普通卡零整行读,技能卡每次列表都读;`/stream` 每连接每 3 s 一拍)。
+     * 判过的按**读回的那份字节**的摘要入记忆;两次读之间字节变了(批读的摘要 ≠ 主读交来的那一份)⇒ 判过的那一份照入记忆,但**不交回**给这一行 ——
+     * 交回的事实只许出自主读读到的同一份字节(一行一个字节版本;修前按令牌拼,B 的判决与清单配 A 的行),这一行本次不带判决与清单(与「离开待决」同一种缺席),
+     * 下一次列表主读读到新字节即命中记忆。
      *
-     * 失败方向与 {@link readParkRowActionCell} 逐字同一条判据(展示/分诊材料、行级容忍 + 响亮、同一个 tag):整只快照在场却不是一只合法的检查点(读回的体坏了,或 core 的摘要读不动它)
-     * ⇒ 只丢**这一行**的两位(授予绑定那一臂照在);行已不在待决(两次读之间被决/过期)⇒ 两位缺席;`not-text`(读腿漏了投影)原样抛。
+     * 失败方向(展示 / 分诊材料、行级容忍 + 响亮,与 {@link readParkRowActionCell} 同一条判据同一个 tag):整行解不出 ⇒ 这一行不在返回里(调用方行照列、
+     * 不带判决与清单),计 `server.approvals.park-row-blob-unreadable`;体是对象但 core 的摘要读不动(缺 `pendingAction` / `gate` 的手改行)⇒ 判决照给
+     * (判官是全函数),清单与成因词丢、同一个 tag 计数;两种都不进记忆(下一次列表重读、再计)。行已离开待决(两次读之间被决 / 过期)⇒ 不在返回里。
+     * `not-text`(读腿漏了投影)与摘要格形不对原样抛(码坏)。授予绑定那一臂(摘要 / 缺席词)不在这里:由 {@link parkRowFacts} 读子树投出,本读口失败时它照在。
      */
-    private readParkedSkillCardFacts;
+    private storedRowProjections;
+    /** 一行整行读回 → 它的 {@link StoredRowProjection}(完整的入记忆;失败方向见 {@link SqlCheckpointStore.storedRowProjections})。 */
+    private projectStoredRow;
     /**
      * [ref] #2 (scheduler seam, core 1.105): a scope's PENDING checkpoints as lightweight
      * {@link CheckpointSummary} rows in ONE query — the cross-task triage view a supervisor scheduler needs
@@ -772,14 +779,14 @@ export declare class SqlCheckpointStore implements CheckpointStore, KindlessBatc
      *    若只看 pending 就会把「park 成功过」这个既成事实读成「没 park 过」⇒ 又是一条假阴性 DENIED
      *    (对账三约束③)。park 成功是事实,gate 的活性由 `status` 表达,交给收敛器自己判。
      *  - **单行读不出 ⇒ 标记返回,不抛**:`unparseable` 的行由收敛器视同「不匹配」,一条坏行不许打断整段
-     *    扫描(§8 C-6)。什么算读不出:blob 的 `version` 超出本 build 支持(`get()` 那条前向兼容门在这里
-     *    不能 throw,否则一条超前行会让整个 session 的对账永久卡死)、或 blob JSON 坏。
+     *    扫描(§8 C-6)。什么算读不出:core 判官对这一行答 `lacking`(更新的引擎能续它 —— 本副本不绑,见 {@link candidateIdentityOf};
+     *    这里不能 throw,否则一条超前行会让整个 session 的对账永久卡死)、或 blob JSON 坏。
      *
      * 匹配是两段的:`tool_call_id` **列**是 `put()` 从 `pendingAction.toolCallId` 盖下来的权威投影,SQL 谓词
      * 先按它(或 NULL)收窄;列为 NULL 的行(无工具动作的 park,或列存在之前的旧行)靠解 blob 补判——解得出
      * 且相等才算候选,解不出就标 `unparseable`。
      * 🔴 **没有「列命中即零解析」的快路径**(原注写过,已作废,别照它优化):函数体对**每一行**无条件解
-     * blob,原因有二 ——(a) 前向兼容门与 blob 可读性门必须门在**所有**命中路径之前(codex F3 + 确认轮:
+     * blob,原因有二 ——(a) 判官的 `lacking` 臂与 blob 可读性门必须门在**所有**命中路径之前(codex F3 + 确认轮:
      * 列长得对不代表 blob 读得出,放行一条读不出的行去 `bindBatch` 会把 ask 钉成 PARKED + 一张本进程读不出
      * 的 resume 坐标,而 PARKED 不可回滚);(b) `[ref]` 之后 blob 顶层的 `sourceSessionId` 是和解三元组的第一
      * 维,列命中行结构上也必须解 blob 才拿得到它。
@@ -835,7 +842,7 @@ export declare class SqlCheckpointStore implements CheckpointStore, KindlessBatc
      *
      * 刻意**不带** `status='pending'` 谓词:判据是「这一行是不是你的」,与它此刻处在哪一态无关(`get()`
      * 自己也是裸 `WHERE token = ?`);加了反而在「刚被并发消费」的窗里把属主自己的诊断吞掉。
-     * 只 SELECT `scope` 一列 ⇒ 版本闸/坏 blob 都影响不到它(那是 `get()` 读 `version`/`checkpoint` 的事)。
+     * 只 SELECT `scope` 一列 ⇒ 坏 blob 影响不到它(那是 `get()` 读 `checkpoint` 的事;7.144.0 起 `get()` 不再按版本列拒,本引擎续不续由 core 判官在续跑时答)。
      */
     peekScopeByToken(token: CheckpointToken): Promise<string | null | undefined>;
     peekPendingScope(sessionId: string, binding?: PendingRowBinding): Promise<string | null | undefined>;