@sema-agent/server 7.147.0 → 7.148.0

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

@@ -1,15 +1,19 @@
 import { type Checkpoint, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
-import { type CheckpointAskCandidate, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-face.js";
-import { type FencedRun, type InProcessClaimFence } from "./store-contracts.js";
+import { type CheckpointAskCandidate, type CtxClaimPut, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type ExpiredApprovalGate, type ExpiredGatePosition, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-face.js";
+import { type CtxWriteClaim } from "./store-contracts.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
+/**
+ * 一只会话的续跑输入档**严格**删(提交出口撤回一只刚铸会话时的 local 一形;SQL 孪生是撤回事务里的 `DELETE FROM checkpoint_ctx WHERE session_id = ?`):
+ * 档不在 ⇒ 照常;删不掉 ⇒ **抛**(撤回的删序还没落标记 ⇒ 会话完整可见,不吞成「删了」);删掉之后 fsync ctx 目录(win32 不 fsync 目录)。
+ * 只按路径动档,不建店实例(本部署没开续跑输入时目录里本就没有这只档)。路径与 {@link LocalCheckpointStore} 的写口同一只(`localCheckpointStoreDirsFor` + {@link ctxFileOf})。
+ */
+export declare function dropLocalCheckpointCtxStrict(root: string, sessionId: string): void;
 export interface LocalCheckpointStoreOptions {
-    /** taskId join for the pending card (the local FileRunStore's `getActiveTaskId`). Absent ⇒ `taskId: null`. */
+    /** 会话认领联结(the local FileRunStore's `getActiveTaskId`)—— 停驻行 `taskId` 的第二格读数([ref],写者 `parkedLegTaskId`)。Absent ⇒ 只剩行上的记录。 */
     getActiveTaskId?: (sessionId: string) => Promise<string | undefined>;
     /** E21 owner guard (the LocalSessionStore's owner read, `headOf(id)?.owner`: `undefined` = no session row). Absent ⇒ owner guard degrades
      *  to null-owner-only (a non-null owner with no owner source purges NOTHING — fail-closed, mirrors the SQL EXISTS guard). */
     readSessionOwner?: (sessionId: string) => Promise<string | null | undefined>;
-    /** ctx 改写的认领栅栏({@link LocalCheckpointStore.rewriteCtxWhileClaimed}):同一数据根上的文件 run 店(进程内栅栏形)。缺席 ⇒ 那一口响亮抛(装配缺陷)。 */
-    claims?: InProcessClaimFence;
 }
 /** checkpoint 店在数据根下自己铸的目录(构造器与一次性迁移 M39 的名册同读这一只)。 */
 export declare function localCheckpointStoreDirsFor(root: string): {
@@ -68,8 +72,30 @@ export declare class LocalCheckpointStore {
      *  suspend→crash→expire-later lifecycle visible. Entries are never dropped while the inner row exists
      *  (a `resolved` row can be reopen()ed back to pending — pruning it would be wrong). */
     private readonly sessionTokens;
+    /**
+     * **归属索引**:每张卡归在哪只会话上(SQL 孪生的 `checkpoint.host_session_id` 列在本店的同一个事实;读法 `hostSessionOf`,`put` 求值一次)。
+     * `hostTokens` = 归属会话 → 卡,`hostOfToken` = 反查(内存,由前者建)。持久化在 `checkpoint-host-sessions.json`,与 scope 注册表 / 会话索引同一条落盘先后
+     * (先登记、后内核 put:崩在两步之间 ⇒ 一条指向不存在的行的归属,读者按 `get` 为空跳过;反过来 ⇒ 一张谁的 run 都找不到的卡)。
+     * 存量卡由一次性迁移 M49 自卡的会话回填({@link backfillHostSessionsM49})。按 run 找卡的读口(取消 / 收割探针 / 续跑输入回收 / 运维队列行的 run)只读它。
+     */
+    private readonly hostTokens;
+    private readonly hostOfToken;
+    private readonly hostSessionsPath;
     private readonly opts;
     constructor(root: string, opts?: LocalCheckpointStoreOptions);
+    /**
+     * 三份旁索引(scope 注册表 / 会话索引 / 归属索引)在 `put` 里的**唯一**登记形:内存先记、整档落盘;落盘抛 ⇒ 内存那一笔撤回再抛。
+     * 撤回是这条规则的要害:三份索引都按「内存里已有 ⇒ 不再落盘」判,一笔留在内存里的失败登记会让同一张卡的重试 `put` 跳过落盘、内核行照提交
+     * —— 文件里永远没有它(重启之后:scope 枚举不到这张卡;会话索引漏它;归属被 M49 自卡的会话回填,cascade 级上的卡丢了它的 run)。
+     * `record` 交回「这一次记下了新东西」,`undo` 只撤这一次记下的那一笔。
+     */
+    private registerDurably;
+    /** 归属索引的内存两面一起记(不落盘;落盘见 {@link persistHostSessions})。交回这一次新记下的卡数。 */
+    private indexHost;
+    /** {@link indexHost} 的一张卡的逆(只给 {@link registerDurably} 的撤回用)。 */
+    private unindexHost;
+    /** Persist the card→host-session index (whole-file atomic replace — same cadence as the session→tokens index). */
+    private persistHostSessions;
     /** Persist the session→tokens index (whole-file atomic replace — puts are per-suspend, low frequency). */
     private persistSessionTokens;
     put(token: CheckpointToken, cp: Checkpoint): Promise<void>;
@@ -116,22 +142,22 @@ export declare class LocalCheckpointStore {
      * session 两条 pending 时答哪条取决于 sidecar 里 scope 的插入序 —— 与 SQL 无序 `LIMIT 1` 同病。
      */
     findPendingTokenBySession(sessionId: string, scope?: string, binding?: PendingRowBinding): Promise<CheckpointToken | null>;
+    /** 会话那一轴的候选集(`PendingRowBinding.axis`):卡自己的对话 ⇒ 内核的按会话读口;卡归属的 run 会话 ⇒ 归属索引({@link runPendings})。 */
+    private axisPendings;
     /** [ref]:候选集 → 读口该答的那一条(过滤 sessionId + 门型,再取「最新优先」)。 */
     private pickPendingRow;
-    /** [ref] read-only probe face: does this session have an EXPIRED checkpoint row? The local twin of the SQL
-     *  `EXISTS (SELECT 1 FROM checkpoint ce WHERE ce.session_id = ? AND ce.status = 'expired')` that drives the
-     *  run stores' failSuspendedWithExpiredCheckpoint. Scans the session→token index (get(token) is the only
-     *  cross-status read core's File store offers); an index entry whose inner row vanished is pruned lazily.
-     *  Backed by a persisted registry, so it stays honest — never a guessed "true".
-     *  ⚠️ 存量限制(codex M2,如实):索引随 put 增量建立,无升级迁移——本版本部署前已存在的 checkpoint 不在
-     *  索引里,其 expired 对本探针不可见(core File store 的 listByScope 是 pending-only,无法枚举历史行回填)。
-     *  旧存量锁死的恢复把手 = cancel verb([ref]①,不依赖本索引);增量行全覆盖。 */
-    hasExpiredBySession(sessionId: string): Promise<boolean>;
+    /** [ref] read-only probe face: does this RUN session have an EXPIRED checkpoint filed under it? The local twin of the SQL
+     *  `EXISTS (SELECT 1 FROM checkpoint ce WHERE ce.host_session_id = tr.session_id AND ce.status = 'expired')` that drives the
+     *  run stores' failSuspendedWithExpiredCheckpoint. Scans the card→host-session index (get(token) is the only
+     *  cross-status read core's File store offers). Backed by a persisted registry, so it stays honest — never a guessed "true".
+     *  ⚠️ 存量限制(如实):M49 从会话索引与此刻的待决行回填归属 —— [ref] 会话索引建立之前就已不是 pending 的老卡两边都不在,
+     *  其 expired 对本探针不可见;旧存量锁死的恢复把手 = cancel verb([ref]①)。 */
+    hasExpiredForRun(runSessionId: string): Promise<boolean>;
     /**
      * [ref] 件1 —— SQL 孪生 `findDecidedApprovalsForBinding` 的本地形(判据、词表、失败方向逐条同源;
      * 那处顶注是唯一真源,这里只记两处**本地形自己的**差别)。
      *
-     *  · 枚举面走 [ref] 的 `sessionTokens` 索引 —— 与 `hasExpiredBySession` 同一条路(core 的 File store
+     *  · 枚举面走 [ref] 的 `sessionTokens` 索引(按卡的对话;core 的 File store
      *    只能 pending-only 枚举,跨态读只有 `get(token)`),所以它那条**存量限制**在这里逐字同样成立:
      *    索引建立之前 park 的老行对本口不可见 ⇒ 回放判别不出 ⇒ 调用方逐字回落 404(保守方向)。
      *  · **没有排序**:本口交出全部命中行,由调用方按「判词一致才回放」判(理由见 SQL 孪生顶注的
@@ -155,7 +181,7 @@ export declare class LocalCheckpointStore {
      * 补齐,而不是给下游那两处各加一条「这台机器绑不了」的特判。
      *
      * 形差(逐条,如实):
-     *  · **枚举面**走 [ref] 的 `sessionTokens` 索引(与 `hasExpiredBySession` / `findDecidedApprovalsForBinding`
+     *  · **枚举面**走 [ref] 的 `sessionTokens` 索引(与 `findDecidedApprovalsForBinding`
      *    同一条路),所以它那条**存量限制**在这里逐字同样成立:索引建立之前 put 的老行对本口不可见 ⇒ 判据 1
      *    不命中 ⇒ 行落判据 ②③④⑤(保守方向,与读口缺席时的既有降级同向)。
      *  · **没有列,所以没有列/blob 一致性门**:SQL 孪生的两道矛盾门(`tool_call_id` 与 `bound_input_hash`
@@ -181,6 +207,15 @@ export declare class LocalCheckpointStore {
     /** `undefined` = no pending row; else the owner scope (local scopes are always strings — never null).
      *  [ref]:与 `findPendingTokenBySession` 同一个 {@link pickPendingRow}(同 binding ⇒ 同一行)。 */
     peekPendingScope(sessionId: string, binding?: PendingRowBinding): Promise<string | null | undefined>;
+    /** 归在这只 run 会话上的待决卡(归属索引 → 逐张 `get`;只认 pending,scope 给了就再判一次)。 */
+    private runPendings;
+    /** SQL 孪生 `hostSessionOfCard` 的本地形:`undefined` = 没有这一行;`null` = 行在、归属索引里没有它(M49 还没回填到的存量卡)。 */
+    hostSessionOfCard(token: CheckpointToken): Promise<string | null | undefined>;
+    /**
+     * M49 的本地腿:存量卡的归属自卡的会话回填(SQL 孪生 `UPDATE … SET host_session_id = session_id WHERE host_session_id IS NULL` 的同义)。来源两份:会话索引
+     * (自 [ref] 起每一张 put 过的卡,键 = 卡的会话)与此刻的全部待决行(更早的待决卡)。已有归属的卡不动;交回新记下的卡数(第二跑零)。
+     */
+    backfillHostSessionsM49(): Promise<number>;
     /**
      * [ref] D-D global expiry sweep — same split as the SQL twin: the deadline branch abort-expires every row
      * EXCEPT an approval-kind row whose gate core reads as facet `A` (those get the graceful resolve-DENY via
@@ -191,11 +226,9 @@ export declare class LocalCheckpointStore {
      */
     reapExpired(cutoff: number): Promise<number>;
     /** [ref] D-D SLA deny-sweep input — pending approval-kind gates past deadline that core reads as facet `A`
-     *  (`facetOf`: a `question`-card gate is `B` and is voided by reapExpired instead; same predicate as the SQL twin). */
-    listExpiredApprovalGates(cutoff: number, limit?: number): Promise<Array<{
-        sessionId: string;
-        scope: string;
-    }>>;
+     *  (`facetOf`: a `question`-card gate is `B` and is voided by reapExpired instead; same predicate as the SQL twin).
+     *  Same order and paging as the SQL twin: deadline, then token; `after` returns only the rows strictly after that position ([ref]). */
+    listExpiredApprovalGates(cutoff: number, limit?: number, after?: ExpiredGatePosition): Promise<ExpiredApprovalGate[]>;
     /**
      * 🔴 **写腿的形闸与 SQL 孪生逐字同一条**(codex 对抗复审 r1 [medium],验真后按类修):TS 的 `object` 说不出
      * 「序列化之后是一只 JSON 对象」—— 数组 / `Date` / `toJSON()` 返回标量或 `null` 的对象全都通得过类型面,
@@ -207,7 +240,7 @@ export declare class LocalCheckpointStore {
      * 一个 `toJSON(k){ return k === "ctx" ? null : {…} }` 的对象验的是 `{…}`、写的是 `{"ctx":null}`
      * (实测两串逐字不同)。有状态的序列化器同理。⇒ 整条记录**只序列化一次**,闸判那一串,写也写那一串。
      */
-    putCtx(sessionId: string, ctx: SealedCheckpointCtx): Promise<void>;
+    putCtx(sessionId: string, ctx: SealedCheckpointCtx, claim?: CtxWriteClaim): Promise<CtxClaimPut>;
     /**
      * 🔴 **坏体 ⇒ 拒,绝不读成缺席**([ref],与 SQL 孪生同一条判据)。修前这里是
      * `catch { return null }` + `(rec.ctx as T) ?? null`,于是一个撕裂 / 手改 / 权限读不动的 ctx 文件与
@@ -224,7 +257,9 @@ export declare class LocalCheckpointStore {
      * 本孪生的栅栏是进程内形(`store-contracts.ts` `InProcessClaimFence`):判认领、刷新活性、问腿判据与本口的落盘是**同一个同步段**(原子写本就同步),
      * 中间没有让出,所以认领在写落定之前挪不动。只改既有档(档不在 ⇒ `context_absent`,不建档);形闸同 {@link LocalCheckpointStore.putCtx},在栅栏之前判。
      */
-    rewriteCtxWhileClaimed(sessionId: string, taskId: string, ctx: SealedCheckpointCtx, legHolds: (run: FencedRun) => boolean): Promise<CtxClaimRewrite>;
+    rewriteCtxWhileClaimed(sessionId: string, ctx: SealedCheckpointCtx, claim: CtxWriteClaim): Promise<CtxClaimRewrite>;
+    /** 两只 ctx 栅栏写(`putCtx` 交认领的那一形 / `rewriteCtxWhileClaimed`)共用的栅栏例程(SQL 孪生同名例程的进程内形):交来的栅栏是 SQL 事务形 ⇒ 响亮抛(装配缺陷);形闸在栅栏之前;判认领、问腿判据、落盘同一个同步段。 */
+    private writeCtxWhileClaimed;
     /**
      * 🔴 **一次性迁移的 ctx 行改写店腿**(local 孪生;`checkpoint-store-face.ts` `CheckpointCtxRowsRewriter`,判词与 SQL 孪生 `rewriteCtxRows` 逐条同):
      * 逐档读(信封经读腿**同一只**判形 —— 读不出 ⇒ 计数、跳过、**不删**),`rewrite` 交回新体 ⇒ 信封原样(`sessionId` / `updatedAt` 不动:收割按 `updatedAt` 判)

package/dist/plugins/local-checkpoint-store.js

@@ -1,24 +1,66 @@
+import { writeLogText } from "../observability/logger.js";
 import { z } from "zod";
 import { denySweepOwns, parkedApprovalCard } from "../approval-content-kind.js";
 import { parkRowFacts, skillCardFacts } from "../approval-card.js";
 import { durableRowIdentity } from "../checkpoint-identity.js";
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { closeSync, existsSync, fsyncSync, openSync, readFileSync, readdirSync, rmSync, unlinkSync } from "node:fs";
+import { IS_WIN32 } from "./host-platform.js";
 import { join } from "node:path";
-import { CHECKPOINT_LIST_LIMITS, FileCheckpointStore, atomicWriteFile, ensureDir, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
+import { CHECKPOINT_LIST_LIMITS, FileCheckpointStore, atomicWriteFile, checkpointDeadlinePassed, ensureDir, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
 import { approvalPayloadFingerprint } from "./approval-payload-fingerprint.js";
-import { approvalDecisionOfWinner, boundedRuleOffers, boundedToolInput, candidateIdentityOf, pendingRowPrecedes, queueRowGateKind, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-face.js";
+import { approvalDecisionOfWinner, boundedRuleOffers, boundedToolInput, candidateIdentityOf, DENY_SWEEP_PAGE_ROWS, isUnreadableSummaryForm, parkedLegTaskId, pendingRowPrecedes, queueRowGateKind, queueTriageOrder, readRiskDescriptorBody, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS, } from "./checkpoint-store-face.js";
 import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
-import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, readStringArrayColumn } from "./sql-json-column.js";
+import { hostSessionOf } from "./checkpoint-index-columns.js";
+import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, isJsonObject, readStringArrayColumn } from "./sql-json-column.js";
 import { UNMANAGED_RETENTION } from "./retention-declaration.js";
 import { assertJsonColumnWritable, createObjectColumnReader } from "./sql-json-column.js";
 import { FENCE_LANDED } from "./store-contracts.js";
+import { recordFailOpen } from "../observability/fail-open.js";
+const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
 function terminalAtOf(cp) {
-    return Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS);
+    const createdAt = cp.createdAt;
+    const deadline = cp.deadline;
+    const deadlineTerm = deadline === undefined ? 0 : isFiniteNumber(deadline) ? deadline : undefined;
+    if (!isFiniteNumber(createdAt) || deadlineTerm === undefined)
+        return -Infinity;
+    return Math.max(createdAt + TERMINAL_BACKSTOP_MS, deadlineTerm + TERMINAL_GRACE_MS);
+}
+function sweepDeadlineKey(deadline) {
+    return isFiniteNumber(deadline) ? deadline : -Infinity;
+}
+function sweepPositionPrecedes(a, b) {
+    return a.deadline < b.deadline || (a.deadline === b.deadline && a.token < b.token);
+}
+function queueRiskDescriptorOf(gate) {
+    const raw = isJsonObject(gate) ? gate.riskDescriptor : undefined;
+    if (raw === undefined || raw === null)
+        return null;
+    const shape = readRiskDescriptorBody(raw);
+    if (shape.problem === undefined)
+        return shape.value;
+    recordFailOpen("server.approvals.risk-descriptor-cell-unreadable");
+    return null;
 }
 function ctxFileOf(sessionId) {
     return `${sanitizePathComponent(sessionId).slice(0, 48)}-${createHash("sha256").update(sessionId).digest("hex").slice(0, 12)}.json`;
 }
+export function dropLocalCheckpointCtxStrict(root, sessionId) {
+    const dir = localCheckpointStoreDirsFor(root).ctx;
+    const path = join(dir, ctxFileOf(sessionId));
+    if (!existsSync(path))
+        return;
+    rmSync(path, { force: true });
+    if (IS_WIN32)
+        return;
+    const fd = openSync(dir, "r");
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 const CtxRecordSchema = z.object({
     sessionId: z.string(),
     updatedAt: z.number(),
@@ -62,12 +104,16 @@ export class LocalCheckpointStore {
     tmpDir;
     scopes = new Set();
     sessionTokens = new Map();
+    hostTokens = new Map();
+    hostOfToken = new Map();
+    hostSessionsPath;
     opts;
     constructor(root, opts = {}) {
         this.inner = new FileCheckpointStore(root);
         this.opts = opts;
         this.scopesPath = join(root, "checkpoint-scopes.json");
         this.sessionTokensPath = join(root, "checkpoint-session-tokens.json");
+        this.hostSessionsPath = join(root, "checkpoint-host-sessions.json");
         const dirs = localCheckpointStoreDirsFor(root);
         this.ctxDir = dirs.ctx;
         this.tmpDir = dirs.tmp;
@@ -81,7 +127,7 @@ export class LocalCheckpointStore {
             catch (e) {
                 quarantineUnreadableSidecar(this.scopesPath, "LocalCheckpointStore scope registry", e instanceof Error ? e.message : String(e));
                 this.scopeRegistryCorrupt = true;
-                console.warn("LocalCheckpointStore: will rebuild the scope set from the data plane on first read (core listScopes) — enumeration is EMPTY until then");
+                writeLogText("stderr", "LocalCheckpointStore: will rebuild the scope set from the data plane on first read (core listScopes) — enumeration is EMPTY until then");
             }
         }
         if (existsSync(this.sessionTokensPath)) {
@@ -94,21 +140,66 @@ export class LocalCheckpointStore {
                 quarantineUnreadableSidecar(this.sessionTokensPath, "LocalCheckpointStore session→tokens index", e instanceof Error ? e.message : String(e));
             }
         }
+        if (existsSync(this.hostSessionsPath)) {
+            for (const [host, toks] of Object.entries(decodeJsonColumn(readFileSync(this.hostSessionsPath, "utf8"), readSessionTokenIndex, "checkpoint-host-sessions.json (the local card→host-session index)"))) {
+                this.indexHost(host, toks);
+            }
+        }
+    }
+    registerDurably(record, undo, persist) {
+        if (!record())
+            return;
+        try {
+            persist();
+        }
+        catch (e) {
+            undo();
+            throw e;
+        }
+    }
+    indexHost(host, tokens) {
+        let added = 0;
+        for (const t of tokens) {
+            if (this.hostOfToken.has(t))
+                continue;
+            const set = this.hostTokens.get(host) ?? new Set();
+            set.add(t);
+            this.hostTokens.set(host, set);
+            this.hostOfToken.set(t, host);
+            added += 1;
+        }
+        return added;
+    }
+    unindexHost(host, token) {
+        const set = this.hostTokens.get(host);
+        set?.delete(token);
+        if (set?.size === 0)
+            this.hostTokens.delete(host);
+        this.hostOfToken.delete(token);
+    }
+    persistHostSessions() {
+        atomicWriteFile(this.tmpDir, this.hostSessionsPath, JSON.stringify(Object.fromEntries([...this.hostTokens].map(([host, set]) => [host, [...set]]))));
     }
     persistSessionTokens() {
         atomicWriteFile(this.tmpDir, this.sessionTokensPath, JSON.stringify(Object.fromEntries([...this.sessionTokens].map(([sid, set]) => [sid, [...set]]))));
     }
     async put(token, cp) {
-        if (!this.scopes.has(cp.scope)) {
-            this.scopes.add(cp.scope);
-            atomicWriteFile(this.tmpDir, this.scopesPath, JSON.stringify([...this.scopes]));
-        }
-        if (!this.sessionTokens.get(cp.sessionId)?.has(token)) {
+        const host = hostSessionOf(cp);
+        this.registerDurably(() => !this.scopes.has(cp.scope) && (this.scopes.add(cp.scope), true), () => this.scopes.delete(cp.scope), () => atomicWriteFile(this.tmpDir, this.scopesPath, JSON.stringify([...this.scopes])));
+        this.registerDurably(() => this.indexHost(host, [token]) > 0, () => this.unindexHost(host, token), () => this.persistHostSessions());
+        this.registerDurably(() => {
+            if (this.sessionTokens.get(cp.sessionId)?.has(token))
+                return false;
             const set = this.sessionTokens.get(cp.sessionId) ?? new Set();
             set.add(token);
             this.sessionTokens.set(cp.sessionId, set);
-            this.persistSessionTokens();
-        }
+            return true;
+        }, () => {
+            const set = this.sessionTokens.get(cp.sessionId);
+            set?.delete(token);
+            if (set?.size === 0)
+                this.sessionTokens.delete(cp.sessionId);
+        }, () => this.persistSessionTokens());
         return this.inner.put(token, cp);
     }
     get(token) {
@@ -150,7 +241,7 @@ export class LocalCheckpointStore {
             this.scopes.add(s);
         this.scopeRegistryCorrupt = false;
         atomicWriteFile(this.tmpDir, this.scopesPath, JSON.stringify([...this.scopes]));
-        console.warn(`LocalCheckpointStore: scope registry REBUILT from the data plane (${rebuilt.length} scope(s) with pending gates) — enumeration restored`);
+        writeLogText("stderr", `LocalCheckpointStore: scope registry REBUILT from the data plane (${rebuilt.length} scope(s) with pending gates) — enumeration restored`);
     }
     async pendings(scope) {
         await this.ensureScopesRebuilt();
@@ -189,26 +280,34 @@ export class LocalCheckpointStore {
     async listPending(scope) {
         const rows = [];
         for (const { token, cp, summary } of await this.pendings(scope)) {
-            const pa = cp.pendingAction;
-            const gate = cp.gate;
-            const gateKind = queueRowGateKind(gate?.kind);
+            const gateKind = queueRowGateKind(summary.gateKind);
             if (gateKind === undefined)
                 continue;
+            const joinKey = durableRowIdentity("approvals-queue", summary.checkpointId, token);
+            const host = this.hostOfToken.get(token);
+            const taskId = parkedLegTaskId(cp.state?.rowTaskId, host === undefined ? null : ((await this.opts.getActiveTaskId?.(host)) ?? null));
+            const createdAt = summary.createdAt !== undefined ? { createdAt: summary.createdAt } : {};
+            const deadline = summary.deadline ?? null;
+            if (isUnreadableSummaryForm(summary)) {
+                rows.push({ sessionId: summary.sessionId, ...joinKey, scope: summary.scope, toolName: null, toolCallId: null, gateKind, taskId, input: null, ...createdAt, deadline, riskDescriptor: null, rowVerdict: summary.rowVerdict });
+                continue;
+            }
+            const pa = cp.pendingAction;
             const toolCallId = pa?.toolCallId ?? null;
             rows.push({
-                sessionId: cp.sessionId,
-                ...durableRowIdentity("approvals-queue", cp.checkpointId, token),
-                scope: cp.scope,
+                sessionId: summary.sessionId,
+                ...joinKey,
+                scope: summary.scope,
                 toolName: pa?.toolName ?? null,
                 toolCallId,
                 ...(toolCallId !== null ? { boundCallId: toolCallId } : {}),
                 ...(pa?.boundInputHash !== undefined ? { boundInputHash: pa.boundInputHash } : {}),
                 gateKind,
-                taskId: (await this.opts.getActiveTaskId?.(cp.sessionId)) ?? null,
+                taskId,
                 input: boundedToolInput(pa?.args),
-                createdAt: cp.createdAt,
-                deadline: cp.deadline ?? null,
-                riskDescriptor: gate?.riskDescriptor ?? null,
+                ...createdAt,
+                deadline,
+                riskDescriptor: queueRiskDescriptorOf(cp.gate),
                 ...(() => {
                     const rs = boundedRuleOffers(pa?.ruleOffers);
                     return rs !== undefined ? { ruleOffers: rs } : {};
@@ -220,15 +319,18 @@ export class LocalCheckpointStore {
                 rowVerdict: summary.rowVerdict,
             });
         }
-        return rows.sort((a, b) => (b.riskDescriptor?.severity ?? 0) - (a.riskDescriptor?.severity ?? 0) || a.createdAt - b.createdAt);
+        return rows.sort(queueTriageOrder);
     }
     async findPendingTokenBySession(sessionId, scope, binding) {
-        return this.pickPendingRow(await this.sessionPendings(sessionId, scope || undefined), sessionId, binding)?.token ?? null;
+        return this.pickPendingRow(await this.axisPendings(sessionId, scope || undefined, binding), binding?.axis === "run" ? undefined : sessionId, binding)?.token ?? null;
+    }
+    axisPendings(sessionId, scope, binding) {
+        return binding?.axis === "run" ? this.runPendings(sessionId, scope) : this.sessionPendings(sessionId, scope);
     }
-    pickPendingRow(rows, sessionId, binding) {
+    pickPendingRow(rows, cardSessionId, binding) {
         let best;
         for (const row of rows) {
-            if (row.cp.sessionId !== sessionId)
+            if (cardSessionId !== undefined && row.cp.sessionId !== cardSessionId)
                 continue;
             if (binding?.gateKinds !== undefined) {
                 const kind = row.cp.gate?.kind;
@@ -240,30 +342,11 @@ export class LocalCheckpointStore {
         }
         return best;
     }
-    async hasExpiredBySession(sessionId) {
-        const tokens = this.sessionTokens.get(sessionId);
-        if (!tokens)
-            return false;
-        let pruned = false;
-        for (const t of [...tokens]) {
-            const cp = await this.inner.get(t);
-            if (!cp) {
-                tokens.delete(t);
-                pruned = true;
-                continue;
-            }
-            if (cp.status === "expired")
+    async hasExpiredForRun(runSessionId) {
+        for (const t of this.hostTokens.get(runSessionId) ?? []) {
+            if ((await this.inner.get(t))?.status === "expired")
                 return true;
         }
-        if (pruned) {
-            if (tokens.size === 0)
-                this.sessionTokens.delete(sessionId);
-            try {
-                this.persistSessionTokens();
-            }
-            catch {
-            }
-        }
         return false;
     }
     async findDecidedApprovalsForBinding(sessionId, boundCallId) {
@@ -315,34 +398,68 @@ export class LocalCheckpointStore {
         return (await this.inner.get(token))?.scope;
     }
     async peekPendingScope(sessionId, binding) {
-        return this.pickPendingRow(await this.sessionPendings(sessionId), sessionId, binding)?.cp.scope;
+        return this.pickPendingRow(await this.axisPendings(sessionId, undefined, binding), binding?.axis === "run" ? undefined : sessionId, binding)?.cp.scope;
+    }
+    async runPendings(runSessionId, scope) {
+        const out = [];
+        for (const token of this.hostTokens.get(runSessionId) ?? []) {
+            const cp = await this.inner.get(token);
+            if (cp === null || cp.status !== "pending" || (scope !== undefined && cp.scope !== scope))
+                continue;
+            out.push({ token, cp });
+        }
+        return out;
+    }
+    async hostSessionOfCard(token) {
+        const host = this.hostOfToken.get(token);
+        if (host !== undefined)
+            return host;
+        return (await this.inner.get(token)) === null ? undefined : null;
+    }
+    async backfillHostSessionsM49() {
+        let added = 0;
+        for (const [sessionId, toks] of this.sessionTokens)
+            added += this.indexHost(sessionId, toks);
+        for (const { token, cp } of await this.pendings())
+            added += this.indexHost(cp.sessionId, [token]);
+        if (added > 0)
+            this.persistHostSessions();
+        return added;
     }
     async reapExpired(cutoff) {
         let n = 0;
         for (const { token, cp } of await this.pendings()) {
-            const deadlineBranch = cp.deadline !== undefined && cp.deadline <= cutoff && !denySweepOwns(cp.gate);
+            const deadlineBranch = checkpointDeadlinePassed(cp.deadline, cutoff) && !denySweepOwns(cp.gate);
             const terminalBranch = terminalAtOf(cp) <= cutoff;
             if ((deadlineBranch || terminalBranch) && (await this.inner.expire(token, cp.scope)))
                 n++;
         }
         return n;
     }
-    async listExpiredApprovalGates(cutoff, limit = 100) {
+    async listExpiredApprovalGates(cutoff, limit = DENY_SWEEP_PAGE_ROWS, after) {
         const hits = [];
-        for (const { cp } of await this.pendings()) {
-            if (denySweepOwns(cp.gate) && cp.deadline !== undefined && cp.deadline <= cutoff)
-                hits.push({ sessionId: cp.sessionId, scope: cp.scope, deadline: cp.deadline });
+        for (const { token, cp } of await this.pendings()) {
+            if (!denySweepOwns(cp.gate) || !checkpointDeadlinePassed(cp.deadline, cutoff))
+                continue;
+            const position = { deadline: sweepDeadlineKey(cp.deadline), token };
+            if (after !== undefined && !sweepPositionPrecedes(after, position))
+                continue;
+            hits.push({ sessionId: cp.sessionId, scope: cp.scope, position });
         }
-        return hits
-            .sort((a, b) => a.deadline - b.deadline)
-            .slice(0, limit)
-            .map(({ sessionId, scope }) => ({ sessionId, scope }));
+        return hits.sort((a, b) => (sweepPositionPrecedes(a.position, b.position) ? -1 : sweepPositionPrecedes(b.position, a.position) ? 1 : 0)).slice(0, limit);
     }
-    async putCtx(sessionId, ctx) {
+    async putCtx(sessionId, ctx, claim) {
+        if (claim !== undefined) {
+            return this.writeCtxWhileClaimed(sessionId, ctx, claim, "local claim-fenced write", (path, text) => {
+                atomicWriteFile(this.tmpDir, path, text);
+                return "written";
+            });
+        }
         const rec = { sessionId, updatedAt: Date.now(), ctx };
         const text = JSON.stringify(rec);
         assertJsonColumnWritable(text, createCtxRecordReader(), `checkpoint ctx for session ${JSON.stringify(sessionId)} (local write leg)`);
         atomicWriteFile(this.tmpDir, join(this.ctxDir, ctxFileOf(sessionId)), text);
+        return "written";
     }
     async getCtx(sessionId) {
         const p = join(this.ctxDir, ctxFileOf(sessionId));
@@ -351,23 +468,25 @@ export class LocalCheckpointStore {
         const rec = refusingCtx(sessionId, () => decodeJsonColumn(readFileSync(p, "utf8"), createCtxRecordReader(), `checkpoint-ctx ${ctxFileOf(sessionId)} for session ${JSON.stringify(sessionId)}`));
         return rec.sessionId === sessionId ? rec.ctx : null;
     }
-    async rewriteCtxWhileClaimed(sessionId, taskId, ctx, legHolds) {
-        const claims = this.opts.claims;
-        if (claims === undefined)
-            throw new Error("LocalCheckpointStore.rewriteCtxWhileClaimed: no claim fence is bound to this store (wiring defect: the local backend binds its own run store)");
+    async rewriteCtxWhileClaimed(sessionId, ctx, claim) {
+        return this.writeCtxWhileClaimed(sessionId, ctx, claim, "local claim-fenced rewrite", (path, text) => {
+            if (!existsSync(path))
+                return "context_absent";
+            atomicWriteFile(this.tmpDir, path, text);
+            return "written";
+        });
+    }
+    writeCtxWhileClaimed(sessionId, ctx, claim, leg, write) {
+        const fence = claim.fence;
+        if ("db" in fence)
+            throw new Error(`LocalCheckpointStore ${leg}: the claim fence must be the in-process run store on this data root (wiring defect: the run store and the checkpoint store come from one backend)`);
         const rec = { sessionId, updatedAt: Date.now(), ctx };
         const text = JSON.stringify(rec);
-        assertJsonColumnWritable(text, createCtxRecordReader(), `checkpoint ctx for session ${JSON.stringify(sessionId)} (local claim-fenced rewrite)`);
+        assertJsonColumnWritable(text, createCtxRecordReader(), `checkpoint ctx for session ${JSON.stringify(sessionId)} (${leg})`);
         const path = join(this.ctxDir, ctxFileOf(sessionId));
-        let outcome = "context_absent";
-        const held = claims.whileHoldingClaim(sessionId, taskId, (run) => {
-            if (!legHolds(run)) {
-                outcome = "claim_released";
-            }
-            else if (existsSync(path)) {
-                atomicWriteFile(this.tmpDir, path, text);
-                outcome = "written";
-            }
+        let outcome = "claim_released";
+        const held = fence.whileHoldingClaim(sessionId, claim.taskId, (run) => {
+            outcome = claim.legHolds(run) ? write(path, text) : "claim_released";
             return FENCE_LANDED;
         });
         return held ? outcome : "claim_released";
@@ -413,7 +532,7 @@ export class LocalCheckpointStore {
             }
             if (rec.updatedAt >= cutoff)
                 continue;
-            if ((await this.findPendingTokenBySession(rec.sessionId)) !== null)
+            if ((await this.findPendingTokenBySession(rec.sessionId, undefined, { axis: "run" })) !== null)
                 continue;
             if ((await this.opts.getActiveTaskId?.(rec.sessionId)) !== undefined)
                 continue;

package/dist/plugins/local-data-dir-modes-m39.js

@@ -1,3 +1,4 @@
+import { createLogger } from "../observability/logger.js";
 import { closeSync, constants as FS, fchmodSync, fstatSync, lstatSync, openSync, readdirSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { physicalPathOf } from "@sema-agent/core";
@@ -45,7 +46,7 @@ const emit = (sink, msg, meta) => {
         sink(msg, meta);
     }
     catch {
-        console.warn(msg, meta);
+        createLogger().warn(msg, meta);
     }
 };
 const sameObject = (a, b) => a.dev === b.dev && a.ino === b.ino;