@sema-agent/server 7.134.0 → 7.136.0

package/dist/plugins/file-history-store-sql.js

@@ -4,7 +4,7 @@ import { BlobTooLargeError, SqlBlobBackend } from "./blob-backend.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isMissingColumnError } from "./sql-errors.js";
 import { recordFailOpen } from "../observability/fail-open.js";
-import { discloseCaughtFailure } from "../file-history-disclosure.js";
+import { foldCaughtFailure } from "../file-history-disclosure.js";
 export const FILE_HISTORY_BLOB_TABLE = "file_history_blob";
 export const FILE_HISTORY_BLOB_KEY_PREFIX = "file-history/";
 const sha256hex = (s) => createHash("sha256").update(s).digest("hex");
@@ -117,7 +117,8 @@ export class SqlFileHistoryStore {
             return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} kept racing a concurrent retraction — retry` } };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${discloseCaughtFailure(err)}` } };
+            const f = foldCaughtFailure(err);
+            return { ok: false, error: { code: "track_failed", message: `first-touch record for ${absPath} could not be persisted: ${f.text}`, ...f.fault } };
         }
     }
     async annulIneligibleReason(scope, keyHash, absPath) {
@@ -190,7 +191,8 @@ export class SqlFileHistoryStore {
             return { ok: false, error: { code: "conflict", message: `first-touch record for ${absPath} was replaced while this retraction was being proven` } };
         }
         catch (err) {
-            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${discloseCaughtFailure(err)}` } };
+            const f = foldCaughtFailure(err);
+            return { ok: false, error: { code: "track_failed", message: `annulling the first-touch record for ${absPath} failed: ${f.text}`, ...f.fault } };
         }
     }
     async loadTracked(exec, scope, forUpdate = false) {
@@ -297,7 +299,8 @@ export class SqlFileHistoryStore {
             }
         }
         catch (err) {
-            return { ok: false, error: { code: "snapshot_failed", message: discloseCaughtFailure(err) } };
+            const f = foldCaughtFailure(err);
+            return { ok: false, error: { code: "snapshot_failed", message: f.text, ...f.fault } };
         }
         this.activeAttempts.add(lease);
         try {
@@ -399,7 +402,8 @@ export class SqlFileHistoryStore {
             catch (err) {
                 await conn.rollback().catch(() => undefined);
                 this.spentAttempts.add(lease);
-                return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${discloseCaughtFailure(err)}` } };
+                const f = foldCaughtFailure(err);
+                return { ok: false, error: { code: "snapshot_failed", message: `boundary for entry "${entryId}" could not be committed: ${f.text}`, ...f.fault } };
             }
             finally {
                 conn.release();
@@ -409,7 +413,8 @@ export class SqlFileHistoryStore {
         }
         catch (err) {
             this.spentAttempts.add(lease);
-            return { ok: false, error: { code: "snapshot_failed", message: discloseCaughtFailure(err) } };
+            const f = foldCaughtFailure(err);
+            return { ok: false, error: { code: "snapshot_failed", message: f.text, ...f.fault } };
         }
         finally {
             this.activeAttempts.delete(lease);
@@ -476,7 +481,7 @@ export class SqlFileHistoryStore {
                     });
                 }
                 catch (err) {
-                    applied = { outcome: "failed", reason: discloseCaughtFailure(err) };
+                    applied = { outcome: "failed", reason: foldCaughtFailure(err).text };
                 }
                 if (applied.outcome === "applied")
                     ledger.filesChanged.push(t.trackKey);
@@ -493,7 +498,8 @@ export class SqlFileHistoryStore {
         }
         catch (err) {
             const touched = empty.filesChanged.length > 0 || empty.identicalSkipped.length > 0 || empty.refused.length > 0 || empty.failed.length > 0;
-            return { outcome: touched ? "partial" : "failed", ...empty, error: { code: "restore_failed", message: discloseCaughtFailure(err) } };
+            const f = foldCaughtFailure(err);
+            return { outcome: touched ? "partial" : "failed", ...empty, error: { code: "restore_failed", message: f.text, ...f.fault } };
         }
     }
     async restorePlan(scope, entryId) {
@@ -596,7 +602,8 @@ export class SqlFileHistoryStore {
         catch (err) {
             if (err instanceof BlobTooLargeError)
                 return { ok: false, error: { code: err.code, message: err.message, wallSource: err.cap.source } };
-            return { ok: false, error: { code: "snapshot_failed", message: `putBlob ${hash} write/upload failed: ${discloseCaughtFailure(err)}` } };
+            const f = foldCaughtFailure(err);
+            return { ok: false, error: { code: "snapshot_failed", message: `putBlob ${hash} write/upload failed: ${f.text}`, ...f.fault } };
         }
     }
     async getBlob(hash) {
@@ -639,7 +646,8 @@ export class SqlFileHistoryStore {
             }
         }
         catch (err) {
-            return { ok: false, error: { code: "conflict", message: `adoptScope failed: ${discloseCaughtFailure(err)}` } };
+            const f = foldCaughtFailure(err);
+            return { ok: false, error: { code: "adopt_failed", message: `adoptScope failed: ${f.text}`, ...f.fault } };
         }
     }
     async scopeEmpty(exec, scope, forUpdate = false) {
@@ -698,7 +706,7 @@ export class SqlFileHistoryStore {
             await this.lockScope(conn, scope);
             const out = await this.exportOf(conn, scope, true);
             await conn.commit();
-            return out;
+            return { ok: true, history: out };
         }
         catch (err) {
             await conn.rollback().catch(() => undefined);
@@ -708,6 +716,29 @@ export class SqlFileHistoryStore {
             conn.release();
         }
     }
+    async verifySourceBlobs(data, srcGetBlob, onVerified) {
+        const needed = new Set();
+        for (const t of data.tracked)
+            for (const v of t.versions)
+                if (v.blobHash !== null)
+                    needed.add(v.blobHash);
+        for (const hash of needed) {
+            let bytes;
+            try {
+                bytes = await srcGetBlob(hash);
+            }
+            catch (err) {
+                return { ok: false, error: { code: "adopt_failed", message: `source blob ${hash} fetch failed: ${foldCaughtFailure(err).text}` } };
+            }
+            if (bytes === undefined)
+                return { ok: false, error: { code: "adopt_failed", message: `source blob ${hash} is missing — the envelope's graph cannot be completed, so nothing is published` } };
+            if (sha256hex(bytes) !== hash) {
+                return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fails content-address integrity — refused, nothing published` } };
+            }
+            await onVerified?.(hash, bytes);
+        }
+        return { ok: true };
+    }
     async importHistory(scope, data, srcGetBlob) {
         try {
             const shaped = validateFileHistoryExport(data);
@@ -721,32 +752,19 @@ export class SqlFileHistoryStore {
                     }
                 }
             }
-            const existing = await this.exportHistory(scope);
-            if (existing !== null) {
-                if (fileHistoryExportDigest(existing) === fileHistoryExportDigest(data))
-                    return { ok: true };
+            const exported = await this.exportHistory(scope);
+            if (!exported.ok)
+                return exported;
+            const existing = exported.history;
+            const sameGraph = existing !== null && fileHistoryExportDigest(existing) === fileHistoryExportDigest(data);
+            if (existing !== null && !sameGraph) {
                 return { ok: false, error: { code: "conflict", message: `importHistory target "${scope}" already holds a DIFFERENT history — a first import requires an empty target and a retry is legal only for the identical envelope (atomic visibility prevents half-graphs; this law prevents publishing the wrong complete graph over locally-grown history)` } };
             }
-            const needed = new Set();
-            for (const t of data.tracked)
-                for (const v of t.versions)
-                    if (v.blobHash !== null)
-                        needed.add(v.blobHash);
-            for (const hash of needed) {
-                let bytes;
-                try {
-                    bytes = await srcGetBlob(hash);
-                }
-                catch (err) {
-                    return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fetch failed: ${discloseCaughtFailure(err)}` } };
-                }
-                if (bytes === undefined)
-                    return { ok: false, error: { code: "not_found", message: `source blob ${hash} is missing — the envelope's graph cannot be completed, so nothing is published` } };
-                if (sha256hex(bytes) !== hash) {
-                    return { ok: false, error: { code: "unsupported_format", message: `source blob ${hash} fails content-address integrity — refused, nothing published` } };
-                }
-                await this.blobs.putBlob(hash, bytes);
-            }
+            const verified = await this.verifySourceBlobs(data, srcGetBlob, sameGraph ? undefined : (hash, bytes) => this.blobs.putBlob(hash, bytes));
+            if (!verified.ok)
+                return verified;
+            if (sameGraph)
+                return { ok: true };
             const conn = await this.db.connect();
             try {
                 await conn.begin();
@@ -789,7 +807,8 @@ export class SqlFileHistoryStore {
             }
         }
         catch (err) {
-            return { ok: false, error: { code: "unsupported_format", message: `importHistory failed: ${discloseCaughtFailure(err)}` } };
+            const f = foldCaughtFailure(err);
+            return { ok: false, error: { code: "adopt_failed", message: `importHistory failed: ${f.text}`, ...f.fault } };
         }
     }
 }

package/dist/plugins/file-run-store.d.ts

@@ -15,9 +15,9 @@ import { type SpaceCommitClaim, type SpaceCommitReading, type SpaceCommitState }
  * 存在的全部理由)。判据锚在**类型**上,不在文案上 —— 文案会改,类型不会(同文件族先例:`AdoptionError`
  * 在同一个降级臂里也是按类型无条件重抛)。
  *
- * 🔴 **S-384:本类自此 `extends StoreBootRefusalError`**(族规基类,见那条顶注)。上面这段论证对
+ * 🔴 **[ref]:本类自此 `extends StoreBootRefusalError`**(族规基类,见那条顶注)。上面这段论证对
  * **每一只**会在 `LocalBackend` 构造器里拒启的 File 店逐字成立,而逐个 `if instanceof` 手工登记会漏 ——
- * S-384 的 ask 账本拒启就漏过一次。继承 = 自动落在正确的一侧。
+ * [ref] 的 ask 账本拒启就漏过一次。继承 = 自动落在正确的一侧。
  */
 export declare class RunStoreStrictHydrateError extends StoreBootRefusalError {
     readonly name = "RunStoreStrictHydrateError";
@@ -76,7 +76,7 @@ export declare class FileRunStore implements InProcessClaimFence {
     /** Replay the on-disk registry/claims/event-logs into the in-memory index on boot. Each plane is torn-tail-/
      *  partial-write-safe (run.json via atomicWriteFile can never be half-written; the active file via writeThenLink is
      *  all-or-nothing; events.jsonl via the JSONL replay drops a crash tail). A corrupt run.json (failed parse) is
-     *  skipped — that run is lost, not a poison that fails the boot — and since S-582 the skip is disclosed and counted
+     *  skipped — that run is lost, not a poison that fails the boot — and since [ref] the skip is disclosed and counted
      *  (`server.run-store.corrupt-record-skipped`), never silent. */
     /**
      * hydrate 期**逐文件**读盘的统一口([ref] 件B / codex 对抗复审 R4-[high])。
@@ -92,7 +92,7 @@ export declare class FileRunStore implements InProcessClaimFence {
      */
     private replay;
     /**
-     * S-582 —— 本店**唯一**的盘上记录读口(hydrate 经 {@link replay} 包一层 strict 档,运行期读点直调它):
+     * [ref] —— 本店**唯一**的盘上记录读口(hydrate 经 {@link replay} 包一层 strict 档,运行期读点直调它):
      * 交形判据给重放属主,坏行按登记名 `run-store` 跳过 + 披露 + 计数。strict 档的射程是「文件读不出」,
      * 不含「文件里有坏行」—— 后者在两档下都走这里的 F 臂(普查表第 96 行)。
      */
@@ -139,10 +139,10 @@ export declare class FileRunStore implements InProcessClaimFence {
      *  offered) → the terminal row → the active-run claim release. Returns whether the pending record is now this run's. */
     private writeTerminal;
     /** Durable F4: park NON-terminal `suspended`, KEEP the task_active claim. CAS on running/suspended (reaper-revert guard).
-     *  S-173:同时落 `result` —— 封口脱敏后的投影(`sealRunRowResult`,凭据不落;`null` = 没观察到 park 结果),SQL 孪生同注。 */
+     *  [ref]:同时落 `result` —— 封口脱敏后的投影(`sealRunRowResult`,凭据不落;`null` = 没观察到 park 结果),SQL 孪生同注。 */
     setSuspended(taskId: string, result: PersistedTaskResult | null): Promise<void>;
     /** [ref] D-B: park NON-terminal `needs_review`, KEEP the claim. CAS on running/needs_review.
-     *  S-173:同 {@link setSuspended} 落封口脱敏后的 `result`。 */
+     *  [ref]:同 {@link setSuspended} 落封口脱敏后的 `result`。 */
     setNeedsReview(taskId: string, result: PersistedTaskResult | null): Promise<void>;
     /** Durable F4 resume: flip suspended/needs_review → running (CAS) + reset cancel/preempt flags.
      *  [ref](codex R1 [medium]):认领 = 接管 `instanceId`(= 当前持有副本;SQL 孪生同注)。CAS 输不改。 */
@@ -165,7 +165,7 @@ export declare class FileRunStore implements InProcessClaimFence {
     /** Runs newest-first, keyset on (createdAt, taskId) DESC; optional exact-match filters (owner is exact, like the SQL). */
     listRuns(opts: RunListQuery): Promise<RunRecord[]>;
     /**
-     * S-297 —— 这个会话**最近一条腿**的窄指针({@link SqlRunStore.latestRunForSession} 的孪生:同一个排序口径
+     * [ref] —— 这个会话**最近一条腿**的窄指针({@link SqlRunStore.latestRunForSession} 的孪生:同一个排序口径
      *  `createdAt DESC, taskId DESC`,与本店 {@link FileRunStore.listSessions} 挑 `rn=1` 那一行的比较器逐字同一份)。
      */
     latestRunForSession(sessionId: string): Promise<LatestRunRef | undefined>;
@@ -225,7 +225,7 @@ export declare class FileRunStore implements InProcessClaimFence {
     /** [ref] wire the checkpoint probe (LocalBackend.checkpoint(), where checkpoint + run store share one root). */
     setCheckpointProbe(probe: RunStoreCheckpointProbe): void;
     /** [ref] shared tail of both suspended-run reapers: flip one parked row → failed('approval.expired') and
-     *  PERSIST it — the file twin of the SQL UPDATE (`error`/`error_code` set directly, no result blob; S-173: the park-time `result` is cleared, same as the SQL `result = NULL`). */
+     *  PERSIST it — the file twin of the SQL UPDATE (`error`/`error_code` set directly, no result blob; [ref]: the park-time `result` is cleared, same as the SQL `result = NULL`). */
     private failExpiredPark;
     /**
      * [ref] Durable F4 expiry — the file twin of TiDBRunStore.reapSuspended, driven by the injected checkpoint

package/dist/plugins/fork-routing-session-store.d.ts

@@ -87,13 +87,13 @@ export declare class ForkRoutingSessionStore implements SessionStore {
      *
      * 已在 host(路由或真行)⇒ 幂等直返。两店都无此会话 ⇒ 抛(调用方=park veto,诚实 fail-closed)。
      *
-     * S-1770:宿主行**在建行那一笔里**带属主 `owner` —— 调用方按委派继承律算好(`delegated-session-owner.ts`:委派树根的属主,
+     * [ref]:宿主行**在建行那一笔里**带属主 `owner` —— 调用方按委派继承律算好(`delegated-session-owner.ts`:委派树根的属主,
      * 推不出 ⇒ 孤行哨兵;`tree` = 判据读到的委派树,判断用:宿主行记着别的树 ⇒ 拒),这里经宿主店的首写登记写下、再按律定夺(core `register` 契约:登记不判授权,判在复读)。
      * 宿主店里同 id 已有一行:记着这一棵委派树且无主 ⇒ 按同一条律认领(只有记录委派树的店);别的树的 / 属主不是它(别人先认领的空壳,或 local 店的无主空壳)⇒ 抛(停驻否决),
      * 转录不拷进别人的行;宿主店记不了 / 读不回属主 ⇒ 同样抛 —— 晋升出一只无主的转录行就是把它交给任何拿到 id 的人。
      */
     promoteToHost(sessionId: string, owner: string | null, tree: DelegationTree): Promise<void>;
-    /** 晋升的建行那一笔(S-1770,规则见 {@link promoteToHost} 头注):宿主店首写登记 `owner`,然后按律定下宿主行的属主(与停驻快路同一只 `settleDelegatedOwner`)。 */
+    /** 晋升的建行那一笔([ref],规则见 {@link promoteToHost} 头注):宿主店首写登记 `owner`,然后按律定下宿主行的属主(与停驻快路同一只 `settleDelegatedOwner`)。 */
     private registerPromotedOwner;
     fork(sourceId: string, owner?: string | null): Promise<string | null>;
     get size(): number;

package/dist/plugins/fork-routing-session-store.js

@@ -223,7 +223,7 @@ export class ForkRoutingSessionStore {
         const register = this.host.register;
         const host = delegatedOwnerHostOf(this.host);
         if (register === undefined || host === undefined) {
-            throw new Error(`session "${sessionId}" cannot be promoted: the host session store cannot record or read back a session owner (register / ownerOf / sessionFaceOf; placementOf and claimOwnerless together or neither), so the promoted transcript would land ownerless`);
+            throw new Error(`session "${sessionId}" cannot be promoted: the host session store cannot record or read back a session owner (register / headOf; placementOf and claimOwnerless together or neither), so the promoted transcript would land ownerless`);
         }
         await register.call(this.host, sessionId, owner);
         await settleDelegatedOwner(host, sessionId, owner, tree);

package/dist/plugins/host-platform.d.ts

@@ -106,15 +106,15 @@ export declare function spawnGroupOptions(): {
  * INCLUDING the throw on a dead group (ESRCH): every call site already wraps in its own try/catch with its own
  * fallback (e.g. `child.kill("SIGKILL")`), and that structure must not change.
  * win32 = core `signalProcessTree(pid,"SIGKILL")` → `taskkill /F /T` (never throws — fire-and-forget spawn).
- * 不返回「落地」证据(S-769 车PA):POSIX 组信号「任一成员收到即成功」,返回成功证明不了组里没有打不着的活成员 —— 这一枪之后
+ * 不返回「落地」证据([ref] 车PA):POSIX 组信号「任一成员收到即成功」,返回成功证明不了组里没有打不着的活成员 —— 这一枪之后
  * 「这个组还在不在」只由观察回答(同步硬收座 {@link hardKillGroupNow} 的 ESRCH、node 收割组长),不由这里推断。
  */
 export declare function killTreeHard(pid: number): void;
 /**
- * S-745(core 7.32.0 #1107)—— **同步组硬收的一枪**:后台 driver 的 `killBackgroundNow` 座位用它(梯子的「组 SIGKILL」那一级,
+ * [ref](core 7.32.0 [ref])—— **同步组硬收的一枪**:后台 driver 的 `killBackgroundNow` 座位用它(梯子的「组 SIGKILL」那一级,
  * 不经 TERM、不挂定时器)。读数是 core 座位闭集里的三词,判据只看 `kill` 系统调用自己的结局:
  *  · POSIX:`kill(-pid, SIGKILL)` 落地 ⇒ `killed`;`ESRCH`(这个组已经没有进程)⇒ `already_gone`;其余拒因(`EPERM` 一族)⇒
- *    `no_pgid`(没有落地,调用方可重试;core 随即派普通 kill)。⚠️ S-769 读数:darwin 对「组里只剩还没被 node 收割的僵尸」也答 `EPERM`
+ *    `no_pgid`(没有落地,调用方可重试;core 随即派普通 kill)。⚠️ [ref] 读数:darwin 对「组里只剩还没被 node 收割的僵尸」也答 `EPERM`
  *    (linux 答成功)。本函数**不**替它改判:EPERM 同样是「组里还有无权发信号的活成员」的答复,只看组长分不开这两形(codex r1 C1 [high]
  *    验真:组长已死未收割 + 活后代被拒 ⇒ 改判就把真被拒读成已不在)。落地也**不**等于「组已空」(组信号任一成员收到即成功,车PA)——
  *    所以 `already_gone` 只有 ESRCH 这一个来源;梯子那一枪先落地、组长还没收割的那一拍,darwin 上如实答 `no_pgid`(未确认),linux 答 `killed`;
@@ -138,7 +138,7 @@ export { killProcessTree };
 /**
  * 登记回执 = 注销的**唯一**凭据(身份即凭据,见簿注)+ 一只幂等的注销把手。
  *
- * S-566 归一轮:注销**只有这一张脸**(`release()`)。此前另有一只 `untrackHostForegroundChild(ticket)`
+ * [ref] 归一轮:注销**只有这一张脸**(`release()`)。此前另有一只 `untrackHostForegroundChild(ticket)`
  * 自由函数,于是「把这只回执从簿上删掉」有两种写法 —— 零别名纪律下这属于歧义面,已**整个删除**
  * (硬 breaking 三句:没有别名、没有过渡方法,调用方的 tsc 红就是通知)。
  */
@@ -158,13 +158,13 @@ export interface ForegroundChildTicket {
  */
 export declare function trackHostForegroundChild(pid: number): ForegroundChildTicket;
 /**
- * 🔴 **本簿在 `src/` 的唯一登记口**(S-566 归一轮)—— 一只自起的 detached 前台子进程「进簿 + 两只主注销」
+ * 🔴 **本簿在 `src/` 的唯一登记口**([ref] 归一轮)—— 一只自起的 detached 前台子进程「进簿 + 两只主注销」
  * 的**全部**语义收在这里。
  *
  * ── 为什么是一只函数而不是五处同一句 ────────────────────────────────────────────────────────────
  * 归一前,这一句在仓里**手抄五份**(`remote-env-host.ts` 三条 fg 腿 + `hook-runner.ts` 两条):
  * 「`pid != null` 才登记」「`exit` 主注销」「`error` 之后 `exit` 可能不来,所以也要注销」——
- * 每多一条 detached 腿就要再抄一遍,而**第六处只要漏抄一臂就是一个静默的孤儿洞**(S-566 的病正是
+ * 每多一条 detached 腿就要再抄一遍,而**第六处只要漏抄一臂就是一个静默的孤儿洞**([ref] 的病正是
  * hook 那两条腿整份没抄)。一条规则答完所有腿,规则集因此变小而不是变大。
  *
  * ── 语义(三条,逐条有理由)────────────────────────────────────────────────────────────────────
@@ -184,7 +184,7 @@ export declare function adoptHostForegroundChild(child: ChildProcess): Foregroun
 /** 一次前台收割的读数。三格分开是**刻意**的:`alreadyDead` 是想要的结果(不是失败),`failed` 是**真的**
  *  没收上来 —— 两者混成一个数就等于把后者静默掉([ref]:这条腿上不许有安静的兜底)。
  *
- *  🔴 **三格只描述调用的那一拍**(S-557):`failed: []` 读作「这一拍发出去的信号没有被拒」,**不是**
+ *  🔴 **三格只描述调用的那一拍**([ref]):`failed: []` 读作「这一拍发出去的信号没有被拒」,**不是**
  *  「机器上一个都没落下」—— 簿在这一拍之后照样可以再登记(受控退的窗里在飞 turn 还在 spawn)。
  *  「一个都没落下」这句话的承重点是退出边界那只钩,不是任何一次读数。 */
 export interface ForegroundReapReading {
@@ -199,8 +199,8 @@ export interface ForegroundReapReading {
  * 收割簿上全部前台子进程组。返回**发出**信号的读数,不是确认死亡数 —— 确认要等,而本函数的调用点之一
  * 是 uncaught 出口。
  *
- * **同步形、一次到位、不等宽限**(S-557 起自述与实现同一句):承重的调用点是退出边界装配器
- * (`boot/exit-boundary.ts`)那只 `process.once("exit")` 钩 —— S-560 起它由**两条车道共用**(HTTP 服务的
+ * **同步形、一次到位、不等宽限**([ref] 起自述与实现同一句):承重的调用点是退出边界装配器
+ * (`boot/exit-boundary.ts`)那只 `process.once("exit")` 钩 —— [ref] 起它由**两条车道共用**(HTTP 服务的
  * 收尾链 + `run-local` 一次性 CLI;后者另装 SIGINT/SIGTERM 处理器,因为前台 CLI 的 Ctrl-C 若走默认终止,
  * `exit` 钩不触发)。`exit` 之后**没有续段**,`await` 一个宽限梯就是把收割赌在一个永远等不到的
  * 时刻上(`hardShutdown` 终点那次早按只是优化,见 `boot/shutdown.ts` 的两处注)。上界 = 簿上条数 ×
@@ -225,7 +225,7 @@ export interface ForegroundReapReading {
  * 真的成立。后台腿的宽限梯不受影响(那条腿有自己的属主,且不在本簿里)。
  */
 export declare function reapHostForegroundChildren(): ForegroundReapReading;
-/** 簿上现存条数。S-557 起**产品面也读它**(退出边界钩的「exit 时簿上还剩几条」哨兵),与第二本同形簿的
+/** 簿上现存条数。[ref] 起**产品面也读它**(退出边界钩的「exit 时簿上还剩几条」哨兵),与第二本同形簿的
  *  {@link liveEphemeralHostWorkspaceCount} 同名同形 —— 所以名字里不再带 `ForTest`(零别名,旧名直接消失)。 */
 export declare function liveHostForegroundChildCount(): number;
 /**

package/dist/plugins/image-bake-store-sql.d.ts

@@ -10,7 +10,7 @@ import { type IndexSpec } from "./ensure-index.js";
  *  读侧 `!!`/`Boolean()` 保持,store 出口 JS 类型逐字节不变(真双库套件的严格值断言为证)。
  *  The line UNIQUE is given the explicit name uq_image_bake_event_line so a 23505 can be attributed to it via err.constraint. */
 export declare const PG_IMAGE_BAKE_SCHEMA: string[];
-/** S-287:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensurePgImageBakeSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
+/** [ref]:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensurePgImageBakeSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
 export declare const IMAGE_BAKE_INDEXES: readonly IndexSpec[];
 /** Idempotent self-contained PG schema apply (for the integration test; central aggregation is done separately). */
 export declare function ensurePgImageBakeSchema(pool: PgPool | PoolClient, poolName?: string): Promise<void>;

package/dist/plugins/image-index-sql.d.ts

@@ -8,7 +8,7 @@ export type { ImageNestedBuildMode, ImageCapabilities, ImagePodContract, ImageSt
  *  TINYINT(1)→SMALLINT(布尔列 PG 映射归一,clay 批 2026-07-26 —— 两方言读回同为 number,写入 0/1,
  *  读侧 `!!` 保持,出口 JS 类型不变), inline UNIQUE KEY/KEY → separate CREATE UNIQUE INDEX / CREATE INDEX). */
 export declare const PG_IMAGE_INDEX_SCHEMA: string[];
-/** S-287:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensureSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
+/** [ref]:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensureSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
 export declare const IMAGE_INDEX_INDEXES: readonly IndexSpec[];
 /** Idempotent self-contained schema apply (for the integration test; central aggregation is done separately). */
 export declare function ensureSchema(pool: PgPool | PoolClient): Promise<void>;

package/dist/plugins/leader-run-store-sql.d.ts

@@ -39,7 +39,7 @@ export declare const LEADER_OBJECTIVE_PREVIEW_CHARS = 160;
 export declare const TIDB_LEADER_RUN_STATEMENTS: readonly string[];
 /** PG 方言的建表语句(MySQL 孪生的逐条翻译:JSON→JSONB,逐列 `COLLATE "C"`,内联 KEY→独立 CREATE INDEX)。 */
 export declare const PG_LEADER_RUN_SCHEMA: readonly string[];
-/** S-287:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensurePgLeaderRunSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
+/** [ref]:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensurePgLeaderRunSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
 export declare const LEADER_RUN_INDEXES: readonly IndexSpec[];
 /** 幂等的 PG schema 应用(中央 `ensurePgSchema` 组合它;集成套件也直接调)。 */
 export declare function ensurePgLeaderRunSchema(q: (text: string, params?: unknown[]) => Promise<unknown>): Promise<void>;

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

@@ -4,9 +4,9 @@ import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
 export interface LocalCheckpointStoreOptions {
     /** taskId join for the pending card (the local FileRunStore's `getActiveTaskId`). Absent ⇒ `taskId: null`. */
     getActiveTaskId?: (sessionId: string) => Promise<string | undefined>;
-    /** E21 owner guard (the LocalSessionStore's `ownerOf`). 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). */
-    ownerOf?: (sessionId: string) => Promise<string | null | 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>;
 }
 export declare class LocalCheckpointStore {
     /** [ref] 车1:托管留存声明 —— **诚实的 none**(与 local session 店同一条判据:本店的行没有按期删除的腿;
@@ -42,7 +42,7 @@ export declare class LocalCheckpointStore {
         readonly reopen: true;
     };
     /**
-     * `CheckpointStore.execution` 声明(core 7.7.0 [ref];S-160)——**必填**,与上面三格同一条判据:**如实
+     * `CheckpointStore.execution` 声明(core 7.7.0 [ref];[ref])——**必填**,与上面三格同一条判据:**如实
      * 按内核判**。内核 core `FileCheckpointStore` 自己声明 `{ outcome: true }`,并把执行记录落成 ledger 的
      * 一个新事件种类(`execution`,与 resolve 同款「先 append+fsync 再翻内存」的崩溃序),
      * {@link LocalCheckpointStore.recordExecutionOutcome} 与 {@link LocalCheckpointStore.reopen} 都是纯委派
@@ -78,7 +78,7 @@ export declare class LocalCheckpointStore {
     get(token: CheckpointToken): Promise<Checkpoint | null>;
     resolve(token: CheckpointToken, scope: string, outcome: ResumeOutcome, expect?: ResolveExpectation): Promise<boolean>;
     reopen(token: CheckpointToken, scope: string, reason: ReopenReason): Promise<boolean>;
-    /** core 7.7.0 [ref](S-160):执行判词的 CAS —— 语义、四词、幂等的结构相等与冲突抛全在被包的内核里
+    /** core 7.7.0 [ref]([ref]):执行判词的 CAS —— 语义、四词、幂等的结构相等与冲突抛全在被包的内核里
      *  (它自己走 core 的共享判词 `executionRecordDisposition`,ledger 事件 `execution` 是它的 commit 半场),
      *  本 wrapper 只做转发。服务扩展面(运维队列/会话索引)与这条记录无关:它不改 status,也不新增可枚举行。 */
     recordExecutionOutcome(token: CheckpointToken, scope: string, gate: GateOutcome): Promise<ExecutionOutcomeRecordWord>;
@@ -134,11 +134,11 @@ export declare class LocalCheckpointStore {
      */
     findDecidedApprovalsForBinding(sessionId: string, boundCallId: string): Promise<DecidedApprovalRecord[]>;
     /**
-     * S-384 —— 对账收敛器**判据 1**(身份三元组 ∧ hash 双等 ⇒ `bindBatch`)的读口在 local 车道的形。
+     * [ref] —— 对账收敛器**判据 1**(身份三元组 ∧ hash 双等 ⇒ `bindBatch`)的读口在 local 车道的形。
      * 语义、判别纪律、`unparseable` 的含义,唯一属主 = SQL 孪生 `findCheckpointCandidatesForAsk` 的顶注与
      * `CheckpointAskCandidate` 的字段注;这里只记**本形自己的三处差别**。
      *
-     * 🔴 **为什么必须有这一口**(不是锦上添花):S-384 让 local 车道有了持久 ask 账,于是收敛器在这条车道上
+     * 🔴 **为什么必须有这一口**(不是锦上添花):[ref] 让 local 车道有了持久 ask 账,于是收敛器在这条车道上
      * 第一次真的有行可扫。缺这一口 ⇒ 判据 1 结构性不命中 ⇒ **窗到期 park 的 ask 行永远停在 `PARKING`**,
      * 而那个态在 wire 上是有后果的:`POST /v1/tool-approvals/:id/respond` 的 `PARKING` 臂答的是
      * `202 parking_in_progress + retryAfterMs`(它的前提是「`bindBatch` 毫秒级就到」),在一台绑不了的机器上
@@ -177,7 +177,7 @@ export declare class LocalCheckpointStore {
     /**
      * [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
-     * listExpiredApprovalGates). Among approval kinds the ONE judge is core `facetOf(gate)` (#1468 A-S4): a gate
+     * listExpiredApprovalGates). Among approval kinds the ONE judge is core `facetOf(gate)` ([ref] A-S4): a gate
      * carrying the `question` card is facet `B` — its deadline voids it (denying a question is incoherent); a gate
      * with no card (parked before core 7.49.0) is no question (core's reading, never re-derived from the tool name).
      * The terminal_at_ms branch (derived read-time via the SAME formula the SQL put stamps) abort-expires ANY kind.
@@ -202,7 +202,7 @@ export declare class LocalCheckpointStore {
      */
     putCtx(sessionId: string, ctx: SealedCheckpointCtx): Promise<void>;
     /**
-     * 🔴 **坏体 ⇒ 拒,绝不读成缺席**(S-577,与 SQL 孪生同一条判据)。修前这里是
+     * 🔴 **坏体 ⇒ 拒,绝不读成缺席**([ref],与 SQL 孪生同一条判据)。修前这里是
      * `catch { return null }` + `(rec.ctx as T) ?? null`,于是一个撕裂 / 手改 / 权限读不动的 ctx 文件与
      * 「这条会话根本没有 ctx」在消费点上**逐字同答**(409 `resume context missing`)—— 运维据此去「重新
      * 提交一个任务」,而真因是盘上那一格坏了。三个店同向:不是「这一行不在」,是「这一行读不出来」。
@@ -227,7 +227,7 @@ export declare class LocalCheckpointStore {
     /**
      * E21 session purge — functional contract: a deleted session has no resumable future. Expires every pending
      * gate of the session (all scopes) + unlinks its ctx file. Owner guard mirrors the SQL EXISTS guard: with an
-     * `ownerOf` source the owner must null-safe-match; without one, only an ownerless call (owner=null) purges.
+     * owner source (`readSessionOwner`) the owner must null-safe-match; without one, only an ownerless call (owner=null) purges.
      * Returns the number of gates expired. (Terminal ledger history stays on disk — local transcripts posture.)
      */
     deleteBySession(sessionId: string, owner: string | null): Promise<number>;

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

@@ -1,11 +1,10 @@
 import { z } from "zod";
-import { parkedApprovalCard } from "../approval-content-kind.js";
-import { parkRowFacts } from "../approval-card.js";
+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, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { denySweepOwns } from "../tool-approval.js";
 import { FileCheckpointStore, atomicWriteFile, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
 import { approvalDecisionOfWinner, approvalPayloadFingerprint, boundedRuleOffers, boundedToolInput, pendingActionToolCallId, pendingRowPrecedes, queueRowGateKind, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-sql.js";
 import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
@@ -156,7 +155,7 @@ export class LocalCheckpointStore {
             for (const summary of await this.inner.listByScope(s)) {
                 const cp = await this.inner.get(summary.token);
                 if (cp && cp.status === "pending")
-                    out.push({ token: summary.token, cp });
+                    out.push({ token: summary.token, cp, summary });
             }
         }
         return out;
@@ -166,7 +165,7 @@ export class LocalCheckpointStore {
     }
     async listPending(scope) {
         const rows = [];
-        for (const { token, cp } of await this.pendings(scope)) {
+        for (const { token, cp, summary } of await this.pendings(scope)) {
             const pa = cp.pendingAction;
             const gate = cp.gate;
             const gateKind = queueRowGateKind(gate?.kind);
@@ -194,6 +193,7 @@ export class LocalCheckpointStore {
                 ...(pa?.hasBidiControls === true ? { hasBidiControls: true } : {}),
                 ...((card) => (card !== undefined ? { approvalCard: card } : {}))(parkedApprovalCard(cp.gate)),
                 ...parkRowFacts(cp.pendingAction),
+                ...skillCardFacts(summary),
             });
         }
         return rows.sort((a, b) => (b.riskDescriptor?.severity ?? 0) - (a.riskDescriptor?.severity ?? 0) || a.createdAt - b.createdAt);
@@ -382,8 +382,8 @@ export class LocalCheckpointStore {
         return n;
     }
     async deleteBySession(sessionId, owner) {
-        if (this.opts.ownerOf) {
-            const actual = await this.opts.ownerOf(sessionId);
+        if (this.opts.readSessionOwner) {
+            const actual = await this.opts.readSessionOwner(sessionId);
             if (actual === undefined)
                 return 0;
             if ((actual ?? null) !== (owner ?? null))