@sema-agent/server 7.103.2 → 7.104.0

package/dist/plugins/run-store-sql.js

@@ -1,4 +1,4 @@
-import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal.js";
+import { redactErrorMessage, redactLedgerEventData, sealRunRowResult } from "../observability/run-terminal.js";
 import { outwardPlane } from "../terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { escapeLike } from "./sql-escape.js";
@@ -149,7 +149,7 @@ export class SqlRunStore {
         return m == null ? 0 : Number(m);
     }
     async setTerminal(taskId, status, result, error) {
-        result = redactTerminalResult(result);
+        result = sealRunRowResult(result);
         error = error === null ? null : (redactErrorMessage(error) ?? null);
         const errorCode = result === null ? null : (outwardPlane(result.terminal).errorCode ?? null);
         let won = false;
@@ -189,14 +189,16 @@ export class SqlRunStore {
             });
         }
     }
-    async setSuspended(taskId) {
-        await this.db.query(this.q("UPDATE task_run SET status = 'suspended', updated_at = ? WHERE task_id = ? AND status IN ('running','suspended')", "UPDATE task_run SET status = 'suspended', updated_at = $1 WHERE task_id = $2 AND status IN ('running','suspended')"), [new Date(), taskId]);
+    async setSuspended(taskId, result) {
+        const sealed = sealRunRowResult(result);
+        await this.db.query(this.q("UPDATE task_run SET status = 'suspended', result = ?, updated_at = ? WHERE task_id = ? AND status IN ('running','suspended')", "UPDATE task_run SET status = 'suspended', result = $1::jsonb, updated_at = $2 WHERE task_id = $3 AND status IN ('running','suspended')"), [sealed == null ? null : this.json(sealed), new Date(), taskId]);
     }
-    async setNeedsReview(taskId) {
-        await this.db.query(this.q("UPDATE task_run SET status = 'needs_review', updated_at = ? WHERE task_id = ? AND status IN ('running','needs_review')", "UPDATE task_run SET status = 'needs_review', updated_at = $1 WHERE task_id = $2 AND status IN ('running','needs_review')"), [new Date(), taskId]);
+    async setNeedsReview(taskId, result) {
+        const sealed = sealRunRowResult(result);
+        await this.db.query(this.q("UPDATE task_run SET status = 'needs_review', result = ?, updated_at = ? WHERE task_id = ? AND status IN ('running','needs_review')", "UPDATE task_run SET status = 'needs_review', result = $1::jsonb, updated_at = $2 WHERE task_id = $3 AND status IN ('running','needs_review')"), [sealed == null ? null : this.json(sealed), new Date(), taskId]);
     }
     async markResuming(taskId, instanceId) {
-        const { affected } = await this.db.query(this.q("UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, instance_id = ?, updated_at = ? WHERE task_id = ? AND status IN ('suspended','needs_review')", "UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, instance_id = $1, updated_at = $2 WHERE task_id = $3 AND status IN ('suspended','needs_review')"), [instanceId, new Date(), taskId]);
+        const { affected } = await this.db.query(this.q("UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, result = NULL, instance_id = ?, updated_at = ? WHERE task_id = ? AND status IN ('suspended','needs_review')", "UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, result = NULL, instance_id = $1, updated_at = $2 WHERE task_id = $3 AND status IN ('suspended','needs_review')"), [instanceId, new Date(), taskId]);
         return affected === 1;
     }
     async getActiveTaskId(sessionId) {
@@ -421,8 +423,8 @@ export class SqlRunStore {
         const cutoff = new Date(Date.now() - olderThanMs);
         let reaped = 0;
         await this.tx(async (conn) => {
-            const { affected } = await conn.query(this.q("UPDATE task_run SET status = 'failed', error = 'run stalled (instance lost?)', updated_at = ? " +
-                "WHERE status = 'running' AND updated_at < ?", "UPDATE task_run SET status = 'failed', error = 'run stalled (instance lost?)', updated_at = $1 " +
+            const { affected } = await conn.query(this.q("UPDATE task_run SET status = 'failed', result = NULL, error = 'run stalled (instance lost?)', updated_at = ? " +
+                "WHERE status = 'running' AND updated_at < ?", "UPDATE task_run SET status = 'failed', result = NULL, error = 'run stalled (instance lost?)', updated_at = $1 " +
                 "WHERE status = 'running' AND updated_at < $2"), [new Date(), cutoff]);
             reaped = affected;
             await conn.query(this.q("DELETE ta FROM task_active ta JOIN task_run tr ON ta.task_id = tr.task_id WHERE tr.status NOT IN ('running','suspended','needs_review')", "DELETE FROM task_active ta USING task_run tr WHERE ta.task_id = tr.task_id AND tr.status NOT IN ('running','suspended','needs_review')"));
@@ -434,9 +436,9 @@ export class SqlRunStore {
         const cutoff = new Date(Date.now() - olderThanMs);
         let reaped = 0;
         await this.tx(async (conn) => {
-            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
+            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.result = NULL, tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
                 "WHERE tr.status = 'suspended' AND tr.updated_at < ? " +
-                "AND NOT EXISTS (SELECT 1 FROM checkpoint c WHERE c.session_id = tr.session_id AND c.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
+                "AND NOT EXISTS (SELECT 1 FROM checkpoint c WHERE c.session_id = tr.session_id AND c.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', result = NULL, error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
                 "WHERE tr.status = 'suspended' AND tr.updated_at < $2 " +
                 "AND NOT EXISTS (SELECT 1 FROM checkpoint c WHERE c.session_id = tr.session_id AND c.status = 'pending')"), [new Date(), cutoff]);
             reaped = affected;
@@ -447,10 +449,10 @@ export class SqlRunStore {
     async failSuspendedWithExpiredCheckpoint() {
         let reaped = 0;
         await this.tx(async (conn) => {
-            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
+            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.result = NULL, tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
                 "WHERE tr.status IN ('suspended','needs_review') " +
                 "AND EXISTS (SELECT 1 FROM checkpoint ce WHERE ce.session_id = tr.session_id AND ce.status = 'expired') " +
-                "AND NOT EXISTS (SELECT 1 FROM checkpoint cp WHERE cp.session_id = tr.session_id AND cp.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
+                "AND NOT EXISTS (SELECT 1 FROM checkpoint cp WHERE cp.session_id = tr.session_id AND cp.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', result = NULL, error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
                 "WHERE tr.status IN ('suspended','needs_review') " +
                 "AND EXISTS (SELECT 1 FROM checkpoint ce WHERE ce.session_id = tr.session_id AND ce.status = 'expired') " +
                 "AND NOT EXISTS (SELECT 1 FROM checkpoint cp WHERE cp.session_id = tr.session_id AND cp.status = 'pending')"), [new Date()]);

package/dist/plugins/send-file-ledger.d.ts

@@ -1,6 +1,7 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import type { IssuedFileLink } from "./send-user-file.js";
+import type { Logger } from "../observability/logger.js";
 /** Ledger scope sentinel for single-user issuance (no principal) — mirrors scopeSegment's "_" key segment. */
 export declare const SENDFILE_SINGLE_USER_SCOPE = "_";
 export interface SendFileLedgerEntry {
@@ -47,7 +48,10 @@ export declare class FileSendFileLedger implements SendFileLedger {
     private readonly path;
     private readonly mem;
     private log;
-    constructor(root: string);
+    /** @param opts.warn corrupt-read disclosure seat (S-582; absent ⇒ the replay owner falls back to `console.warn`). */
+    constructor(root: string, opts?: {
+        warn?: Logger["warn"];
+    });
     record(entry: SendFileLedgerEntry): Promise<void>;
     listByScope(scope: string, limit: number, beforeId?: string): Promise<SendFileLedgerEntry[]>;
     /** Release the append-log fd (LocalBackend.close → graceful-restart re-open). */

package/dist/plugins/send-file-ledger.js

@@ -1,5 +1,6 @@
 import { join } from "node:path";
-import { AppendLog, ensureDir, readJsonlRecords, uuidv7 } from "@sema-agent/core";
+import { AppendLog, ensureDir, uuidv7 } from "@sema-agent/core";
+import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
 export const SENDFILE_SINGLE_USER_SCOPE = "_";
 export class TiDBSendFileLedger {
     pool;
@@ -68,19 +69,23 @@ export class MemorySendFileLedger {
             .map((e) => ({ ...e }));
     }
 }
+const LEDGER_ROW_SHAPE = {
+    what: "send-file ledger row without a string id / scope / objectKey",
+    read(record) {
+        const r = record;
+        return typeof r.id === "string" && typeof r.scope === "string" && typeof r.objectKey === "string" ? record : undefined;
+    },
+};
 export class FileSendFileLedger {
     path;
     mem = new MemorySendFileLedger();
     log;
-    constructor(root) {
+    constructor(root, opts) {
         const dir = join(root, "sendfile-ledger");
         ensureDir(dir);
         this.path = join(dir, "links.jsonl");
-        for (const r of readJsonlRecords(this.path)) {
-            if (!r || typeof r.id !== "string" || typeof r.scope !== "string" || typeof r.objectKey !== "string")
-                continue;
+        for (const r of replayJsonlSkipping(this.path, "send-file-ledger", LEDGER_ROW_SHAPE, opts?.warn).records)
             void this.mem.record(r);
-        }
     }
     async record(entry) {
         this.log ??= new AppendLog(this.path);

package/dist/plugins/session-event-payload.d.ts

@@ -14,10 +14,20 @@
  * 会话事件日志是 **wake 的全部依据**:一行读不出形的 payload 被当成 `null` / 空对象端出去 ⇒ 这只会话的
  * 上下文树里多一个没有 `id`、没有 `type` 的节点,`leafIdAfterEntry` 与 `buildContext` 在它上面的行为未定;
  * 静默跳过它则是**一段对话从历史里消失**(而模型会照着一棵少了一截的树继续说话)。两者都比一次响亮的
- * wake 失败坏。本店没有枚举式 corrupt 码(`SessionError` 的词表 —— `conflict` 等 —— 是并发契约词,
- * 不是读侧 corrupt 词)⇒ 折成响亮裸 `Error`,点名 `<表>.<列>` + 行标识(S-550 车①② 裁定,沿用)。
+ * wake 失败坏。
+ *
+ * ## 拒的**词** = core 的 `SessionError("corrupt_session")`(S-612,server 7.104.0)
+ * 写这段代码时 core 的 `SessionError` 闭集里还没有读侧的 corrupt 词(那时这里折成 `StoreCorruptError` / 更早是裸
+ * `Error`,点名 `<表>.<列>` + 行标识 —— S-550 车①② 裁定)。core 7.30.0(#1041)给文件会话店铸了
+ * `corrupt_session`(「这只会话的存储读不出,无法唤醒」),于是同一件事在三种会话后端上说了两种话:文件后端上 wire
+ * 是 500 `corrupt_session`,SQL 后端上是一只未分类的失败。⇒ 改抛**同一个词**;句子只留坐标(`<表>.<列>` + 会话 +
+ * 行号 + 坏体种别),不带这一行的内容、不含任何盘上路径(codex r1 [high]:修前的句子带着坏体的前 64 个字符)。失败方向不变:仍然**拒**,不跳过(SQL 行没有「撕裂」这种自然形,坏行 = 被篡改或迁移
+ * 事故;文件店「跳过坏记录、其余照回放」的那一半在这里不成立,契约附录里如实写两种后端的差别)。
+ * 映射到 wire 的唯一属主是 `src/session-error-wire.ts`。
+ * 🔴 `not-text`(读腿没按文本投影 = 本仓的码漂)**不折**:原样上抛 —— 判别与 `foldJsonColumn` 的是同一只谓词
+ * `isJsonColumnBodyProblem`,不另写一份。
  */
-import type { SessionTreeEntry } from "@sema-agent/core";
+import { type SessionTreeEntry } from "@sema-agent/core";
 import { type JsonColumnReader } from "./sql-json-column.js";
 /**
  * 形读者:core 自己声明的 `SessionTreeEntryBase` 里那两把**不可省**的串键。
@@ -32,6 +42,6 @@ import { type JsonColumnReader } from "./sql-json-column.js";
  * core 也没有导出 `SessionTreeEntry` 的验证器 —— `validateEntriesForImport` 吃的是已经成形的对象)。
  */
 export declare const readSessionEventPayload: JsonColumnReader<SessionTreeEntry>;
-/** 一格 `session_event.payload`(已按文本投影)→ 一条事件。坏体 ⇒ 响亮拒(见文件头注)。 */
+/** 一格 `session_event.payload`(已按文本投影)→ 一条事件。坏体 ⇒ 响亮拒 `SessionError("corrupt_session")`(见文件头注)。 */
 export declare function decodeSessionEventPayload(cell: unknown, sessionId: string, rowId: unknown): SessionTreeEntry;
 //# sourceMappingURL=session-event-payload.d.ts.map

package/dist/plugins/session-event-payload.js

@@ -1,4 +1,5 @@
-import { decodeJsonColumn, foldJsonColumn } from "./sql-json-column.js";
+import { SessionError } from "@sema-agent/core";
+import { decodeJsonColumn, isJsonColumnBodyProblem } from "./sql-json-column.js";
 export const readSessionEventPayload = (body) => {
     if (typeof body !== "object" || body === null || Array.isArray(body))
         return { problem: "expected a JSON object (a SessionTreeEntry)" };
@@ -14,7 +15,9 @@ export function decodeSessionEventPayload(cell, sessionId, rowId) {
         return decodeJsonColumn(cell, readSessionEventPayload, `session_event.payload for session ${sessionId} row ${String(rowId)}`);
     }
     catch (e) {
-        throw foldJsonColumn(e, (m) => `session storage: ${m} — refusing rather than wake a session from a tree with a node nobody can read`);
+        if (!isJsonColumnBodyProblem(e))
+            throw e;
+        throw new SessionError("corrupt_session", `session storage: ${e.where} is not a readable session entry (${e.problem}) — refusing rather than wake a session from a tree with a node nobody can read`, e);
     }
 }
 //# sourceMappingURL=session-event-payload.js.map

package/dist/plugins/store-backend.d.ts

@@ -233,9 +233,13 @@ export interface StoreBackend {
      *  epoch is gone (its manifest index table retired with it), so EVERY row in that domain is an orphan and its
      *  BYTES (incl. MinIO objects) would otherwise outlive the epoch forever. SQL backends only; reaper-driven. */
     legacySnapshotBlobSweep?(): Promise<number>;
-    /** 🔴 **一次性迁移(随 7.75.0 连同 `one-time-migrations.ts` 一起从接口上删)** —— 本版三处退役落在
-     *  已写进库里的字节上,升一次级改完、兼容臂当场删干净(硬 breaking 纪律:持久数据面 = 响亮拒 +
-     *  一次性迁移,窗过即删,永不长期双读)。逐条语义、幂等与拒启臂见该模块头注。
+    /** 🔴 **一次性迁移** —— 落在已写进库里的字节上的退役,升一次级改完、兼容臂当场删干净(硬 breaking 纪律:持久数据面 =
+     *  响亮拒 + 一次性迁移,窗过即删,永不长期双读)。逐条语义、幂等与拒启臂见该模块头注。
+     *
+     *  **本成员什么时候删**(嵌入方按这里排期):每条迁移各有窗 —— 引入它的版本发布日 + 30 天,窗关之后的第一个 minor 删那一条
+     *  的码;逐条的日期只登记在 `plugins/one-time-migrations.ts` 的 `ONE_TIME_MIGRATIONS`(随包在
+     *  `dist/plugins/one-time-migrations.d.ts`),起动日志行 `one_time_migrations_applied` 的 `removableAfter` 读数同源。
+     *  **最后一条**删码时本成员随之从接口上删(硬 breaking:自建 `StoreBackend` 的实现方 tsc 红即通知)。
      *
      *  **必选,不是 optional**:漏实装一支后端 = 那条车道的存量字节永远停在旧读法上,而读腿已经只认新的
      *  ⇒ 必须是编译期错误,不是运行期的一次静默跳过。 */

package/dist/plugins/store-backend.js

@@ -13,6 +13,7 @@ import { buildStoreOpenRefusalTail } from "./store-open-refusal.js";
 import { acquireLocalBackendWithWait } from "./store-lock-wait.js";
 import { NO_SQL_MIGRATIONS, runSqlOneTimeMigrations } from "./one-time-migrations.js";
 import { LocalSessionStore } from "./local-session-store.js";
+import { noteReplayInSessionOpenScope } from "../session-records-skipped-notice.js";
 import { LocalCheckpointStore } from "./local-checkpoint-store.js";
 import { FileResumeAnchorStore } from "./file-resume-anchor-store.js";
 import { TiDBApprovalExemptionStore, PgApprovalExemptionStore, FileApprovalExemptionStore } from "./approval-exemption-store.js";
@@ -234,17 +235,19 @@ class LocalBackend {
                 (tail === undefined ? "" : ` ${tail}`));
         }
         this.sessionStore = new LocalSessionStore(new FileSessionRepo(this.fileBackend.root, {
-            onCorruptRead: createCorruptReadSeat((msg, fields) => this.discloseWarn(msg, fields), "session_repo_corrupt_read"),
+            onCorruptRead: createCorruptReadSeat((msg, fields) => this.discloseWarn(msg, fields), "session_repo_corrupt_read", undefined, noteReplayInSessionOpenScope),
         }), this.fileBackend.root);
+        const corruptReadWarn = (msg, fields) => this.discloseWarn(msg, fields);
         this.runStore = new FileRunStore(this.fileBackend.root, {
             error: (msg, fields) => void (this.onError ?? this.onWarn)?.(msg, fields),
             strictHydrate: config.runStoreStrictHydrate,
+            warn: corruptReadWarn,
         });
-        this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root);
-        this.approvalExemptionStore = new FileApprovalExemptionStore(this.fileBackend.root);
-        this.approvalNonceStore = new FileApprovalNonceStore(this.fileBackend.root);
-        this.approvalAskStore = new FileApprovalAskStore(this.fileBackend.root);
-        this.sendFileLedgerStore = new FileSendFileLedger(this.fileBackend.root);
+        this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.approvalExemptionStore = new FileApprovalExemptionStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.approvalNonceStore = new FileApprovalNonceStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.approvalAskStore = new FileApprovalAskStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.sendFileLedgerStore = new FileSendFileLedger(this.fileBackend.root, { warn: corruptReadWarn });
         this.workflowJournalStore = new FileWorkflowJournalStore(this.fileBackend.root, undefined, {
             onCorruptRead: createCorruptReadSeat((msg, fields) => this.discloseWarn(msg, fields), "workflow_journal_corrupt_read"),
         });
@@ -280,6 +283,7 @@ class LocalBackend {
         if (!this.permissionRuleStoresInst) {
             this.permissionRuleStoresInst = createFilePermissionRuleStores(this.fileBackend.root, {
                 onError: (message) => this.onWarn?.("permission_rule_store_disclosure", { message }),
+                warn: (msg, fields) => this.discloseWarn(msg, fields),
             });
         }
         return this.permissionRuleStoresInst;

package/dist/plugins/store-contracts.d.ts

@@ -185,6 +185,11 @@ export declare const RUN_STATUS_CLASS: {
 export type UnsuccessfulRunStatus = {
     [K in RunRecord["status"]]: (typeof RUN_STATUS_CLASS)[K] extends "unsuccessful" ? K : never;
 }[RunRecord["status"]];
+/** 表判为「park」(停在门上)的词 —— **从表派生**,不是手抄的第二份清单。今天 = `"suspended" | "needs_review"`。
+ *  消费点(S-173:同步提交 200 体的 poll 回执 `status`,`http/sync-submit-body.ts`)拿它当型;表翻面 ⇒ 那里当场红。 */
+export type ParkedRunStatus = {
+    [K in RunRecord["status"]]: (typeof RUN_STATUS_CLASS)[K] extends "parked" ? K : never;
+}[RunRecord["status"]];
 /**
  * 一个状态词的类;**表里没有的词 ⇒ `undefined`**。
  *
@@ -318,8 +323,8 @@ export interface SessionSummary {
     /** K-5c (shell §K): the LATEST run's task_id — the anchor the shell uses to re-attach the live event tail in ONE
      *  hop (`GET /v1/runs/:lastRunId/events`) when resuming a picked session, instead of a second lookup. */
     lastRunId: string | null;
-    /** [ref]([ref]/[ref]):latest 终局 run 的 engine runId(`TaskResult.runId`,latest.result JSON 提取的
-     *  零迁移路线 —— result 终局才写 ⇒ 在跑 run 键诚实缺席);OMIT-when-absent,恒不铸 null。轴辨析与
+    /** [ref]([ref]/[ref]):latest run 的 engine runId(`TaskResult.runId`,latest.result JSON 提取的
+     *  零迁移路线 —— result 在终局与 park 时写、认领续跑即清空(S-173)⇒ 在跑 run 键诚实缺席);OMIT-when-absent,恒不铸 null。轴辨析与
      *  wire 半场见 `security.ts SessionListItem.lastTaskRunId`(同名同义)。 */
     lastTaskRunId?: string;
     /** The auto-generated session title (cheap-model one-liner, write-once). null = not (yet)

package/dist/plugins/tidb-pool.js

@@ -6,6 +6,7 @@ import { TIDB_LEADER_RUN_STATEMENTS } from "./leader-run-store-sql.js";
 import { TIDB_ADOPTION_LOG_STATEMENTS } from "./adoption-log-sql.js";
 import { TIDB_PERMISSION_RULE_STATEMENTS } from "./permission-rule-store-sql.js";
 import { TIDB_RETENTION_STATEMENTS } from "./retention-store-sql.js";
+import { SESSION_META_INCARNATION_COLUMN } from "../session-incarnation.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { CENTRAL_SCHEMA_INDEXES } from "./schema-indexes.js";
 import { SESSION_INDEXES } from "./pg-session-storage.js";
@@ -75,6 +76,11 @@ export const SCHEMA_STATEMENTS = [
      placement_root_session_id   VARCHAR(190) NULL,
      placement_handle            VARCHAR(190) NULL,
      placed_at                   DATETIME(3)  NULL,
+     -- S-790 / S-506(design/330 §2):会话化身 —— 同一个会话 id 上**这一位住客**的不透明令牌。铸点只在新建行(register /
+     -- 无 id 创建 / fork / 导入新行),删除随行消失,同 id 重登记铸新的;'' = 没铸过,读口响亮拒。列定义的唯一属主 =
+     -- src/session-incarnation.ts 的 SESSION_META_INCARNATION_COLUMN(存量库由一次性迁移 M5 用同一串补列 + 回填)。
+     -- 不上 wire、不进模型上下文、日志只打前 8 位。
+     ${SESSION_META_INCARNATION_COLUMN.tidb},
      PRIMARY KEY (session_id),
      KEY idx_session_meta_owner (owner),
      -- listPlaced 的检索腿(kind + 租户 + 年龄升序);普通会话这三列全 NULL ⇒ 不占索引选择性。
@@ -261,8 +267,8 @@ export const SCHEMA_STATEMENTS = [
      bound_input_hash VARCHAR(190) NULL,
      -- 🔴 队列化之前的**单座**列 pending_steer 已**退役删列**:那个席位在引擎侧没了(core 7.17.0 #717 d
      -- 对带席的行 PRE-CAS 拒 seat_retired),留着一列没人读、没人写的字节只会让下一个人以为还有两种读法。
-     -- 存量库由启动期的一次性迁移处置(plugins/one-time-migrations.ts,随 7.75.0 删):列上还有非空值 ⇒
-     -- **响亮拒启**并给出两条出路(回 7.16.0 把那些 checkpoint resume 一次让座位排空 / 运维手工清列),
+     -- 存量库由启动期的一次性迁移处置(plugins/one-time-migrations.ts 的 M2,窗口见该文件登记表):列上还送得出去的格 ⇒
+     -- **响亮拒启**并给出两条出路(先在 server 7.73.x 上把那些 run 决掉或取消,让座位送达 / 运维手工清列),
      -- 清空之后 DROP COLUMN。刻意**不**自动把裸单座折进队列:那等于本仓替引擎铸一条它从没写过的队列条目。
      -- pending_steer_queue:core 5.14.0(#147)的**有界有序队列**(PendingSteerEntry[] 的 JSON),现在是本表上
      -- durable steering 的唯一载体。Never touches status/resolve (design/80 inv #4)。

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

@@ -13,6 +13,7 @@
 import { type AcquiredSession, type PlacedSessionRow, type SessionPlacement, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry } from "@sema-agent/core";
 import type { Pool } from "mysql2/promise";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
+import { type SessionFace } from "../session-incarnation.js";
 import type { SessionSummary } from "./store-contracts.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
@@ -36,7 +37,8 @@ export declare class TiDBSessionStore implements SessionStore {
     private load;
     /** Idempotently create a session_meta row with an owner. Existing owner is never overwritten.
      *  [ref]:`placement` 在场时与行同一条 INSERT 落六列;ON DUPLICATE 臂是 no-op ⇒ 已存在的行的元组
-     *  **永不被重写**(first-write 不可变,义务 5 的写侧半场)。 */
+     *  **永不被重写**(first-write 不可变,义务 5 的写侧半场)。
+     *  S-790:化身与属主同一条 first-write 律 —— 新行铸一只(`mintSessionIncarnation`),已存在的行 no-op 臂一个字节不动。 */
     register(sessionId: string, owner: string | null, placement?: SessionPlacement): Promise<void>;
     /**
      * [ref] 义务 6 的廉价探针 —— 一行 PK SELECT:`undefined` = 普通会话或无此行。
@@ -57,6 +59,9 @@ export declare class TiDBSessionStore implements SessionStore {
     }): Promise<PlacedSessionRow[]>;
     /** Owner principal of a session, `null` if registered ownerless, `undefined` if no such session. */
     ownerOf(sessionId: string): Promise<string | null | undefined>;
+    /** S-790:属主 + 化身**一次读**(单行单 SELECT —— 两次独立读在删除 / 重登记的缝里能拼出混世代组合)。`undefined` = 无此会话;
+     *  行在而化身为空 ⇒ `SessionIncarnationMissingError`(响亮拒,判据唯一属主 `sessionFaceFromRow`)。 */
+    sessionFaceOf(sessionId: string): Promise<SessionFace | undefined>;
     touch(sessionId: string): Promise<void>;
     /** E18 — the session's current leaf `SessionTreeEntry.id` (`session_meta.leaf_id`, set transactionally on every
      *  persist). A single SELECT, NO acquire/lock/CAS — safe to call mid-run (write-safety is the append-time CAS, not

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

@@ -5,6 +5,7 @@ import { jsonColumnText } from "./sql-json-column.js";
 import { escapeLike } from "./sql-escape.js";
 import { BASELINE_IO_DEADLINE_MS, decodeInstructionSource, encodeInstructionSource } from "../instruction-source-notice.js";
 import { MANAGED_RETENTION } from "./retention-store-sql.js";
+import { carriedIncarnation, mintSessionIncarnation, sessionFaceFromRow } from "../session-incarnation.js";
 import { contentForkRelation, fastForwardSharedContentDiverged } from "../session-sync-content.js";
 import { assertPlacementAdmission, LIST_PLACED_BATCH, PLACEMENT_SELECT_COLUMNS, placedRowFromRow, placementFromRow, placementInsertValues, SQL_SESSION_PLACEMENTS, } from "./session-placement.js";
 import { classifySyncRelationshipByIds, SyncConflictError, stagingIdFor, STAGING_ID_MARKER, STAGING_GC_GRACE_MS, } from "../session-sync-kernel.js";
@@ -52,9 +53,9 @@ export class TiDBSessionStore {
     }
     async register(sessionId, owner, placement) {
         const now = new Date();
-        await this.pool.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, " +
+        await this.pool.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, " +
             "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at) " +
-            "VALUES (?,?,?,?,NULL,0,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE session_id = session_id", [sessionId, owner, now, now, ...placementInsertValues(placement, now)]);
+            "VALUES (?,?,?,?,NULL,0,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE session_id = session_id", [sessionId, owner, now, now, mintSessionIncarnation(), ...placementInsertValues(placement, now)]);
     }
     async placementOf(sessionId) {
         const [rows] = await this.pool.query(`SELECT ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
@@ -82,6 +83,12 @@ export class TiDBSessionStore {
             return undefined;
         return rows[0].owner ?? null;
     }
+    async sessionFaceOf(sessionId) {
+        const [rows] = await this.pool.query("SELECT owner, incarnation FROM session_meta WHERE session_id = ?", [sessionId]);
+        if (rows.length === 0)
+            return undefined;
+        return sessionFaceFromRow(sessionId, rows[0].owner ?? null, rows[0].incarnation);
+    }
     async touch(sessionId) {
         await this.pool.query("UPDATE session_meta SET updated_at = ? WHERE session_id = ?", [
             new Date(),
@@ -213,7 +220,7 @@ export class TiDBSessionStore {
                 const payload = String(r.payload);
                 await conn.query("INSERT INTO session_event (session_id, seq, entry_id, parent_id, type, payload, ts) VALUES (?,?,?,?,?,?,?)", [newId, seq, r.entry_id, r.parent_id ?? null, r.type, payload, r.ts]);
             }
-            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES (?,?,?,?,?,?)", [newId, owner, now, now, leafId, eventRows.length]);
+            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES (?,?,?,?,?,?,?)", [newId, owner, now, now, leafId, eventRows.length, mintSessionIncarnation()]);
             await conn.commit();
             return newId;
         }
@@ -267,7 +274,7 @@ export class TiDBSessionStore {
         const conn = await this.pool.getConnection();
         try {
             await conn.beginTransaction();
-            await this.insertValidatedLog(conn, sessionId, owner, validated);
+            await this.insertValidatedLog(conn, sessionId, owner, validated, mintSessionIncarnation());
             await conn.commit();
         }
         catch (err) {
@@ -290,14 +297,14 @@ export class TiDBSessionStore {
         const conn = await this.pool.getConnection();
         try {
             await conn.beginTransaction();
-            const [placedRows] = await conn.query("SELECT placement_kind FROM session_meta WHERE session_id = ? FOR UPDATE", [sessionId]);
+            const [placedRows] = await conn.query("SELECT placement_kind, owner, incarnation FROM session_meta WHERE session_id = ? FOR UPDATE", [sessionId]);
             if (placedRows[0]?.placement_kind != null) {
                 await conn.rollback();
                 throw new SessionError("placement_refused", `session ${sessionId} belongs to the ${String(placedRows[0].placement_kind)} placement partition — a session-sync replace cannot overwrite a delegation transcript`);
             }
             await conn.query("DELETE FROM session_event WHERE session_id = ?", [sessionId]);
             await conn.query("DELETE FROM session_meta WHERE session_id = ? AND owner <=> ? AND placement_kind IS NULL", [sessionId, owner]);
-            await this.insertValidatedLog(conn, sessionId, owner, validated);
+            await this.insertValidatedLog(conn, sessionId, owner, validated, carriedIncarnation(placedRows[0] === undefined ? undefined : { owner: placedRows[0].owner, incarnation: placedRows[0].incarnation }, owner));
             await conn.commit();
         }
         catch (err) {
@@ -314,7 +321,7 @@ export class TiDBSessionStore {
             conn.release();
         }
     }
-    async insertValidatedLog(conn, sessionId, owner, validated) {
+    async insertValidatedLog(conn, sessionId, owner, validated, incarnation) {
         let leafId = null;
         for (const e of validated)
             leafId = leafIdAfterEntry(e);
@@ -323,7 +330,7 @@ export class TiDBSessionStore {
             const e = validated[seq];
             await conn.query("INSERT INTO session_event (session_id, seq, entry_id, parent_id, type, payload, ts) VALUES (?,?,?,?,?,?,?)", [sessionId, seq, e.id, e.parentId ?? null, e.type, JSON.stringify(e), new Date(e.timestamp)]);
         }
-        await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES (?,?,?,?,?,?)", [sessionId, owner, now, now, leafId, validated.length]);
+        await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES (?,?,?,?,?,?,?)", [sessionId, owner, now, now, leafId, validated.length, incarnation]);
     }
     beginImportStaging(realSessionId, token) {
         return new TiDBStagingHandle(this.pool, realSessionId, stagingIdFor(realSessionId, token));
@@ -450,8 +457,8 @@ class TiDBStagingHandle {
             if (lastRow[0])
                 leafId = leafIdAfterEntry(decodeSessionEventPayload(lastRow[0].payload, this.realSessionId, "last staged row"));
             const now = new Date();
-            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES (?,?,?,?,?,?) " +
-                "ON DUPLICATE KEY UPDATE owner = VALUES(owner), updated_at = VALUES(updated_at), leaf_id = VALUES(leaf_id), leaf_seq = VALUES(leaf_seq)", [this.realSessionId, owner, now, now, leafId, srcIds.length]);
+            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES (?,?,?,?,?,?,?) " +
+                "ON DUPLICATE KEY UPDATE owner = VALUES(owner), updated_at = VALUES(updated_at), leaf_id = VALUES(leaf_id), leaf_seq = VALUES(leaf_seq)", [this.realSessionId, owner, now, now, leafId, srcIds.length, mintSessionIncarnation()]);
             const [afterMeta] = await conn.query("SELECT placement_kind FROM session_meta WHERE session_id = ?", [this.realSessionId]);
             if (afterMeta[0]?.placement_kind != null) {
                 await conn.rollback();

package/dist/project-identity.d.ts

@@ -1,10 +1,8 @@
-import type { TaskSpec } from "@sema-agent/core";
-/** core 的项目身份声明席(`TaskSpec.memory.projectKey`)—— 从 core 类型派生,不另写一份。 */
-export type MemoryProjectKey = NonNullable<NonNullable<TaskSpec["memory"]>["projectKey"]>;
+import type { MemoryProjectKey, MemoryProjectKeyAbsentReason } from "@sema-agent/core";
+/** core 的项目身份声明席(`TaskSpec.memory.projectKey`)—— core 包根导出的型,原样转出(本仓调用方从这里取)。 */
+export type { MemoryProjectKey };
 /** 本仓会说的缺席词。`not_git` 刻意排除:裁 D 起非 git 目录按目录键控,不是缺席(core 闭集仍收它,本仓不铸)。 */
-export type ProjectIdentityAbsentReason = Exclude<Extract<MemoryProjectKey, {
-    absent: unknown;
-}>["absent"], "not_git">;
+export type ProjectIdentityAbsentReason = Exclude<MemoryProjectKeyAbsentReason, "not_git">;
 /** 一个任务根的项目身份:canonical 项目根,或说得出理由的缺席。 */
 export type ProjectIdentity = {
     readonly root: string;

package/dist/request-key-closure.js

@@ -21,7 +21,7 @@ const TASK_BODY_DECLARED_KEYS = [
     "a2aPeers", "acceptPartialRestore", "additionalDirectories", "additionalReadDirectories", "agents",
     "appendSystemPrompt", "approverPosture", "attachmentIds", "attachments", "capabilitiesNeeded", "cascade", "clientContext",
     "compaction", "compactionModel", "council", "cwd", "debate", "deferTools", "deviceId", "enableFork",
-    "excludeAllTools", "excludeTools",
+    "excludeAllTools", "excludeTools", "fileHistory",
     "finalVerification", "forwardSubagentEvents", "images", "interactiveTools", "jobId", "limits", "maxCostUsd",
     "maxTokens", "mcpServers", "memory", "memoryCapture", "memoryWrite", "model", "objective", "oneShot", "outputRetries",
     "outputSchema", "permissionMode", "projectId", "promptProfile", "reasoningEffort", "requireExistingSession",

package/dist/request-value-closure.d.ts

@@ -1,21 +1,90 @@
+/**
+ * 提交体的**值闭集门** —— `request-key-closure.ts`(键名闭集)的姊妹,同一条纪律的另一半。
+ *
+ * ## 这里解决的是哪一类病
+ *
+ * 键名对了、**值**拼错了:`memoryCapture: "OFF"`、`memory: "on"`、`memory: true`、`fileHistory: "off"`。这一族键有一个
+ * 共同的形 —— **单成员闭集的关断词**:合法值只有**一个**关断拼法(记忆族是 `"off"`;core 在 `fileHistory` /
+ * `checkpointStore` 上的拼法是 `"disabled"`),「开」的拼法**刻意不存在**(缺席就是「照常」的唯一形,声明只能单向收紧)。
+ * 于是坏值有且只有一种正确处置:**响亮拒**。按 truthiness 读成任一态都是灾难的一半 ——
+ * 一个敲错的隐私/收紧请求被静默丢掉(用户以为关了,其实没关),或者一个敲错的键把功能静默关掉。
+ *
+ * 🔴 **判别是「值域恰好是一个关断词」,不是「值域恰好是一个字面量」**(S-724 加 `fileHistory` 时定形):
+ * `approverPosture` 的值域也只有一个词(`"bypass"`),但它是一句**姿态声明**、闭集属主在 core、本仓刻意**零判据**
+ * (`http/wire-types.ts` 那一段逐字成文);把判别放宽成「单字面量」会把它也拖进本表 = 同一语义面第二个判官。
+ * 关断词全集 {@link OffSwitchWord} 是 core 的两种关断拼法,新增第三种拼法 = 加一个词(并逐键重判)。
+ *
+ * ## 为什么是一只判据函数,不是每处一抄
+ *
+ * 这道门必须落在**两腿**上:fresh 提交的 HTTP admission(400 `request.field_invalid`)与 **resume 重放**
+ * 共用的解析路径(`boot/resolve-spec.ts`;从这里逃出的 `HttpError` 被 `http/resume-legs.ts` 折成 409
+ * `resume_blocked_by_policy`(带 `blockedBy: e.code`)= 一个 typed 的「续跑被挡」,比静默放行诚实 —— 亲读
+ * `resume-legs.ts:776` / `:2366`,**不是**邻处旧注说的 `server.ts`,那句是切片搬家后的陈旧指路)。
+ * ⚠️ 本族**刻意不**照抄「fresh fail-loud / resume 宽容降级」那条双层姿势(`settings` / `outputStyle` /
+ * `permissionMode` 走的是它):那三处降级的是配置/名单类的**可恢复量**,而把一条收紧声明按打字错误折成缺席是
+ * **不可逆方向**的静默降级 —— 一条旧 worker 持久化的 `memoryCapture:'OFF'` 会在 resume 时静默恢复采集。
+ *
+ * 两腿各抄一份判据 + 一份文案,就是同一条 wire 语义上的**两个写者**;`memoryCapture` 从 [ref] 起正是这么长的
+ * (`http/admission.ts` 与 `boot/resolve-spec.ts` 各一份逐字手抄的 150 字文案)。S-405 给这一族添第二个键
+ * (`memory`)时把它收成**一张表、一只判据、一处文案属主**:新增一个同形键 = 加一行,而不是四处改。
+ * S-724 加第三个键 `fileHistory` 正是这么加的 —— 一行(带它自己的关断词),零处改判据。
+ * 文案的冻结职责随之从「桶扫描」搬到 `test/api-error-text-freeze.test.ts` 的常量锚格(与 `RUN_NOT_FOUND_MESSAGE` /
+ * `PERSIST_RULE_*` 两格同形、同理由)。
+ *
+ * ## 边界(与姊妹门同律)
+ *
+ *  · 只判**本表登记的键**的值形;别的值形校验归各自既有的门,本门零抢话。
+ *    唯一的跨键句:`fileHistory` 关断词与还原同体({@link FILE_HISTORY_DISABLED_NO_RESTORE}),文案属主随关断词住在这里,
+ *    只在 fresh 受理门执行(理由在那一格)。
+ *  · 只判**值**,不判键名(键名闭集是 `request-key-closure.ts` 的活)。
+ *  · 体本身非对象 ⇒ 本门不判(留给「missing 'objective' string」那道根形门,免得一个体被两句话抢答)。
+ */
+import type { TaskRequestBody } from "./http/wire-types.js";
 /** [ref] §2.1([ref]):`memoryCapture` 的拼写门文案。**wire 可见文本** —— 改一个字就是对端契约漂移
  *  (SDK/壳/文档锚它),字节冻结在 `test/api-error-text-freeze.test.ts` 的常量锚格。 */
 export declare const MEMORY_CAPTURE_SPELLING_MESSAGE = "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual \u2014 there is no 'on' spelling)";
 /** core [ref] r5 §5 W3(S-405):请求级「记忆整面关」`memory` 的拼写门文案。同上,wire 可见、字节冻结。
  *  文案刻意点明 capture 的分工 —— 两个键都在记忆轴上、形又一模一样,拿错的人要在同一条回执里读到该用哪个。 */
 export declare const MEMORY_OFF_SPELLING_MESSAGE = "memory must be the string 'off' when present (the request-level declaration that this run mounts no memory face at all; absent = memory as usual \u2014 there is no 'on' spelling; to keep memory mounted but stop this session's content from entering long-term memory, send memoryCapture: 'off' instead)";
+/** S-724(core 7.31.0 #1048):请求级「文件历史关断」`fileHistory` 的拼写门文案。同上,wire 可见、字节冻结。
+ *  唯一词是 core 的拼法 `'disabled'`(与 `checkpointStore` 同),**不是**记忆族的 `'off'` —— 句子点名它,
+ *  顺带说清同一提交里不能再要还原(那一对的拒句是下面的 {@link FILE_HISTORY_DISABLED_NO_RESTORE})。 */
+export declare const FILE_HISTORY_OFF_SPELLING_MESSAGE = "fileHistory must be the string 'disabled' when present (the request-level declaration that this run records no file history \u2014 no backup of an edited file, and no file restore in the same request; absent = the deployment's setting \u2014 there is no 'enabled' spelling)";
+/**
+ * S-724 b′(主会话裁,车PW codex r1 [high] 复现后)—— `fileHistory: "disabled"` 与还原**同体**的拒句(`request.field_conflict`)。
+ * 与 `tool-approval.ts` 的 `SETTLED_BY_DENY_ONLY` / `READ_ROOT_GRANT_ALLOW_ONLY` **同一族**:「只看体就能判的矛盾,在裁决之前响亮说」。
+ * 这一对是调用方自己写出的矛盾(关掉这条 run 的文件历史,又要从文件历史还原);core 也拒(`rewind.capture_disabled`),但它的拒
+ * 落在 prepare 的**会话分叉之后**(`prepare-acquire-reconcile` 先按 `resumeAt` 把活动分支移过去,`prepare-file-history` 才判),
+ * 且拒后不回滚 —— 拒传不回来。所以本层在任何副作用之前拒。**这不是替 core 再判一次「捕获关了能不能还原」**:判的是体里两个键
+ * 能不能共存,不看部署、不看店。
+ * 判据:{@link fileHistoryRestoreConflict}。**只在 fresh 受理门**(`http/admission.ts`);续跑腿不过这道门(RESUME 重放不过受理门,
+ * 同律 —— 且续跑腿重建时整族剥掉一次性历史动作,矛盾在盘上的体里本就留不下来)。wire 可见、字节冻结。
+ */
+export declare const FILE_HISTORY_DISABLED_NO_RESTORE = "fileHistory: 'disabled' cannot ride with a file restore (restoreFiles, rewindFilesTo, or the retired rewindFiles) \u2014 the request turns this run's file history off and asks to restore files from it in the same breath; the engine would refuse it (rewind.capture_disabled) only after the session had already been branched at resumeAt, which it does not undo, so it is refused here, before any side effect. Drop fileHistory to restore, or drop the restore to run without file history";
 /**
- * **单成员闭集键表** —— 合法值只有 `"off"`,缺席=照常,没有 `"on"`。
+ * 「关断词 ∧ 还原」这一对的判据(纯函数,只看体)。还原 = 三个键里任一个在请求:`restoreFiles: true`、非空串 `rewindFilesTo`
+ * (与 `boot/resolve-spec.ts` 的读法同:空串 / 非串按缺席)、退役拼法 `rewindFiles: true`(restore 义要一次还原;capture 义要的
+ * 正是这个词关掉的记录 —— 两义都与关断词矛盾)。调用前值形已由上面的单成员表与既有布尔门判过。
+ */
+export declare function fileHistoryRestoreConflict(body: Pick<TaskRequestBody, "fileHistory" | "restoreFiles" | "rewindFiles" | "rewindFilesTo">): boolean;
+/**
+ * **单成员闭集键表** —— 每键合法值只有它自己那一个关断词(`word`),缺席=照常,没有「开」的拼法。
  *
- * 🔴 顺序 = **裁决顺序**,且是**既存键在前**:一个两键都畸形的存量体,判决与加 `memory` 之前逐字节相同
+ * 🔴 顺序 = **裁决顺序**,且是**既存键在前**:一个多键都畸形的存量体,判决与加新键之前逐字节相同
  * (新键不许改写既有体的回执)。新增同形键一律**追加在尾部**。
  */
 declare const SINGLE_MEMBER_OFF_FIELDS: readonly [{
     readonly field: "memoryCapture";
+    readonly word: "off";
     readonly message: "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual — there is no 'on' spelling)";
 }, {
     readonly field: "memory";
+    readonly word: "off";
     readonly message: "memory must be the string 'off' when present (the request-level declaration that this run mounts no memory face at all; absent = memory as usual — there is no 'on' spelling; to keep memory mounted but stop this session's content from entering long-term memory, send memoryCapture: 'off' instead)";
+}, {
+    readonly field: "fileHistory";
+    readonly word: "disabled";
+    readonly message: "fileHistory must be the string 'disabled' when present (the request-level declaration that this run records no file history — no backup of an edited file, and no file restore in the same request; absent = the deployment's setting — there is no 'enabled' spelling)";
 }];
 /** 一次值闭集裁决的产物:出问题的键名(机读)+ 一句 wire 文案。 */
 export interface SingleMemberOffFieldIssue {
@@ -23,7 +92,7 @@ export interface SingleMemberOffFieldIssue {
     message: string;
 }
 /**
- * 单成员闭集键的值形裁决:表内任一键在场且不是字面 `"off"` ⇒ 返回拒体(调用方 400 `request.field_invalid`);
+ * 单成员闭集键的值形裁决:表内任一键在场且不是它自己那一个关断词 ⇒ 返回拒体(调用方 400 `request.field_invalid`);
  * 全部合法或全部缺席 ⇒ `null`。**两腿(fresh admission / resume 重放)共用这一只**。
  */
 export declare function singleMemberOffFieldIssue(raw: unknown): SingleMemberOffFieldIssue | null;

package/dist/request-value-closure.js

@@ -1,16 +1,24 @@
 export const MEMORY_CAPTURE_SPELLING_MESSAGE = "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual — there is no 'on' spelling)";
 export const MEMORY_OFF_SPELLING_MESSAGE = "memory must be the string 'off' when present (the request-level declaration that this run mounts no memory face at all; absent = memory as usual — there is no 'on' spelling; to keep memory mounted but stop this session's content from entering long-term memory, send memoryCapture: 'off' instead)";
+export const FILE_HISTORY_OFF_SPELLING_MESSAGE = "fileHistory must be the string 'disabled' when present (the request-level declaration that this run records no file history — no backup of an edited file, and no file restore in the same request; absent = the deployment's setting — there is no 'enabled' spelling)";
+export const FILE_HISTORY_DISABLED_NO_RESTORE = "fileHistory: 'disabled' cannot ride with a file restore (restoreFiles, rewindFilesTo, or the retired rewindFiles) — the request turns this run's file history off and asks to restore files from it in the same breath; the engine would refuse it (rewind.capture_disabled) only after the session had already been branched at resumeAt, which it does not undo, so it is refused here, before any side effect. Drop fileHistory to restore, or drop the restore to run without file history";
+export function fileHistoryRestoreConflict(body) {
+    if (body.fileHistory !== "disabled")
+        return false;
+    return body.restoreFiles === true || body.rewindFiles === true || (typeof body.rewindFilesTo === "string" && body.rewindFilesTo.length > 0);
+}
 const SINGLE_MEMBER_OFF_FIELDS = [
-    { field: "memoryCapture", message: MEMORY_CAPTURE_SPELLING_MESSAGE },
-    { field: "memory", message: MEMORY_OFF_SPELLING_MESSAGE },
+    { field: "memoryCapture", word: "off", message: MEMORY_CAPTURE_SPELLING_MESSAGE },
+    { field: "memory", word: "off", message: MEMORY_OFF_SPELLING_MESSAGE },
+    { field: "fileHistory", word: "disabled", message: FILE_HISTORY_OFF_SPELLING_MESSAGE },
 ];
 export function singleMemberOffFieldIssue(raw) {
     if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw))
         return null;
     const body = raw;
-    for (const { field, message } of SINGLE_MEMBER_OFF_FIELDS) {
+    for (const { field, word, message } of SINGLE_MEMBER_OFF_FIELDS) {
         const value = body[field];
-        if (value !== undefined && value !== "off")
+        if (value !== undefined && value !== word)
             return { field, message };
     }
     return null;

package/dist/roster-bound-http-status.d.ts

@@ -0,0 +1,6 @@
+export declare const ROSTER_BOUND_HTTP_STATUS: {
+    readonly "config.tool_name_too_long": 503;
+    readonly "config.tool_contract_too_long": 503;
+    readonly "config.tool_roster_bound": 503;
+};
+//# sourceMappingURL=roster-bound-http-status.d.ts.map