@sema-agent/server 7.133.0 → 7.134.0

package/dist/caller-text-echo.d.ts

@@ -1,5 +1,7 @@
 /** 回显的字符上限(剥完控制与双向字符之后数)。 */
 export declare const CALLER_TEXT_ECHO_MAX_CHARS = 64;
+/** 回显被截时补在末尾的记号 —— 回显口径的唯一属主;出口座的日志字段行(`trace/exit-seat.ts`)读同一枚,不另写一个 `…`。 */
+export declare const CALLER_TEXT_CUT_MARK = "\u2026";
 /** 站点给的回显选项。 */
 export interface EchoCallerTextOptions {
     /** 回显的字符上限(剥完控制与双向字符之后数);不给 = {@link CALLER_TEXT_ECHO_MAX_CHARS}。必须是正整数,否则抛 `RangeError`(编程错误,不静默落成某个长度)。 */

package/dist/caller-text-echo.js

@@ -1,11 +1,12 @@
 import { stripControlAndBidi } from "@sema-agent/settings-schema";
 export const CALLER_TEXT_ECHO_MAX_CHARS = 64;
+export const CALLER_TEXT_CUT_MARK = "…";
 export function echoCallerText(text, opts) {
     const max = opts?.maxChars ?? CALLER_TEXT_ECHO_MAX_CHARS;
     if (!Number.isInteger(max) || max < 1)
         throw new RangeError(`echoCallerText: maxChars must be a positive integer, got ${String(max)}`);
     const clean = stripControlAndBidi(text);
-    return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+    return clean.length > max ? `${clean.slice(0, max)}${CALLER_TEXT_CUT_MARK}` : clean;
 }
 export function quotedCallerText(text) {
     return `"${echoCallerText(text)}"`;

package/dist/canonical-json.d.ts

@@ -1,46 +1,7 @@
 /**
- * Canonical JSON(键递归排序、零空白、数组保序)—— 本仓所有「先序列化再 sha256 / 指纹自比」站点的**单一序列化器**
- * ([ref] / [ref],2026-08-31 合并批)。
- *
- * ## 为什么只能有一个
- * 合并前本仓有 **5 处**手写复刻(memory-origin-fence / permission-rule-store-sql / bench-l8 artifact /
- * web-admin restart-signal / mcp-revocation),每处一份「排 key、递归、拼串」——同一个算法五份实现,
- * 语义在边缘(undefined 值键、函数成员、非有限数)各自漂了一点。指纹型代码的病灶恰恰在边缘:同一份内容算出
- * 两个指纹 = 落库 checksum 失配 / 误签 restart / 包完整性自校验对不上。
- *
- * ## 语义 = core `canonicalJsonStringify` 的**逐字港**(fidelity 高于「更漂亮」)
- * 治理携出包(`POST /v1/memory/export`)的 `integrity.sectionHashes.entries` 必须与 core 铸包/校验时算的
- * 哈希**逐字节相同**(core `memoryBundleInvalid` 三向对账),而 core 公共面只出口 `computeMemoryBundleHash`
- * (Record 特化),不出口这只序列化器(`dist/core/memory-engine/file-backend.js#canonicalJsonStringify`,
- * exports 封死)——所以本仓必须持有一份逐字港,且**不得**在下游「修」它的边缘行为(源头修复纪律:
- * core 若改形,港随之改;本仓不做第二个写者)。防漂移钉 = `test/memory-origin-fence.test.ts` §④(期望哈希全
- * 经 core 出口独立算出)。
- *
- * 语义表(与 core 逐字同;`test/canonical-json.test.ts` 逐行钉):
- *  · 对象:own 可枚举键,**值为 `undefined` 的键省略**(与 `JSON.stringify` 同),其余按 UTF-16 码元序排序
- *    (`Object.keys().sort()`,数字形键同样按字符串序:`"10" < "2"`);键经 `JSON.stringify` 转义。
- *  · 数组:保序;元素 `undefined` / 函数 / symbol ⇒ `null`(与 `JSON.stringify` 同)。
- *  · 标量:`JSON.stringify`(`NaN`/`±Infinity` ⇒ `null`、`-0` ⇒ `0`、字符串转义与 `JSON.stringify` 同)。
- *  · **非 JSON 输入的港继承形(不是本仓的设计,是 core 的形,如实记)**:对象成员为函数/symbol 时,键**保留**
- *    而值经 `JSON.stringify` 得 `undefined` ⇒ 拼出字面 `undefined`(非法 JSON 文本);顶层 `undefined`/函数/symbol
- *    ⇒ 返回 `undefined`(非字符串)。五个站点的真实输入全是 JSON 形(JSON.parse 产物 / DB 行 / zod 解析产物),
- *    这两条**不可达**;需要「非法输入响亮拒」的站点用 {@link canonicalJsonStrict}。
- *  · `Date`/`Map`/`Set`/类实例:按普通对象处理(own 可枚举键 ⇒ `Date` 成 `{}`),**不调 `toJSON`**——与 core 同。
- *  · `bigint`:`JSON.stringify` 抛 TypeError,原样上抛。
- *
- * ## 不在本文件里的第二形(如实登记)
- * `src/web-admin-client/restart-signal.ts#stableStringify`(mcp-revocation 同源改调)是**另一个语义**:undefined 值键
- * **保留为 `"k":null`**。两族在 JSON 形输入上逐字节相同(golden 交叉读数已证),分歧只在进程内构造的
- * `{k: undefined}` 形——restart 指纹的输入正是进程内切片对象,该形原则上可达,而 `{k:undefined}` 与 `{}` 是否
- * 同指纹是 restart-signal 轴上的**行为**(多签/少签一次 fleet 滚动重启),不是序列化器的私事 ⇒ 本批不并
- * (语义恒等才可合并),golden 各自钉,K→O 统一另立件走三问。
- */
-/** core `canonicalJsonStringify` 的逐字港(语义表见文件头)。 */
-export declare function canonicalJson(value: unknown): string;
-/**
- * 严格形:先按**同一遍历序**校验,再交 {@link canonicalJson} 序列化 —— 被签名/被内容哈希的载荷(bench/l8 部署
+ * 严格形:先按**同一遍历序**校验,再交 core `canonicalJsonStringify` 序列化 —— 被签名/被内容哈希的载荷(bench/l8 部署
  * 真实性 artifact)不许把 `NaN`/`Infinity` 静默写成 `null`(签名盖在坏字节上),也不许把函数/bigint/顶层
- * `undefined` 当作可序列化。校验通过的输入域上,输出与 {@link canonicalJson} **逐字节相同**(golden 钉);
+ * `undefined` 当作可序列化。校验通过的输入域上,输出与 core `canonicalJsonStringify` **逐字节相同**(golden 钉);
  * 拒绝集与错误文案 = 合并前 `src/bench/l8/artifact.ts#serialize` 逐字(`test/l8-deploy-contract.test.ts` 钉
  * `/non-finite/`):
  *  · 非有限数(任意深度)⇒ `canonicalJson: non-finite number is not serializable`

package/dist/canonical-json.js

@@ -1,18 +1,7 @@
-export function canonicalJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map((v) => (v === undefined || typeof v === "function" || typeof v === "symbol" ? "null" : canonicalJson(v))).join(",")}]`;
-    if (value !== null && typeof value === "object") {
-        const rec = value;
-        const keys = Object.keys(rec)
-            .filter((k) => rec[k] !== undefined)
-            .sort();
-        return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(rec[k])}`).join(",")}}`;
-    }
-    return JSON.stringify(value);
-}
+import { canonicalJsonStringify } from "@sema-agent/core";
 export function canonicalJsonStrict(value) {
     assertCanonicalJsonSerializable(value);
-    return canonicalJson(value);
+    return canonicalJsonStringify(value);
 }
 function assertCanonicalJsonSerializable(v) {
     if (v === null)

package/dist/capabilities/composite-members.d.ts

@@ -45,7 +45,7 @@ export declare const COMPOSITE_CAPABILITY_MEMBERS: {
     readonly centerWiring: readonly ["effectivePull", "effectiveRevision", "lease", "leaseHealth", "failMode", "usageReport", "issuer", "worker", "caller"];
     readonly webSearch: readonly ["backend"];
     readonly background: readonly ["listFace", "exitFaces"];
-    readonly taskSettings: readonly ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks", "pluginHooks", "managedHookGroups", "tightenOnlySeats"];
+    readonly taskSettings: readonly ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks", "pluginHooks", "managedHookGroups", "tightenOnlySeats", "approvalFrameFamilies"];
     readonly settings: readonly ["permissions"];
     readonly permissionModeAuto: readonly ["accepted", "classifierSeat", "entitlementSource", "armed", "reason", "model"];
     readonly writeProtection: readonly ["armed", "rows", "replaced"];

package/dist/capabilities/composite-members.js

@@ -6,7 +6,7 @@ export const COMPOSITE_CAPABILITY_MEMBERS = {
     centerWiring: ["effectivePull", "effectiveRevision", "lease", "leaseHealth", "failMode", "usageReport", "issuer", "worker", "caller"],
     webSearch: ["backend"],
     background: ["listFace", "exitFaces"],
-    taskSettings: ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks", "pluginHooks", "managedHookGroups", "tightenOnlySeats"],
+    taskSettings: ["permissions", "permissionMode", "model", "outputStyle", "env", "hooks", "pluginHooks", "managedHookGroups", "tightenOnlySeats", "approvalFrameFamilies"],
     settings: ["permissions"],
     permissionModeAuto: ["accepted", "classifierSeat", "entitlementSource", "armed", "reason", "model"],
     writeProtection: ["armed", "rows", "replaced"],

package/dist/capabilities/mcp-probe.js

@@ -1,7 +1,7 @@
 import { probeMcpServers } from "@sema-agent/core";
 import { createHash } from "node:crypto";
 import { createFixedWindowRateLimiter } from "../device-enrollment.js";
-import { canonicalJson } from "../canonical-json.js";
+import { canonicalJsonStringify } from "@sema-agent/core";
 import { keyClosureClause, scanKeyClosure } from "../request-key-closure.js";
 import { requestMcpDeclarationRefusal, validateRequestMcp } from "../task-mcp.js";
 import { specWithholdsMcpAssertionHeader, toCoreMcpServerSpec } from "../mcp-assertion-header.js";
@@ -86,7 +86,7 @@ export function buildMcpProbeIdentity(principal) {
     return principal !== undefined && principal.length > 0 ? principal : "local";
 }
 export function buildMcpProbeCacheKey(principal, specs) {
-    return `${buildMcpProbeIdentity(principal)}::${createHash("sha256").update(canonicalJson(specs), "utf8").digest("hex")}`;
+    return `${buildMcpProbeIdentity(principal)}::${createHash("sha256").update(canonicalJsonStringify(specs), "utf8").digest("hex")}`;
 }
 export function buildMcpProbeRateKey(principal) {
     return `mcp-probe:${buildMcpProbeIdentity(principal)}`;

package/dist/capability-facts.d.ts

@@ -220,6 +220,8 @@ export declare function readRootGrant(d: Pick<Deps, "config">): Fact<"read_root_
  *  · 活卡协调器缺席 ⇒ `[]`(没有审批卡可呈)。
  * 对 why 闭集穷举:`streamApproval` 的拒因多一个 ⇒ 这里编译红,逼着给新拒因定族。三条执行腿选族读的是同一只判据的 `active`,
  * 与本映射的「在场 ⇒ 呈卡族」是同一条规则(真腿对拍钉在 `test/stream-approval-on-e2e.test.ts`)。没有端点按它拒:它是消费方分派帧族的读点,`streamApproval` 的词义不变。
+ * S-1914:它也是壳**声明**的依据 —— 一条 run 只在 `settings.approvalFrameFamilies` 含本位那一个族时有活审批通道(三条腿判的是同一只映射
+ * `presentedApprovalFrameFamily`);不含 ⇒ 这条腿不呈卡,问当场交无人值守政策口。本位的值不因声明而变。
  */
 export declare function approvalFrameFamilies(stream: ReturnType<typeof streamApproval>): readonly ApprovalFrameFamily[];
 export declare function deviceLane(d: Pick<Deps, "deviceHub">): Fact<"device_hub_absent", {

package/dist/capability-facts.js

@@ -1,7 +1,7 @@
 import { buildOperatorRosterWayOut, operatorRosterPresent } from "./http/principal-gate.js";
 import { mcpInjectionHonored } from "./task-mcp.js";
 import { cwdHonored } from "./task-cwd.js";
-import { resolveStreamApprovalGate } from "./tool-approval.js";
+import { presentedApprovalFrameFamily, resolveStreamApprovalGate } from "./tool-approval.js";
 import { selfOrchestrationDenial } from "./task-workflow.js";
 import { centerEntitlementSourceWired } from "./runtime-caps-resolver.js";
 import { overwriteWipeIncapable } from "./session-sync.js";
@@ -196,7 +196,7 @@ export function streamApproval(d) {
         toolApprovalEnabled: d.toolApproval !== undefined,
         streamApprovalEnabled: d.config.streamApproval?.enabled === true,
         backend: d.backend,
-        parkFacility: d.checkpointStore !== undefined,
+        checkpointStore: d.checkpointStore,
     });
     if (gate.active)
         return yes({ askStore: gate.askStore });
@@ -220,14 +220,14 @@ export function readRootGrant(d) {
 }
 export function approvalFrameFamilies(stream) {
     if (stream.available)
-        return ["approval_request"];
+        return [presentedApprovalFrameFamily(true)];
     switch (stream.why) {
         case "tool_approval_disabled":
             return [];
         case "stream_approval_disabled":
         case "store_backend_absent":
         case "checkpoint_store_absent":
-            return ["tool_approval"];
+            return [presentedApprovalFrameFamily(false)];
         default: {
             const unhandled = stream.why;
             throw new Error(`unhandled stream-approval why: ${JSON.stringify(unhandled)}`);

package/dist/checkpoint-ctx-seal-m28.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 一次性迁移 M28 —— 升级之前写下的停驻行(`checkpoint_ctx`)里,请求面凭据位上的明文起服**原地封好**。
+ * 🔴 M28 · 窗口见 `plugins/one-time-migrations.ts` 的 ONE_TIME_MIGRATIONS 登记表(窗、删法、删后由谁接住只写在那一行)。
+ *
+ * ## 为什么要它(持久数据面)
+ * 7.134.0 起凭据位上的值在 ctx 里只以封签存在(规则属主 `http/checkpoint-ctx.ts` 末段「凭据位密封」),续跑上下文读口对凭据位上的明文答
+ * 409 `conflict.checkpoint_ctx_unsealable`(`reason:"plaintext"`)。升级前停驻的行是明文 —— 持久数据面不能「翻红」,所以起服扫一遍、用**同一只**封口
+ * (`sealStoredCheckpointCtxM28`,与写侧 `sealCheckpointCtx` 同一只走法)封好、原地回写;不删行、不动续跑时钟、已封的与不带凭据的行零写。
+ *
+ * ## 为什么不在 `one-time-migrations.ts` 的迁移段里
+ * 封要保管店派生的封签器,而那一段跑在店层(起服第 3 段,`openStores`),比建店的 web-admin 运行时能把封签器交下去的地方早、也不该反向依赖它;
+ * 本条在起服第 6 段 checkpoint 店建成、封签器的装配判(`CHECKPOINT_CTX_SEALING_REQUIRED`)过了之后调一次,早于任何路由装配(与 M10 / M19 / M25
+ * 同为在迁移段之外跑的条目)。读数一行 info `checkpoint_ctx_credentials_sealed`,不进 `OneTimeMigrationReport`(登记行 `reportKeys` 空)。
+ */
+import { type CheckpointCtxSealer, type SealedCheckpointCtx } from "./http/checkpoint-ctx.js";
+import { type OneTimeMigrationWindow } from "./plugins/one-time-migrations.js";
+import type { CtxRowsRewriteM28 } from "./plugins/checkpoint-store-sql.js";
+/** 两孪生的店腿(`SqlCheckpointStore` / `LocalCheckpointStore` 的 `rewriteCtxRowsM28`)。 */
+export interface CheckpointCtxRowsRewriterM28 {
+    rewriteCtxRowsM28(rewrite: (sessionId: string, ctx: object) => {
+        readonly ctx: SealedCheckpointCtx;
+        readonly values: number;
+    } | undefined): Promise<CtxRowsRewriteM28>;
+}
+/** M28 一次起服的读数(起服 info 行逐键打出;测试按它断言)。`window: "closed"` ⇒ 一行都没读(其余全 0)。 */
+export interface CheckpointCtxSealM28Report {
+    readonly window: "open" | "closed";
+    readonly rowsScanned: number;
+    readonly rowsSealed: number;
+    readonly valuesSealed: number;
+    readonly rowsUnreadable: number;
+    readonly rowsTooLarge: number;
+}
+/**
+ * 跑一次 M28(`today` = UTC 日历日 YYYY-MM-DD;`window` 缺省 = 登记表 M28 那一行 —— 只有测试递别的窗)。窗关 ⇒ 不扫。
+ * 店腿的每一行:`sealStoredCheckpointCtxM28` 交回新体(凭据位上的明文封好)⇒ 回写;交回 `undefined`(没有明文)⇒ 不写。
+ */
+export declare function sealCheckpointCtxCredentialsM28(store: CheckpointCtxRowsRewriterM28, sealer: CheckpointCtxSealer, opts: {
+    readonly today: string;
+    readonly window?: Pick<OneTimeMigrationWindow, "removableAfter">;
+}): Promise<CheckpointCtxSealM28Report>;
+//# sourceMappingURL=checkpoint-ctx-seal-m28.d.ts.map

package/dist/checkpoint-ctx-seal-m28.js

@@ -0,0 +1,19 @@
+import { sealStoredCheckpointCtxM28 } from "./http/checkpoint-ctx.js";
+import { ONE_TIME_MIGRATIONS, migrationWindowOpen } from "./plugins/one-time-migrations.js";
+function m28Window() {
+    const row = ONE_TIME_MIGRATIONS.find((w) => w.id === "M28");
+    if (row === undefined)
+        throw new Error("checkpoint-ctx-seal-m28: the one-time migration registry has no M28 row — this migration outlived its registry row; delete it with that row");
+    return row;
+}
+export async function sealCheckpointCtxCredentialsM28(store, sealer, opts) {
+    if (!migrationWindowOpen(opts.window ?? m28Window(), opts.today)) {
+        return { window: "closed", rowsScanned: 0, rowsSealed: 0, valuesSealed: 0, rowsUnreadable: 0, rowsTooLarge: 0 };
+    }
+    const r = await store.rewriteCtxRowsM28((sessionId, ctx) => {
+        const out = sealStoredCheckpointCtxM28(ctx, sealer, sessionId);
+        return out === undefined ? undefined : { ctx: out.ctx, values: out.valuesSealed };
+    });
+    return { window: "open", rowsScanned: r.scanned, rowsSealed: r.rewritten, valuesSealed: r.valuesRewritten, rowsUnreadable: r.unreadable, rowsTooLarge: r.tooLarge };
+}
+//# sourceMappingURL=checkpoint-ctx-seal-m28.js.map

package/dist/field-conflict.d.ts

@@ -1,5 +1,5 @@
 /** 冲突的类(闭集)。同一个约束的几个拒点同一个词;新增一类见文件头。 */
-export declare const FIELD_CONFLICT_KINDS: readonly ["cascade_verify", "image_profile", "resume_anchor", "system_prompt_fold", "file_history_restore", "skills_disabled", "existing_session", "scratchpad_root", "ask_answer", "policy_person_ask", "plan_edit", "plan_mode_after", "bound_call_door", "remember_decision"];
+export declare const FIELD_CONFLICT_KINDS: readonly ["cascade_verify", "image_profile", "resume_anchor", "system_prompt_fold", "file_history_restore", "skills_disabled", "existing_session", "scratchpad_root", "ask_answer", "policy_person_ask", "plan_edit", "plan_mode_after", "bound_call_door", "remember_decision", "approval_feedback"];
 /** 冲突的类(闭集词)。 */
 export type FieldConflictKind = (typeof FIELD_CONFLICT_KINDS)[number];
 /**
@@ -21,6 +21,7 @@ export interface FieldConflictCoordinates {
     readonly plan_mode_after: "decision" | "permissionModeAfter";
     readonly bound_call_door: "boundCallId";
     readonly remember_decision: "remember" | "decision";
+    readonly approval_feedback: "feedback" | "decision" | "decidedBy";
 }
 /** 折叠上限那一类另带的度量位:合起来的量与帽。 */
 export interface FieldConflictMeasure {

package/dist/field-conflict.js

@@ -13,6 +13,7 @@ export const FIELD_CONFLICT_KINDS = [
     "plan_mode_after",
     "bound_call_door",
     "remember_decision",
+    "approval_feedback",
 ];
 export function fieldConflictFacts(kind, fields, measure) {
     return { detail: { kind, fields: [...fields], ...(measure === undefined ? {} : { count: measure.count, cap: measure.cap }) } };

package/dist/file-history-disclosure.d.ts

@@ -1,3 +1,35 @@
+/**
+ * S-157④ —— SQL file-history 店的 **typed 永久失败**披露座:散文一个铸点 + 机器面一只 sink。
+ *
+ * ## 病(基线 v7.79.0 逐行亲核 + 亲跑)
+ * `plugins/blob-backend.ts:55` 的 `BlobTooLargeError` 带 typed 判别码 `blob_too_large_for_sql`,头注
+ * 原话「绝不能与 transient 写失败混在一类(那类是可重试的 502;这类重试永远不会成功)」。可它一旦被
+ * `plugins/file-history-store-sql.ts` 的任何一条 `catch` 折进 `FileHistoryResult.error.message`,判别码
+ * 就只剩散文,**机器一位都读不到**。两条腿各自的后果:
+ *
+ * · **snapshot(边界捕获)腿**:引擎把失败包成一句散文交给 `RunnerDeps.onError({phase:"rewind"})`
+ *   (core 7.20.0 `dist/core/runner/prepare-file-history.js` 的 `wrapFileHistoryEntry`),服务那条臂从文本里抠**第一个**
+ *   括号词当 metric label —— 而第一个括号词恒是引擎自己的闭集码。实测:「这个文件永远存不进这口店」
+ *   与「连接被重置」在 `rewind_snapshot_failed_total` 上**同形** `code="snapshot_failed"`。
+ * · **trackEdit(首触备份)腿**:本服务用引擎默认的 `onTrackFailure:"refuse"`(`boot/runner-deps.ts` 亲读),
+ *   那条路 **完全不走 onError** —— 引擎把 `(track_failed: <本店 message>)` 念给模型,末句是
+ *   「Retry when the file-history store is healthy.」(`prepare-file-history.js`)。对这枚码那是永远
+ *   不会到来的一天,而**运维面一个计数都没有**:这条腿今天在遥测上完全不可见。
+ *
+ * ## 修法(源头留痕,不走文本通道)
+ * · **散文面**({@link discloseCaughtFailure} 的返回值):把 caught error 的 typed `code` 写成一个括号词
+ *   前置到它自己的 message 前 —— **不 `instanceof` 单挑任何一个类**(身上有字符串 `code` 就折),该店
+ *   11 处折点全部改走这一只函数。人与模型因此看得到「这是哪一类失败」。
+ * · **机器面**(同一只函数的副作用):码取自 typed 错**对象**、对闭集词表判定,**绝不从散文里抠**。
+ *   🔴 这一条是 codex R1-[high] 验真后的定形:文本通道**天然可伪造** —— 一个名叫
+ *   `(blob_too_large_for_sql).txt` 的文件读不出来时,它的路径就在 `snapshot_failed` 的散文里,任何
+ *   「从散文里取在册括号词」的读法都会把它当成一枚永久码(继而抑制掉真故障的告警)。闭集只约束基数,
+ *   不能证明来源。所以机读判定搬回**唯一知道真相的那一层**=铸错的地方,`rewind` 臂的读法一字不动。
+ * · 留痕三件套与 `observability/fail-open.ts` / `observability/secret-env-scrub.ts` 同律:**计数逐次**
+ *   (`file_history_permanent_failure_total{code}`)、**每进程每码一条 warn**(第二条起零新增内容,而
+ *   20G 树的用户每 turn 撞一次)、装配前累计的次数在 install 时补进 metrics。
+ */
+import { FILE_HISTORY_ERROR_CODES } from "@sema-agent/core";
 import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";
 interface Sink {
@@ -18,11 +50,8 @@ export declare function installFileHistoryFailureRecorder(deps: Sink): void;
 export declare function fileHistoryPermanentFailureCounts(): ReadonlyMap<string, number>;
 /** 测试用重置(进程级状态在同一个 vitest worker 里跨用例存活)。 */
 export declare function resetFileHistoryFailureRecorderForTest(deps?: Sink): void;
-/** core `FileHistoryError.code` 闭集的值投影(两道差集钉在下面;`satisfies` 让它进 core 读表的 `literals` 段 ——
- *  core 退役其中一词时,提货前的求交门就能点名这张表)。 */
-declare const FILE_HISTORY_ERROR_CODE_WORDS: readonly ["track_failed", "snapshot_failed", "restore_failed", "adopt_failed", "not_found", "aborted", "unsupported_format", "conflict"];
-/** rewind 粗码臂的码词 = core 的闭集。 */
-export type FileHistoryErrorCode = (typeof FILE_HISTORY_ERROR_CODE_WORDS)[number];
+/** rewind 粗码臂的码词 = core 的闭集(值与型同一源:`FILE_HISTORY_ERROR_CODES`)。 */
+export type FileHistoryErrorCode = (typeof FILE_HISTORY_ERROR_CODES)[number];
 /** rewind 臂一次失败的粗码:文本里**第一个**在册的 `(码)` / `(码:`;没有 ⇒ `unknown`。纯函数、不抛。 */
 export declare function rewindFailureCode(err: unknown): FileHistoryErrorCode | "unknown";
 export {};

package/dist/file-history-disclosure.js

@@ -1,3 +1,4 @@
+import { FILE_HISTORY_ERROR_CODES } from "@sema-agent/core";
 const PERMANENT_STORE_FAILURE_CODES = {
     blob_too_large_for_sql: {
         note: "a blob is larger than this deployment's SQL snapshot-blob cap — the same file will fail every turn until the deployment changes",
@@ -86,8 +87,7 @@ export function resetFileHistoryFailureRecorderForTest(deps = {}) {
     sink = { ...deps };
     deps.metrics?.counter(PERMANENT_FAILURE_COUNTER, PERMANENT_FAILURE_HELP);
 }
-const FILE_HISTORY_ERROR_CODE_WORDS = ["track_failed", "snapshot_failed", "restore_failed", "adopt_failed", "not_found", "aborted", "unsupported_format", "conflict"];
-const FILE_HISTORY_ERROR_CODE_SET = new Set(FILE_HISTORY_ERROR_CODE_WORDS);
+const FILE_HISTORY_ERROR_CODE_SET = new Set(FILE_HISTORY_ERROR_CODES);
 const isFileHistoryErrorCode = (w) => FILE_HISTORY_ERROR_CODE_SET.has(w);
 export function rewindFailureCode(err) {
     const text = err instanceof Error ? err.message : String(err);

package/dist/fleet/fleet-bus.d.ts

@@ -190,6 +190,10 @@ export interface FleetWorkflowRow {
      *  `/v1/fleet/stream` `?session=` filter. NOT rendered. */
     sessionId?: string;
     status: string;
+    /** ADDITIVE / tolerate-absent:run 行上的机读终态码**原样过境**(`WorkflowRun.errorCode`,开集机器词,与 `GET /v1/workflows/:id` 的同名位同一套)。
+     *  停驻的 workflow run 终态 = `status:"failed"` + `errorCode:"workflow.agent_parked"`:`status` 词表不加字(不另铸专用 status 词),
+     *  「停驻」与「真失败」靠这一位分开。run 行没有码 ⇒ 键缺席(不铸空串);缺席也可能是老服务端,消费方同形处置:退回只读 `status`。 */
+    errorCode?: string;
     doneCount?: number;
     /** 计划总数(= `run.agents.length`,**含排队中**)—— 注意它**不是**"已启动数",见 {@link FleetWorkflowRow.startedCount}。 */
     totalCount?: number;

package/dist/fleet/fleet-bus.js

@@ -20,6 +20,7 @@ export function buildFleetWorkflowRow(id, run) {
         scope: run.scope,
         ...(run.originatingSessionId ? { sessionId: run.originatingSessionId } : {}),
         status: run.status,
+        ...(run.errorCode ? { errorCode: run.errorCode } : {}),
         doneCount: done,
         totalCount: agents.length,
         failedCount: failed,

package/dist/hooks/hook-runner.js

@@ -12,7 +12,7 @@ import { recordFailOpen } from "../observability/fail-open.js";
 import { LIMIT_REASONS } from "../limit-refusal.js";
 import { clipDataText, echoCallerText } from "../caller-text-echo.js";
 import { redactSecrets, buildDisplaySafeUrl } from "../trace/redact.js";
-import { canonicalJson } from "../canonical-json.js";
+import { canonicalJsonStringify } from "@sema-agent/core";
 import { ccPromptSystemFor, wrapCondition, parseCcVerdict, CC_EVALUATOR_MAX_OUTPUT_TOKENS } from "./cc-stop-prompt.js";
 import { ccAgentHookSystemFor } from "./cc-agent-hook-prompt.js";
 import { renderBranchTranscript } from "./branch-transcript.js";
@@ -1393,7 +1393,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                             }
                             if (decision === "allow" || decision === undefined) {
                                 const proposed = h.updatedInput !== null && typeof h.updatedInput === "object" ? h.updatedInput : undefined;
-                                const proposesRewrite = proposed !== undefined && canonicalJson(proposed) !== canonicalJson(groupInput);
+                                const proposesRewrite = proposed !== undefined && canonicalJsonStringify(proposed) !== canonicalJsonStringify(groupInput);
                                 if (ran.distrust !== undefined && hookPhaseOf(ran.source) === "unmanaged" && (decision === "allow" || proposesRewrite)) {
                                     noteVerdictUntrusted(ctx, { event: "PreToolUse", reason: ran.distrust, entry, source: ran.source, toolName });
                                 }

package/dist/http/admission.js

@@ -4,6 +4,7 @@ import { echoModelRef, modelUnavailableMessage } from "../model-entry-refusal.js
 import { HttpError, sessionIdShapeIssue } from "../security.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS, PERMISSION_MODE_WORDS, parseTaskSettings, settingsPermissionBucketIssue, skillListingBudgetFractionOk, skillListingMaxDescOk, stampEntryPermissionMode, taskHooksHonored, taskSettingsKeyIssue } from "../task-settings.js";
 import { tightenOnlySeatIssue } from "../tighten-only-seats.js";
+import { approvalFrameFamiliesIssue } from "../tool-approval.js";
 import { buildEntryModeClampNotice } from "../entry-mode-clamp-notice.js";
 import { autonomyModeFloor } from "../runtime-governance.js";
 import { taskBodyKeyIssue } from "../request-key-closure.js";
@@ -251,6 +252,13 @@ export function createAdmission(ctx) {
                     return null;
                 }
             }
+            {
+                const familiesIssue = approvalFrameFamiliesIssue(st);
+                if (familiesIssue) {
+                    sendError(res, 400, "request.field_invalid", familiesIssue.message, familiesIssue.fields);
+                    return null;
+                }
+            }
             const envRaw = st.env;
             if (envRaw !== undefined && envRaw !== null) {
                 if (typeof envRaw !== "object" || Array.isArray(envRaw)) {

package/dist/http/approval-sweeps.js

@@ -104,9 +104,11 @@ export function createApprovalSweeps(ctx) {
             }
         };
         const storedBodyUnservable = async (sessionId) => {
-            const read = await readResumeCtx(cs.getCtx(sessionId));
+            const read = await readResumeCtx(cs.getCtx(sessionId), { sessionId, opener: deps.checkpointCtxSealing });
             if (read.kind === "corrupt")
                 return undefined;
+            if (read.kind === "unsealable")
+                return undefined;
             if (read.kind === "absent")
                 return undefined;
             return storedBodyReplayRefusal(read.ctx, deps.config);

package/dist/http/checkpoint-ctx.d.ts

@@ -39,6 +39,10 @@
  * `resolveSpec` 本身留作真正的拒点(提交腿 400;续跑腿在到它之前已被本判据答掉)。再开第六个问点必须调这两只,不许各判各的 —— 此前铸卡前只判了
  * allow 记号,工具名清单那一问漏在外面,卡铸出来了、`/wake` 恒 409([ref] 合并复审两腿同报)。
  *
+ * ## 凭据位密封(7.134.0;常设规则,不是迁移)
+ * 体里请求面凭据位上的值在 ctx 里只以封签存在 —— 写:{@link buildCheckpointCtx} / {@link sealCheckpointCtx} 一只封口;读:续跑上下文读口里一只开口
+ * {@link openCheckpointCtx};开不开 ⇒ `409 conflict.checkpoint_ctx_unsealable`。规则全文在本文件末段「凭据位密封」的头注。
+ *
  * ## 何时删(一次性迁移,不是长期双读)
  * 本判据、拒臂、记号写点与 `CheckpointCtx.permissionsAllowReading` 一起删,删除条件与窗登记在 `plugins/one-time-migrations.ts` 的
  * 一次性迁移登记表(本条那一行):所有旧读法下停驻的行都已结束或被收割(停驻行的终局 = 落盘起 `TERMINAL_BACKSTOP_MS`,见
@@ -73,14 +77,16 @@ export declare function bodyCarriesAllowList(body: TaskRequestBody): boolean;
  * 调用方是「本进程刚按当前读法读过这份体」的写点:fresh 提交(受理门按当前读法读过 `allow`),或已经过了续跑拒臂的重放腿
  * (`startFreshHostTurn` 把宿主的存量体交给 `POST /v1/runs` 同一条链 —— 它在那之前调过 `resolveResumeSpecOrBlocked`,没记号却带 `allow` 的体到不了这里)。
  * 续跑腿的**写回**不经本函数:**不改词**的写回传读进来的 ctx(记号随行,不重新判 —— 在写回口重新判会把一条没记号的旧行「洗」成新行);
- * **改词**的写回(只有 `plan_review` 的批准 / 编辑)经 {@link withPermissionModeRewritten}。
+ * **改词**的写回(只有 `plan_review` 的批准 / 编辑)经 {@link withPermissionModeRewritten}。两种写回落盘之前都过同一只封口 {@link sealCheckpointCtx}。
+ *
+ * `sealer` / `sessionId`:凭据位密封的两件(本文件末段)—— `sessionId` 是这一行的会话(绑进封签);`sealer` 必传,缺席也要说出来(`undefined`)。
  */
 export declare function buildCheckpointCtx(fields: {
     body: TaskRequestBody;
     memoryScope?: string | undefined;
     unattendedLeg?: true;
     writerVersion: string;
-}): CheckpointCtx;
+}, sealer: CheckpointCtxSealer | undefined, sessionId: string): SealedCheckpointCtx;
 /**
  * 模式词的**第二个写者** —— `plan_review` 的批准 / 编辑把这条 run 的体词从 `plan` 写成批准的档(`resume-legs.ts` `drivePlanReview`,调用点只有那一处;
  * `test/allow-list-reading-park-refusal.test.ts` 枚举调用点,多一处即红)。与 {@link buildCheckpointCtx} **同一条规则**:按当前读法写下的词,盖当前读法记号。
@@ -208,4 +214,153 @@ export declare function storedBodyReplayLogFields(refusal: StoredBodyReplayRefus
  * 没有默认值:每个调用点必须说出这件事实。
  */
 export declare function storedBodyReplayAnswer(refusal: StoredBodyReplayRefusal, readerVersion: string, cardPending: boolean): ResumeRefusalAnswer;
+/**
+ * 🔴 **停驻行里请求面凭据的落盘形 —— 一条规则**:提交体里**凭据位**({@link CHECKPOINT_CTX_CREDENTIAL_SLOTS},闭集)上的每一个值,在 `checkpoint_ctx`
+ * (local 店的 `<数据根>/checkpoint-ctx/<会话>.json` / SQL 店的 `checkpoint_ctx.ctx` 列)里只以**封签**({@link SealedCheckpointValue})存在。
+ *  · **写**:一只封口 {@link sealCheckpointCtx}。新的持久化写经 {@link buildCheckpointCtx}(它的唯一产物形就是封好的 {@link StoredCheckpointCtx}),
+ *    续跑腿的写回(`resume-legs.ts` 的 `commitResumeCtx`:读进来的 ctx 在内存里是开封形)经它本身;一次性迁移 M28 对存量行用同一只走法
+ *    ({@link sealStoredCheckpointCtxM28})。凭据位上的**每一个值都封,不分类型**(串、数字、`null`、对象 —— 包括调用方自己送来的封签形对象):
+ *    封签里装的是那个 JSON 值本身,开封逐字还原。字典位上的容器本身不是字典(串 / 数组 / `null` / 封签形对象)⇒ 整只容器当一个值封。
+ *    于是落盘形里凭据位上**只有本封口铸的封签**,没有哪个值能「原样存下、续跑时被开成别的东西」(调用方送一只封签形对象 ⇒ 存的是再封一层,
+ *    开出来还是那只对象 —— 与新提交腿看到的同一个值)。没有封签器而有值要封 ⇒ 抛 {@link CheckpointCtxUnsealableError}(`no_key_store`,调用方在写之前拒)。
+ *  · **读法记号**(与本文件另两只记号同一条「写的人盖章」):封口铸出的每一份落盘形都带 `credentialSeal: CHECKPOINT_CTX_SEAL_ALG` —— 这一行的凭据位
+ *    **全部**由本封口封过。没有记号的行是 7.134.0 之前的写者写下的:那时没有任何写者封值,所以它凭据位上的封签形对象只可能是调用方原样送来的,不是封签。
+ *    记号只在落盘形上(开口交出的开封形里没有它;写回再封时重新盖)。
+ *  · **读**:一只开口 {@link openCheckpointCtx},唯一调用方 = 续跑上下文唯一读口 `resume-ctx-read.ts` 的 `readResumeCtx`(读出的 ctx 在任何消费者
+ *    看到之前已开封)。行带当前记号:凭据位上封签 ⇒ 开(开不开 ⇒ 拒);带 `sealed` 键却不是本闭集的封签形(含将来的 `alg`)⇒ 拒 `unrecognized_seal`;
+ *    其余任何值 ⇒ 拒 `plaintext`。行没有记号 ⇒ 凭据位上**任何**值(含封签形对象)⇒ 拒 `plaintext`(更早版本写下、M28 还没扫到);记号认不得(将来的格式)⇒
+ *    凭据位上任何值 ⇒ 拒 `unrecognized_seal`。凭据位上没有值的行不论记号照常开。
+ *    **拒** = 读口第四态 `unsealable`(`field` = 哪一个凭据位,`reason` ∈ {@link CHECKPOINT_CTX_UNSEALABLE_REASONS}),各续跑入口答
+ *    `409 conflict.checkpoint_ctx_unsealable`(`resume-ctx-read.ts` 的 `resumeCtxUnsealableAnswer`)。**没有**明文回落臂、**没有**静默丢键臂。
+ *  · **装配**:`checkpointStore` 在场而封签器缺席 ⇒ 拒启({@link CHECKPOINT_CTX_SEALING_REQUIRED};`createHttpServer` 与起服第 6 段同一句)。
+ *
+ * **一个域一对钥匙**:停驻行封签用这一域自己的保管店(`<数据根>/sealed-key/checkpoint-ctx-keys/`,生产工厂 `sealed-key.ts` `ensureCheckpointCtxSealing`),
+ * 与模型钥匙(`ModelEntry.sealedApiKey`)的那对钥匙不共用 —— 模型钥匙的密文放进凭据位、停驻行的封签放进 `sealedApiKey`,两边都是「不持有那把钥匙」;
+ * 封签再把**会话 id 绑进密文**(信封 = `[alg, sessionId, value]`):别的会话那一行的封签搬过来开不开 —— 读口不是这台副本任何一把钥匙的解密预言机。
+ *
+ * 本模块的零值依赖纪律照旧:封签器 / 开封器是调用方递进来的接口(实现在 `sealed-key.ts`,它依赖 libsodium,不进本模块的闭包)。
+ */
+export declare const CHECKPOINT_CTX_SEAL_ALG = "checkpoint-ctx-sealedbox-v1";
+/** 停驻行里一只凭据值的**封签**(闭集形:恰这三键、三值皆串、`alg` 只有 {@link CHECKPOINT_CTX_SEAL_ALG} 一个词)。与明文不可混淆:明文是串,封签是对象。 */
+export interface SealedCheckpointValue {
+    readonly alg: typeof CHECKPOINT_CTX_SEAL_ALG;
+    /** 封它的那把公钥的 id(开封按它**精确**选私钥,不逐把试)。 */
+    readonly publicKeyId: string;
+    /** `crypto_box_seal` 密文的标准 base64。 */
+    readonly sealed: string;
+}
+/** 封口(只会封):把凭据位上的一个 JSON 值(任何类型)封进 `sessionId` 那一行。抛 = 封不了(调用方当写失败处置)。 */
+export interface CheckpointCtxSealer {
+    seal(value: unknown, sessionId: string): SealedCheckpointValue;
+}
+/** 开口:`holds` = 这台副本有没有 `publicKeyId` 那把私钥;`open` 抛 = 开不开(密文坏 / 不是 `sessionId` 那一行封的 / 不是停驻行信封);返回封进去的那个 JSON 值。
+ *  🔴 `open` 的返回值是活凭据:只进内存,不进日志、不落盘(再落盘必经 {@link sealCheckpointCtx})。 */
+export interface CheckpointCtxOpener {
+    holds(publicKeyId: string): boolean;
+    open(sealed: SealedCheckpointValue, sessionId: string): unknown;
+}
+/** 封签器 = 封口 + 开口(生产工厂 `sealed-key.ts` `ensureCheckpointCtxSealing`;`ServiceDeps.checkpointCtxSealing` 的型)。 */
+export interface CheckpointCtxSealing extends CheckpointCtxSealer, CheckpointCtxOpener {
+}
+/**
+ * **凭据位闭集**(提交体里值为凭据的位置)。路径段 `*` = 那一格容器的**每一个成员**:数组的每一项、字典的每一个值(一只走法,不分容器种类 —— 字典成员的点名形
+ * `field` 是 `.<键>`,数组是 `[<下标>]`)。`map` = 那一格是串值字典,**每一个值**都是凭据(不分哪一键);`value` = 那一格本身是凭据。
+ * 入表判据(一条):请求面上**为承载凭据而设**的字段 —— 静态请求头(MCP http 传输、A2A 对端〔引擎型注:「e.g. an auth bearer」〕、http hook 条目)、
+ * 交给子进程的 env(MCP stdio 传输、任务 shell 的 `settings.env`)、请求自带的搜索后端钥匙。http hook 的头与另两种静态头同判:契约包的条目形是
+ * `headers: Record<string, string>`、受理面(`parseHooksConfig`)只判条数与字数、`interpolateHookEnvVars` 只换 `$NAME` 引用而字面值原样上 wire ——
+ * 头值可以就是字面的 `Authorization: Bearer …`。hooks 的形 = 事件名 → 匹配组数组 → 组的 `hooks` 数组 → 条目;只有 `type:"http"` 的条目有 `headers`,
+ * 别的条目在那一段缺席、走法照常不往下走。**不入表**:命令行 / URL / 工具实参之类自由文本(不是凭据字段;它们里有没有秘密不是本层能判的)。
+ * 加一位 = 加一行,读写两侧与一次性迁移 M28 共用 {@link mapCredentialSlots} 一只走法,自动覆盖。
+ */
+export declare const CHECKPOINT_CTX_CREDENTIAL_SLOTS: readonly [{
+    readonly path: readonly ["mcpServers", "*", "transport", "headers"];
+    readonly holds: "map";
+}, {
+    readonly path: readonly ["mcpServers", "*", "transport", "env"];
+    readonly holds: "map";
+}, {
+    readonly path: readonly ["a2aPeers", "*", "headers"];
+    readonly holds: "map";
+}, {
+    readonly path: readonly ["settings", "env"];
+    readonly holds: "map";
+}, {
+    readonly path: readonly ["settings", "webSearch", "apiKey"];
+    readonly holds: "value";
+}, {
+    readonly path: readonly ["settings", "hooks", "*", "*", "hooks", "*", "headers"];
+    readonly holds: "map";
+}];
+/** 开不开 / 封不了的成因(闭集):`no_key_store` = 这台副本没有封签器(没有保管店);`key_not_held` = 封它的那把钥匙不在这台副本的保管店里
+ *  (多副本不共享 `<数据根>/sealed-key/`,或保管目录被换过);`unopenable` = 钥匙在、开不开(密文坏 / 不是这一行封的 / 不是停驻行信封);
+ *  `plaintext` = 凭据位上是明文(更早版本的写者);`unrecognized_seal` = 带 `sealed` 键却不是本闭集的封签形(含将来的 `alg`)。 */
+export declare const CHECKPOINT_CTX_UNSEALABLE_REASONS: readonly ["no_key_store", "key_not_held", "unopenable", "plaintext", "unrecognized_seal"];
+export type CheckpointCtxUnsealableReason = (typeof CHECKPOINT_CTX_UNSEALABLE_REASONS)[number];
+/** 封不了 / 开不开的那一格:`field` = 凭据位在提交体里的路径(如 `mcpServers[0].transport.headers.Authorization`、
+ *  `settings.hooks.PreToolUse[0].hooks[0].headers.Authorization`;键名不是秘密,值从不进来)。 */
+export declare class CheckpointCtxUnsealableError extends Error {
+    readonly field: string;
+    readonly reason: CheckpointCtxUnsealableReason;
+    constructor(field: string, reason: CheckpointCtxUnsealableReason);
+}
+/**
+ * 停驻行的**落盘形**:凭据位上是封签,不是 {@link TaskRequestBody} 型面说的串 —— 所以体在型面上只是「一只对象」,读它的唯一合法方式是 {@link openCheckpointCtx}
+ * (经续跑上下文读口)。产物只有两只铸点:{@link buildCheckpointCtx} 与 {@link sealCheckpointCtx}。
+ */
+export type StoredCheckpointCtx = Omit<CheckpointCtx, "body"> & {
+    readonly body: {
+        readonly [key: string]: unknown;
+    };
+    readonly credentialSeal?: typeof CHECKPOINT_CTX_SEAL_ALG;
+};
+declare const sealedCheckpointCtxBrand: unique symbol;
+/**
+ * **封口铸出的**落盘形(品牌型):店的写口(`putCtx`)与一次性迁移 M28 的行改写只收它 ⇒ 「写 ctx 只有封口一个写入面」由型面守,
+ * 不再靠逐个数调用点(把开封形 / 裸对象直接交给写口 = 当场 tsc 红)。铸点闭集(都在本模块,都经 {@link mintSealedCheckpointCtx}):
+ * {@link sealCheckpointCtx}(新的持久化写经 {@link buildCheckpointCtx} 到它;续跑腿的写回)与 {@link sealStoredCheckpointCtxM28}。零运行期变化。
+ */
+export type SealedCheckpointCtx = StoredCheckpointCtx & {
+    readonly [sealedCheckpointCtxBrand]: true;
+};
+/** 装配期拒启的那一句(`createHttpServer` 与起服第 6 段同调;一句、一个出口)。 */
+export declare const CHECKPOINT_CTX_SEALING_REQUIRED = "a durable checkpoint store is wired but checkpointCtxSealing is not: suspended tasks keep the request's credentials (MCP / A2A headers and env values, settings.env, settings.webSearch.apiKey, http hook headers) in their resume context, and they are stored sealed or not at all \u2014 give the service a sealed-key store for them (this service builds it under <data root>/sealed-key/checkpoint-ctx-keys/ at boot; a failure there is the earlier checkpoint_ctx_sealing_unavailable warning \u2014 make that directory creatable and chmod-able by the service, or repair or remove a key file there whose public and private halves do not belong together), or, when embedding, pass checkpointCtxSealing: await ensureCheckpointCtxSealing(sealedKeyDir); refusing to start rather than write credentials in plaintext";
+/** 封签形的判官(恰三键、三值皆串、`alg` 是本闭集那一个词)。 */
+export declare function isSealedCheckpointValue(v: unknown): v is SealedCheckpointValue;
+/**
+ * **封口**(写的一侧唯一的一只):内存里的开封形 ctx ⇒ 落盘形。`sealer` 必传(缺席也要说出来:`undefined` = 这台副本没有保管店 ⇒ 体里有凭据就抛
+ * {@link CheckpointCtxUnsealableError} `no_key_store`,调用方在写之前拒;体里没有凭据 ⇒ 没有要封的东西,照常)。`sessionId` = 这一行的会话(绑进封签)。
+ * 调用方:{@link buildCheckpointCtx}(新的持久化写)与续跑腿的写回(`resume-legs.ts` `commitResumeCtx`)。
+ */
+export declare function sealCheckpointCtx(ctx: CheckpointCtx, sealer: CheckpointCtxSealer | undefined, sessionId: string): SealedCheckpointCtx;
+/** {@link openCheckpointCtx} 的结局:开封形 ctx,或第一处开不开的凭据位。 */
+export type OpenedCheckpointCtx = {
+    readonly kind: "ok";
+    readonly ctx: CheckpointCtx;
+} | {
+    readonly kind: "unsealable";
+    readonly field: string;
+    readonly reason: CheckpointCtxUnsealableReason;
+};
+/**
+ * **开口**(读的一侧唯一的一只;唯一调用方 = 续跑上下文读口 `readResumeCtx`):落盘形 ⇒ 开封形。`opener` 缺席 = 这台副本没有保管店(体里有封签就
+ * `no_key_store`;没有凭据的行照常开)。判词见本段头注。
+ */
+export declare function openCheckpointCtx(stored: StoredCheckpointCtx, opener: CheckpointCtxOpener | undefined, sessionId: string): OpenedCheckpointCtx;
+/**
+ * 一份落盘 ctx(持久化 JSON,不信型面)的凭据位上**第一只封签**的点名(`field`,形同拒句里的那一位;键名不是秘密,值从不出来)—— 没有 ⇒ `undefined`。
+ * 走法 = 封口 / 开口 / M28 共用的那一只 {@link mapCredentialSlots},判形 = {@link isSealedCheckpointValue};不开封、不看记号(只问「凭据位上有没有封签」)。
+ * 唯一读者:随包排空检查脚本的 `sealed-credentials-rollback` 判据(经编译产物取):7.133.x 读不懂封签、续跑时把这些凭据位当没有 ⇒ 回滚之前先把这样的停驻行决掉或取消。
+ */
+export declare function sealedCredentialFieldOf(stored: unknown): string | undefined;
+/**
+ * 🔴 **一次性迁移 M28 的行改写**(窗与删法见 `plugins/one-time-migrations.ts` 登记表 M28;编排 = `checkpoint-ctx-seal-m28.ts`):一行存量 ctx
+ * (持久化 JSON,不信型面)**没有读法记号**(= 7.134.0 之前的写者写下的)⇒ 凭据位上的**每一个值**(含调用方原样送来的封签形对象)用同一只封口封好、盖记号 ——
+ * 与写侧 {@link sealCheckpointCtx} 同一条规则。带记号的行(本版写下的,或本条已改写过的)、记号认不得的行 ⇒ `undefined`(不写:第二跑零命中;认不得的留给读口拒);
+ * 凭据位上没有值 ⇒ `undefined`(不写);体不是对象 ⇒ `undefined`(读口自己的形判接住)。其余位(另两只记号、写者版本、非凭据字段)原样。
+ */
+export declare function sealStoredCheckpointCtxM28(stored: object, sealer: CheckpointCtxSealer, sessionId: string): {
+    readonly ctx: SealedCheckpointCtx;
+    readonly valuesSealed: number;
+} | undefined;
+export {};
 //# sourceMappingURL=checkpoint-ctx.d.ts.map