@sema-agent/server 7.50.0 → 7.52.0

package/dist/plugins/remote-env-k8s.d.ts

@@ -268,7 +268,7 @@ export declare class RemoteK8sExecutionEnv implements RemoteExecutionEnv, Backgr
         maxLines?: number;
         abortSignal?: AbortSignal;
     }): Promise<Result<string[], FileError>>;
-    /** 父目录自建(与 host/local-docker/adb/ssh 同口径)。抽成共用是因为 `appendFile` 曾**绕过**它:
+    /** 父目录自建(与 host/local-docker/adb/ssh 同口径)。抽成共用是因为 `appendFile` 曾**跳过**它:
      *  🔴 2026-07-25 实测的跨腿分叉 —— `appendFile` 直接调 `writeChunked`,整条路上没有 `mkdir -p`,于是
      *  「直接 append 建一个新日志路径」在 k8s 腿上返 `not_found`,而其余 5 腿都成功(host/local-docker/adb 实测,
      *  ssh/e2b 由方法体判据)。core 的后台输出镜像正是"每拍 append 一次"的形,这条分叉会让它在 k8s 腿上从第一拍

package/dist/plugins/remote-scratchpad.js

@@ -1,4 +1,4 @@
-const REMOTE_SCRATCHPAD_LANES = new Set(["e2b", "k8s", "local-docker", "ssh"]);
+const REMOTE_SCRATCHPAD_LANES = new Set(["e2b", "k8s", "local-docker", "ssh", "device"]);
 export function isRemoteScratchpadLane(provider) {
     return provider !== undefined && REMOTE_SCRATCHPAD_LANES.has(provider);
 }

package/dist/plugins/retention-lane-store-sql.d.ts

@@ -147,7 +147,7 @@ export declare class SqlRetentionLaneStore implements RetentionLaneStore {
      * 判据三合取写进**一条 CAS 的 WHERE**:holder 是我 ∧ fencing token 还是本轮那个 ∧ **尚未过期**。
      *  · 第三项是承重的:租约过期而 holder 还写着我,必须读成**不再属于我**(fail-closed)——另一个副本
      *    随时可能抢走,两个副本同时跑三方法是这条腿最不能出的事。
-     *  · 「复核」与「续租」合成一条语句而不是先读后写(codex 对抗复审 R1-[high],验真后改):
+     *  · 「复核」与「续租」合成一条语句而不是先读后写(codex 交叉复审 R1-[high],验真后改):
      *    ① 读+写两条语句之间有窗口,而 CAS 的谓词与更新在引擎里是原子的;
      *    ② 更要紧的是**续租本身**:`startRetentionLane` 的重入守卫会跳过下一 tick,于是一轮的续租机会
      *       只有轮首那一次 —— 一轮跑满 2×interval 之后租约自己到期,而本副本毫不知情、继续删下去。
@@ -196,7 +196,7 @@ export declare class SqlRetentionLaneStore implements RetentionLaneStore {
         nowMs: number;
     }): Promise<void>;
     /**
-     * 放置/解除 **+ 治理审计行,同一个事务**(codex 对抗复审 R1-[high],验真后加)。
+     * 放置/解除 **+ 治理审计行,同一个事务**(codex 交叉复审 R1-[high],验真后加)。
      *
      * 🔴 为什么必须原子(与 §6 F5 的「删除与审计同事务」是同一条判据,只是换了一张表):两次独立提交下,
      * 第二步失败会留下一次**无审计的状态变更**。PUT 那一支是「冻结了但账上没有」;**DELETE 那一支更重**
@@ -231,7 +231,7 @@ export declare class SqlRetentionLaneStore implements RetentionLaneStore {
      *
      * `before` = 上一页最后一行的 `id`(严格小于)。
      *
-     * 🔴 读上限是 `MAX_LIMIT + 1` 而不是 `MAX_LIMIT`(codex 对抗复审 R1-[medium],验真属实):调用方要判
+     * 🔴 读上限是 `MAX_LIMIT + 1` 而不是 `MAX_LIMIT`(codex 交叉复审 R1-[medium],验真属实):调用方要判
      * 「还有没有下一页」就得多取一行,而**页**的上限是 `MAX_LIMIT`。旧形把 limit 无条件夹到 `MAX_LIMIT`
      * ⇒ 请求 `limit=200` 时 scanned 恒 ≤ 200 ⇒ `hasMore` 恒 false ⇒ **第 201 行之后的审计对这条分页链
      * 永久不可达**。这一格是「窗的上限」与「探路的那一行」两个不同的数被写成同一个数造成的,

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

@@ -217,7 +217,7 @@ export declare class SqlRetentionStore implements ManagedRetentionCapability {
      *     一条既存的 hold(两方言的这两个动词都只在缺行时写),只保证**接下来那把行锁有东西可锁**;
      *  ② `SELECT held … FOR UPDATE` —— 现在这行必定存在,于是锁真的拿到了。
      *
-     * 🔴 为什么必须先造行(codex 对抗复审 R1-[high],验真后改):`FOR UPDATE` 锁不住缺席行(TiDB 无 gap
+     * 🔴 为什么必须先造行(codex 交叉复审 R1-[high],验真后改):`FOR UPDATE` 锁不住缺席行(TiDB 无 gap
      * lock;PG READ COMMITTED 同样)。presence 形(「行在 = 冻结」)下,operator 的 PUT 与本事务可以**同时**
      * 都读到「没有 hold」,PUT 提交返回成功之后本事务照删不误 —— 设计稿 §5 声称由行锁给出的串行化在那一形
      * 上根本不存在。哨兵行把 hold 的写点与删除的读点压到**同一把行锁**上,那句承诺才成立。
@@ -309,7 +309,7 @@ export declare class SqlRetentionStore implements ManagedRetentionCapability {
     /**
      * **可过期**的候选 token(保护谓词写在 SQL 里、扣在 `LIMIT` **之前**)。
      *
-     * 🔴 为什么保护必须下推(codex 对抗复审 R1-[medium],验真后改):旧形先按时间取 N 行、再在 JS 里剔除
+     * 🔴 为什么保护必须下推(codex 交叉复审 R1-[medium],验真后改):旧形先按时间取 N 行、再在 JS 里剔除
      * pinned —— 只要最老的一批持续被占着,每轮取回的都是同一批、每轮删 0,**它们后面**那些同样过期、又
      * 没有任何引用的行**永远轮不到**。那不是「下一拍自然收敛」,那是一个域的留存静默停摆(而且读数一直
      * 是 deleted=0,看上去像"没有候选")。判据下推之后 LIMIT 扣的是**真能动的行**,头部被保护多少行都不
@@ -319,7 +319,7 @@ export declare class SqlRetentionStore implements ManagedRetentionCapability {
     /**
      * 过期视界之内、**当下被 live-pin 护住**的 pending 行数 = receipt 的 `skipped`。
      *
-     * 🔴 账法定谳(两轮对抗复审各推了一次,最终落在这一形):
+     * 🔴 账法定谳(两轮交叉复审各推了一次,最终落在这一形):
      *  · 曾经用「候选 + pinned 两读相加当分母、差值当 skipped」——被 codex R2 抓到会把中途翻转 pin 的行数两遍;
      *  · 改成「视界总数当分母、差值当 skipped」——被 codex R3 抓到在 PG 的 READ COMMITTED 下可以**为负**
      *    (分母读完之后又有行被 put/reopen 成 pending,候选与 UPDATE 都看得见它 ⇒ expired > 分母),而一条
@@ -356,7 +356,7 @@ export declare class SqlRetentionStore implements ManagedRetentionCapability {
      * **可删**的会话 id:本域、过视界、且四条活引用腿**一条都不命中**(保护谓词下推,扣在 LIMIT 之前 ——
      * 理由与 {@link expiryCandidates} 逐字相同:头部被保护的树不许饿死它后面的树)。
      *
-     * `lock = true`(删除事务里的读)追加 `FOR UPDATE`,这一格是**承重**的(codex 对抗复审 R1-[high]):
+     * `lock = true`(删除事务里的读)追加 `FOR UPDATE`,这一格是**承重**的(codex 交叉复审 R1-[high]):
      *  · 会话行是**存在**的行 ⇒ 这把锁与 hold 哨兵不同,它真的锁得住;
      *  · 锁住之后,并发的 `touch()`(把会话重新拉进视界)与 session-sync 的 **owner 改写**(importEntries /
      *    replaceEntries / staged commit 都会重写 `session_meta.owner`)必须排队等我们提交 —— 否则「按旧候选集
@@ -371,11 +371,11 @@ export declare class SqlRetentionStore implements ManagedRetentionCapability {
     /**
      * 本域**可归属**的孤儿卸载结果(属主 session 已亡 + 墓碑归属本域 + 归属**无歧义**)。
      *
-     * 🔴 第三个条件是 fail-closed 的归属门(codex 对抗复审 R3-[high],验真后加):`tool_result` 没有域列,
+     * 🔴 第三个条件是 fail-closed 的归属门(codex 交叉复审 R3-[high],验真后加):`tool_result` 没有域列,
      * 它的域完全靠「属主 sessionId 的墓碑」推。而会话 id 是**调用方可自选**的 ⇒ 两个租户先后用过同一个 id
      * 完全合法;两边都删过之后,同一个 row_key 上会有**两个域**的墓碑,这时任何一边的 sweep 拿自己的墓碑
      * 去认领这些字节都只是猜。判据因此是:**存在第二个域的同名墓碑 ⇒ 这批行不可归属 ⇒ 一根不删**,
-     * 实体清理退回既有的 TTL 腿(`reapOlderThan`)。少删一次是可接受的;删掉另一个租户的字节、还绕过它的
+     * 实体清理退回既有的 TTL 腿(`reapOlderThan`)。少删一次是可接受的;删掉另一个租户的字节、还跳过它的
      * legal hold 与审计域,不可接受。
      */
     protected orphanToolResultCandidates(exec: {
@@ -394,7 +394,7 @@ export declare class SqlRetentionStore implements ManagedRetentionCapability {
      *      {@link SqlRetentionStore.sessionCandidates});
      *   ③ 按 E21 顺序逐表删 → 墓碑 → 审计行(同事务)→ COMMIT。
      *
-     * 🔴 活引用重查为什么是**候选查询本身**而不是第二条查询(codex 对抗复审 R1 的两条 high 合并采纳):
+     * 🔴 活引用重查为什么是**候选查询本身**而不是第二条查询(codex 交叉复审 R1 的两条 high 合并采纳):
      *  · 两条查询之间有窗口,而下推之后「被查到的」按构造就是「四条腿一条都不命中的」;
      *  · `FOR UPDATE` 让这些会话行在本事务期间不可被 `touch()` 拉回视界、也不可被 session-sync 改写属主 ——
      *    旧形(不加锁 + 尾部无条件删 `session_event`)可以在属主被并发改写后,把**别的租户**的历史删掉;

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

@@ -373,6 +373,12 @@ export class SqlRetentionStore {
             ["session_policy", "session_id"],
             ...(this.opts.taskAttachmentTable ? [["task_attachment", "session_id"]] : []),
             ["snapshot_manifest", "scope"],
+            ["file_history_tracked", "scope"],
+            ["file_history_version", "scope"],
+            ["file_history_boundary", "scope"],
+            ["file_history_boundary_file", "scope"],
+            ["file_history_scope", "scope"],
+            ["file_history_reaped_entry", "scope"],
         ]) {
             const s = set(col, 1);
             await conn.query(`DELETE FROM ${table} WHERE ${s.sql}`, s.params);

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

@@ -152,8 +152,14 @@ export declare class SqlRunStore {
      * this the row sits at `suspended`/updated_at=suspend-time for the WHOLE resume execution, so a resume that
      * crosses the TTL is marked `failed` mid-run and its session lock (`task_active`) is released. Returns true
      * if it claimed the flip (false ⇒ the reaper already expired it, or it isn't suspended).
+     *
+     * S-51(codex R1 [medium],红先双库证):认领 = **接管 `instance_id`**。此前该列只在 createRun 铸、此处不动,
+     * 于是 A 创建、C 认领 resume 的行永远记 A —— 而 steer/interrupt 的「他副本」臂与 sendHandleMiss 都拿这列当
+     * 「当前持有者」证据:verify 形 resume 腿(不登记 steerable)在 C 上跑时,C 读到 A≠C 就谎报「run 在别的副本」。
+     * 语义自此成文:`instance_id` = **当前持有副本**(createRun 铸、markResuming 认领接管);CAS 输不改列
+     * (一个输掉的认领不许覆盖赢家的持有记录——同一条条件 UPDATE 天然保证)。
      */
-    markResuming(taskId: string): Promise<boolean>;
+    markResuming(taskId: string, instanceId: string): Promise<boolean>;
     /** The active run's taskId for a session (the `task_active` claim) — lets resume find the suspended run row. */
     getActiveTaskId(sessionId: string): Promise<string | undefined>;
     /** Shared row→record mapper — byte-identical between dialects (both drivers hand back the same column
@@ -215,7 +221,7 @@ export declare class SqlRunStore {
      * 右删失效**(anchors 腿的注逐字写着这句)。删除决策的属主门在**路由层**(DELETE /v1/sessions/:id 先
      * `ownerOf` 再比对 scope,fleet-wide 臂同门),本方法的唯一生产调用点是那条路由后面的 purge 协调器。
      *
-     * 🔴 **化身围栏**(`expectedSessionOwner`;codex 对抗复审 R1-[high],验真后修)—— 属主门下来了,但会话
+     * 🔴 **化身围栏**(`expectedSessionOwner`;codex 交叉复审 R1-[high],验真后修)—— 属主门下来了,但会话
      * **身份**必须在同一个事务里重新确认。会话 id 由调用方自选、且删除之后**可被别人重新登记**
      * (`register` 是 INSERT … ON DUPLICATE KEY / ON CONFLICT,老行没了就是一条新行,新 owner):于是
      * 「路由 `ownerOf` 已验权」这句话在两只并发 purge 交错时会过期 —— A 与 A' 同时通过属主门,A' 跑完整条
@@ -280,7 +286,7 @@ export declare class SqlRunStore {
      * the run + RELEASE its task_active (unlock the session). Mirrors the checkpoint reaper's CAS-expire (≈ deny);
      * idempotent across replicas. Returns count.
      *
-     * 🔴 design/80 D-D (adversarial blocker fix): SKIPS any row whose checkpoint is STILL pending — that row is
+     * 🔴 design/80 D-D (blocker fix): SKIPS any row whose checkpoint is STILL pending — that row is
      * owned by a checkpoint-state-driven sweep (the SLA deny-sweep for human/irreversible_ask, or
      * failSuspendedWithExpiredCheckpoint once the checkpoint is expired). Without this guard, this time-based
      * UPDATE fired at the SAME instant as the deny-sweep (deadline == createdAt + ttl, both keyed on the TTL),

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

@@ -132,8 +132,8 @@ export class SqlRunStore {
     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 markResuming(taskId) {
-        const { affected } = await this.db.query(this.q("UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, updated_at = ? WHERE task_id = ? AND status IN ('suspended','needs_review')", "UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, updated_at = $1 WHERE task_id = $2 AND status IN ('suspended','needs_review')"), [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]);
         return affected === 1;
     }
     async getActiveTaskId(sessionId) {

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

@@ -8,7 +8,7 @@ export declare const PRESIGN_MAX_TTL_SEC = 604800;
  *  - keyed on the S3 SECRET KEY — server-held and stable, so the mapping is deterministic per deployment but
  *    unforgeable/unenumerable from outside (a URL holder cannot test principal guesses without the key);
  *  - the "sendfile-scope:" DOMAIN SEPARATOR pins this HMAC use — the same secret signs SigV4 requests, and a
- *    cross-protocol collision between "scope segment" and any other HMAC-of-attacker-controlled-string use is
+ *    cross-protocol collision between "scope segment" and any other HMAC-of-caller-controlled-string use is
  *    exactly what domain separation exists to prevent;
  *  - 32 hex chars (128 bits) is a NAMESPACE label, not a secret: the cross-tenant BIRTHDAY bound at even a
  *    billion tenants is ~n²/2^129 ≈ 2^-69 — negligible. (The earlier 16-hex/64-bit cut had a ~2.7% birthday

package/dist/plugins/session-placement.d.ts

@@ -96,7 +96,7 @@ export interface PlacementAcquireOpts {
  * · 方向①(claim 关门):`persisted` 在场 + 非 `requireExisting` + 调用方没带创建 placement ⇒ 拒。
  *   `requireExisting`(读/复活形,义务 5)与「创建调用及其幂等重取」(带 placement 的可信内部链)
  *   是仅有的两个合法形。placement 不可变意味着带 placement 的参数**永远重写不了**任何东西——持久化
- *   的那一份恒赢,所以放行它不开任何后门。
+ *   的那一份恒赢,所以放行它不开任何口子。
  * · 方向②(镜像/squat):带 placement 的创建形回读到**缺席**或**异组**元组 ⇒ 拒。缺席 = 并发的
  *   claim 形抢先建出了普通会话(或带外写把元组抹了);异组 = 同 id 上坐着另一条委派链的转录。
  *   两者都不许让「声明了 durable 分区」这句话在静默中变成谎。

package/dist/plugins/sql-errors.d.ts

@@ -50,7 +50,7 @@ export declare const MYSQL_ER_BAD_FIELD_CODE = "ER_BAD_FIELD_ERROR";
  * 🔴 单一属主的理由与 {@link isDupKeyError} 逐字同源(本文件顶注的 single-semantic-multi-site-drift):
  * 判据一旦复制,两处的识别集就会各自漂,而这条谓词的错判方向**特别贵** —— 它守的是一句**破坏性**的
  * 错误指路(「去 DROP TABLE」)。超时、连接重置、取消、资源不足、列级权限被拒、表整个不存在,每一种
- * 都会让探针抛错;把它们诊断成「删表重建」比它要挡的缺陷更贵(#340 codex 对抗复审 round2/round3
+ * 都会让探针抛错;把它们诊断成「删表重建」比它要挡的缺陷更贵(#340 codex 交叉复审 round2/round3
  * [high] 两轮收窄后的终形)。认不出的一律**不是**缺列(fail-safe:宁可把一次真缺列报成原始错误)。
  *
  * MySQL 侧两个归因键都认(mysql2 的 `code`/`errno` 是同一件事的两种写法),与 dup-key 那条同姿势。

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

@@ -1,7 +1,6 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import type { SessionStore, SessionPolicyStore, FileSnapshotStore, WorkflowJournalStore, ToolResultStore } from "@sema-agent/core";
-import { type FileSnapshotBounds } from "@sema-agent/core";
+import type { SessionStore, SessionPolicyStore, FileHistoryStore, WorkflowJournalStore, ToolResultStore } from "@sema-agent/core";
 import { type OutcomeSink } from "./file-outcome-sink.js";
 import { type InboxWarn } from "./workflow-run-store-sql.js";
 import { FileRunStore } from "./file-run-store.js";
@@ -9,6 +8,7 @@ import { LocalCheckpointStore } from "./local-checkpoint-store.js";
 import { FileResumeAnchorStore } from "./file-resume-anchor-store.js";
 import { type ApprovalExemptionStore } from "./approval-exemption-store.js";
 import { type ApprovalAskStore as ApprovalAskStoreType } from "./approval-ask-store-sql.js";
+import { type MemoryOptOutGrantStore } from "./memory-optout-grant-store-sql.js";
 import { type SendFileLedger } from "./send-file-ledger.js";
 import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 import type { ServiceConfig } from "../config-types.js";
@@ -17,6 +17,7 @@ import { TiDBCheckpointStore, PgCheckpointStore } from "./checkpoint-store-sql.j
 import { TiDBImageIndex, PgImageIndex } from "./image-index-sql.js";
 import { TiDBImageBake, PgImageBake } from "./image-bake-store-sql.js";
 import { TiDBLeaderRunStore, PgLeaderRunStore } from "./leader-run-store-sql.js";
+import type { DeviceStore } from "../device-store.js";
 import { TiDBBreakerState, PgBreakerState } from "./breaker-state-sql.js";
 import { TiDBCostQuota } from "./tidb-cost-quota.js";
 import { PgCostQuota } from "./pg-cost-quota.js";
@@ -44,22 +45,27 @@ export type { ApprovalAskStore, AskRow, NewAskRow, AskTransitionPatch, DecideAsk
  *  it, core's InMemory omits it → optional). tidb/pg = durable twins; local = core's InMemorySessionPolicyStore (works
  *  local — rules need no cloud-only infra). The shared env-gated equivalence suite keeps the twins byte-matched to InMemory. */
 export type ServiceSessionPolicyStore = SessionPolicyStore;
-/** E19 rewind-files FileSnapshotStore — core's interface PLUS the service `deleteBySession` (E21 purge; the durable
- *  twins carry it, core's InMemory omits it → optional). tidb/pg = durable twins (manifest+blobs, reuse core
- *  captureManifest/applyManifest); local = core's FileFileSnapshotStore(file-backed content-addressed,跨重启
- *  存活——接入审计 L6 订正:旧注释写 InMemory 会误导 local 快照持久性判断). Also the 2c work-artifact transfer store. */
-export type ServiceFileSnapshotStore = FileSnapshotStore & {
-    /** [805]③a observability tail (SQL twins only — core's local stores drop the count internally, a core-side
-     *  gap): captureManifest's tolerated-vanished counter → metric sink, assigned by main.ts when present.
-     *  codex F8: async sinks admitted; the twins swallow a rejected promise (never-throw seam holds). */
-    onSkippedVanished?: (count: number) => void | Promise<void>;
+/** S-15 per-edited-file rewind FileHistoryStore — core's interface PLUS the service extras only the SQL twins
+ *  carry (optional so the local lane's core `FileFileHistoryStore` still fits). Replaces the retired E19
+ *  whole-tree `ServiceFileSnapshotStore` (design/381: the boundary covers the TRACKED set only — files this
+ *  session edited; there is no whole-tree manifest anymore). Also the 2c history-transfer store
+ *  (exportHistory/importHistory + the blob negotiation faces below). */
+export type ServiceFileHistoryStore = FileHistoryStore & {
+    /** 2c sync blob-face marker — see SqlFileHistoryStore.syncBlobFaces (codex R2-high: name-probing
+     *  `putBlob` on an arbitrary store collides with the local core store's PRIVATE void helper). */
+    syncBlobFaces?: true;
+    /** E21 purge / overwrite-dst sync wipe: drop the WHOLE scope incl. v1 baselines + DV-14 markers
+     *  (`reap(scope, [])` deliberately retains those while the scope lives — not a purge). SQL twins only. */
     deleteBySession?(scope: string): Promise<number>;
-    /** 2c session-sync DoS bound — GLOBALLY GC grace-window orphan blobs (standalone PUTs never imported, plus the
-     *  blobs reap()/deleteBySession() left orphaned — byte deletion is ASYNC, never on the sync purge path). The durable
-     *  twins carry it (scheduled by the main.ts reaper, error-tolerant → eventual consistency); core's InMemory omits it. */
+    /** Async byte-GC for the file_history_blob domain (orphans left by reap/purge/lost mint races; grace-window
+     *  protected — never a synchronous external-store delete). Reaper-driven; SQL twins only. */
     sweepOrphanBlobs?(): Promise<number>;
-    /** The subset of `hashes` already present — a cheap SQL INDEX probe (BOTH backends). Used by the §10 import
-     *  blob-presence pre-check (a HEAD/index check, NOT N full getBlob GETs). The durable twins carry it; optional. */
+    /** 2c blob negotiation: upload one content-addressed blob ahead of importHistory. SQL twins only. */
+    putBlob?(hash: string, bytes: Uint8Array): Promise<import("@sema-agent/core").FileHistoryResult>;
+    /** 2c blob read face (scope-checked by the route against the session's history graph). SQL twins only. */
+    getBlob?(hash: string): Promise<Uint8Array | undefined>;
+    /** The subset of `hashes` already present — a cheap SQL INDEX probe (the import presence pre-check,
+     *  never N full getBlob GETs). SQL twins only. */
     hasBlobs?(hashes: string[]): Promise<Set<string>>;
 };
 /** SVC-2 (core CORE-7) WorkflowJournalStore — core's interface PLUS the service `deleteByRun` (GC extra). tidb/pg =
@@ -159,9 +165,38 @@ export interface StoreBackend {
     /** E6 durable SessionPolicyStore (operator-tightened per-session tool rules). REQUIRED on all backends — works local
      *  (local = core's InMemorySessionPolicyStore), like resumeAnchor. Backs core's RunnerDeps.sessionPolicyStore. */
     sessionPolicy(): ServiceSessionPolicyStore;
-    /** E19 rewind-files FileSnapshotStore (working-tree snapshot/restore keyed by entryId; also the 2c artifact-transfer
-     *  store). REQUIRED on all backends (local = core's InMemoryFileSnapshotStore). Backs core's RunnerDeps.fileSnapshotStore. */
-    fileSnapshot(): ServiceFileSnapshotStore;
+    /** S-15 per-edited-file rewind FileHistoryStore (trackEdit/annulTrack/snapshot/restore over the tracked set;
+     *  also the 2c history-transfer store). REQUIRED on all backends (local = core's file-backed
+     *  `FileFileHistoryStore` under the data root). Backs core's RunnerDeps.fileHistoryStore. */
+    fileHistory(): ServiceFileHistoryStore;
+    /** design/383 §3.1 / S-50 §一(S-49 S-2):per-principal **memory-capture opt-out 授权表**
+     *  (`memory_optout_grant`)—— `RuntimeCaps.allowMemoryOptOut` 的本地 verdict 源(三层折叠:per-principal
+     *  行 → 部署缺省哨兵行 → 代码缺省 allow)+ `/v1/admin/memory-optout` 四端点的持久层。
+     *
+     *  🔴 **可选**(与 permissionRule 同族):SQL 后端 = 双方言 twin;`local` 车道 **undefined**,且缺席是一个
+     *  真答案 —— 没有 verdict 源时 `allowMemoryOptOut` 键不合成(core 读「无 per-principal 限制」,`open` 姿态
+     *  下 opt-out 照常生效),而 `MEMORY_CAPTURE_POLICY=governed` 在启动期对无源部署拒启
+     *  (`boot/runtime-caps.ts` `assertMemoryCapturePolicyWirable`)。刻意**不给 local 一个 in-memory twin**:
+     *  一条授权行是「operator 写下的合规事实」,进程内 Map 会在重启时静默丢掉它,下一次解析读到的是
+     *  「没有行 ⇒ 代码缺省 allow」—— 那是**放宽面**上的静默降级(permissionRule 那条禁令的同一理由)。
+     *  File 形候真实的 local+governed 部署需求出现再落(候需求档)。 */
+    memoryOptOutGrant(): MemoryOptOutGrantStore | undefined;
+    /** S-1 legacy-epoch discriminant (core `RunnerDeps.legacyRewindBoundaryProbe`): does the RETIRED whole-tree
+     *  snapshot epoch hold a boundary for (sessionId, entryId)? Reads the legacy `snapshot_manifest` table.
+     *  SQL backends only (local never had a whole-tree epoch table). Diagnostic input on the refusal path —
+     *  a probe that cannot tell answers undefined (reads exactly like an absent probe), never throws. */
+    legacyRewindBoundaryProbe?(query: {
+        sessionId: string;
+        entryId: string;
+    }): Promise<boolean | undefined>;
+    /** Retired-epoch byte hygiene: GC grace-passed orphan `snapshot_blob` rows/objects (rows the retention
+     *  lane's `snapshot_manifest` sweeps keep orphaning — without this leg their BYTES would outlive every
+     *  manifest reference forever, incl. MinIO objects). SQL backends only; reaper-driven. */
+    legacySnapshotBlobSweep?(): Promise<number>;
+    /** Retired-epoch right-to-delete: drop the session's LEGACY `snapshot_manifest` rows on the online E21
+     *  purge (the retention lane already sweeps them on expiry — the two delete legs must converge on the
+     *  same row set; a user's DELETE must reach old-epoch data too). Bytes go via the async legacy sweep. */
+    legacySnapshotPurge?(sessionId: string): Promise<number>;
     /** SVC-2 (core CORE-7) durable WorkflowJournalStore — the cross-replica resume journal for an LLM-authored workflow
      *  (RunWorkflowOptions.journalStore). REQUIRED on all backends (tidb/pg = durable twins; local = core's
      *  InMemoryWorkflowJournalStore, single-replica/in-process).
@@ -212,6 +247,14 @@ export interface StoreBackend {
      * 缺席 ⇒ endpoint 落到显式的单副本内存降级臂(见 `leader/endpoint.ts` 的 store 缺席注)。
      */
     leaderRun?(): LeaderRunStore;
+    /**
+     * device lane 的四表店(device-executor-lane-v2 §6,车A-2 交店 / 车A-4 接线)。**SQL 后端专有**,
+     * `local` 刻意省略 —— 与 {@link leaderRun} 逐字同一条理由:config 层已经把「`REMOTE_EXEC=device` 且
+     * 无外部 SQL 店」整个组合拒启了(`device-durable-store` 不变量),所以 local 车道上根本不存在一个需要
+     * 这四张表的 device worker。消费点按 `backend?.device?.()` 取,缺席 ⇒ `boot/device-lane.ts` 的
+     * `assertDeviceLaneWired` 响亮拒启(**不是**静默落进程内 stub)。
+     */
+    device?(): DeviceStore;
     /**
      * #270 —— 托管留存的**破坏性**三方法(core `ManagedRetentionCapability` 的 server 侧真身)。
      * **SQL 后端专有**,`local` 刻意省略:那三条腿是跨十余张表的单事务级联,file/in-memory 形没有事务面
@@ -252,17 +295,13 @@ export interface StoreBackend {
      *  splits a fleet window into disjoint buckets = soft-limit leak). OPTIONAL: local backend omits (no fleet). */
     dbNowMs?(): Promise<number>;
 }
-/** (c)(clay 拍 a+c,2026-07-27)云形快照 blob 姿势门——boot 时调用(main.ts),纯函数可单测。
- *  SQL 后端(mysql|pg)把 blob 字节落 `snapshot_blob` 单行的形已被两役实证撞 mysql-协议包墙
- *  (D-1 附件 → 对象存储裁定;snapshot_blob >31MiB 同墙):大字节归对象存储。云形缺 MinIO ⇒
- *  fail-loud(启动了才是假安全);`SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true` = 显式接受 SQL 店 +
- *  per-blob 帽(单机/测试台形)。local 后端不经此门(file/in-memory 快照店,无 SQL 包墙)。 */
+/** (c)(clay 拍 a+c,2026-07-27;S-15 换店后域=file_history_blob,门与旋钮名不变)云形 blob 姿势门——
+ *  boot 时调用(boot/stores.ts),纯函数可单测。SQL 后端(mysql|pg)把 blob 字节落单行的形已被两役
+ *  实证撞 mysql-协议包墙(D-1 附件 → 对象存储裁定):大字节归对象存储。per-file 历史的 blob=单文件
+ *  字节,同一堵墙(>6MiB 的被 track 文件在 TiDB 上落不进 SQL 行 ⇒ trackEdit 拒 ⇒ 默认 DV-14 下该次
+ *  编辑被拒)。云形缺 MinIO ⇒ fail-loud(启动了才是假安全);`SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true` =
+ *  显式接受 SQL 店 + per-blob 帽(单机/测试台形)。local 后端不经此门(file 店,无 SQL 包墙)。 */
 export declare function assertCloudSnapshotBlobPosture(kind: "mysql" | "pg" | "local", config: Pick<ServiceConfig, "snapshotBlobStore" | "snapshotBlobAllowSql">): void;
-/** REWIND_SNAPSHOT_MAX_MB overrides ONLY the byte cap of core's DEFAULT_SNAPSHOT_BOUNDS (raise for
- *  big monorepos, lower for tight DBs). File-count / ignoreDirs stay core defaults — the knob answers the one
- *  field the 20G-workspace case needed; more knobs when a case shows up. Exported for tests
- *  (fractional-MB rounding + partial-merge semantics need a regression lock). */
-export declare function snapshotBoundsFromConfig(config: ServiceConfig): FileSnapshotBounds;
 /**
  * 启动日志里「跨副本 or 进程内」那一格的标签。
  *

package/dist/plugins/store-backend.js

@@ -1,22 +1,23 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { AdoptionError, FileStorageBackend, FileSessionRepo, DEFAULT_SNAPSHOT_BOUNDS } from "@sema-agent/core";
+import { AdoptionError, FileStorageBackend, FileSessionRepo } from "@sema-agent/core";
 import { FileWorkflowJournalStore } from "@sema-agent/core";
 import { TiDBOutcomeLedger, PgOutcomeLedger } from "./outcome-ledger-sql.js";
 import { FileOutcomeSink } from "./file-outcome-sink.js";
 import { TiDBWorkflowRunStore, TiDBWorkflowCompletionInbox, TiDBWorkflowNotifyJournalStore, PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore } from "./workflow-run-store-sql.js";
-import { FileRunStore } from "./file-run-store.js";
+import { FileRunStore, RunStoreStrictHydrateError } from "./file-run-store.js";
 import { LocalSessionStore } from "./local-session-store.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";
 import { TiDBApprovalAskStore, PgApprovalAskStore } from "./approval-ask-store-sql.js";
 import { InMemoryApprovalAskStore } from "./approval-ask-store-memory.js";
+import { TiDBMemoryOptOutGrantStore, PgMemoryOptOutGrantStore } from "./memory-optout-grant-store-sql.js";
 import { TiDBSendFileLedger, PgSendFileLedger, FileSendFileLedger } from "./send-file-ledger.js";
 import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 import { TiDBSessionPolicyStore, PgSessionPolicyStore } from "./session-policy-store-sql.js";
 import { TiDBWorkflowJournalStore, PgWorkflowJournalStore } from "./workflow-journal-store-sql.js";
-import { TiDBFileSnapshotStore, PgFileSnapshotStore } from "./file-snapshot-store-sql.js";
+import { TiDBFileHistoryStore, PgFileHistoryStore, FILE_HISTORY_BLOB_TABLE, FILE_HISTORY_BLOB_KEY_PREFIX } from "./file-history-store-sql.js";
 import { MinioBlobBackend, SqlBlobBackend } from "./blob-backend.js";
 import { createTidbPool, ensureSchema as ensureTidbSchema } from "./tidb-pool.js";
 import { createPgPool, ensurePgSchema, pgPoolOptions } from "./pg-pool.js";
@@ -26,6 +27,7 @@ import { TiDBToolResultStore, PgToolResultStore } from "./tool-result-store-sql.
 import { TiDBImageIndex, PgImageIndex } from "./image-index-sql.js";
 import { TiDBImageBake, PgImageBake } from "./image-bake-store-sql.js";
 import { TiDBLeaderRunStore, PgLeaderRunStore } from "./leader-run-store-sql.js";
+import { TiDBDeviceStore, PgDeviceStore } from "./device-store-sql.js";
 import { TiDBBreakerState, PgBreakerState } from "./breaker-state-sql.js";
 import { TiDBCostQuota } from "./tidb-cost-quota.js";
 import { PgCostQuota } from "./pg-cost-quota.js";
@@ -40,7 +42,21 @@ import { TiDBRetentionLaneStore, PgRetentionLaneStore } from "./retention-lane-s
 import { createSqlPermissionRuleStores } from "./permission-rule-store-sql.js";
 import { createFilePermissionRuleStores } from "./permission-rule-store-file.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
-function snapshotBlobBackend(config, dialect, pool) {
+function historyBlobBackend(config, dialect, pool) {
+    const s = config.snapshotBlobStore;
+    if (!s)
+        return new SqlBlobBackend(dialect, pool, config.snapshotBlobSqlMaxBytes, FILE_HISTORY_BLOB_TABLE);
+    return new MinioBlobBackend({
+        endpoint: s.endpoint,
+        bucket: s.bucket,
+        accessKey: s.accessKey,
+        secretKey: s.secretKey,
+        ...(s.region ? { region: s.region } : {}),
+        keyPrefix: `${s.keyPrefix ?? ""}${FILE_HISTORY_BLOB_KEY_PREFIX}`,
+        ...(s.presignTtlSec ? { presignTtlSec: s.presignTtlSec } : {}),
+    }, { dialect, pool, table: FILE_HISTORY_BLOB_TABLE });
+}
+function legacyBlobBackend(config, dialect, pool) {
     const s = config.snapshotBlobStore;
     if (!s)
         return new SqlBlobBackend(dialect, pool, config.snapshotBlobSqlMaxBytes);
@@ -54,18 +70,51 @@ function snapshotBlobBackend(config, dialect, pool) {
         ...(s.presignTtlSec ? { presignTtlSec: s.presignTtlSec } : {}),
     }, { dialect, pool });
 }
+async function legacyProbeImpl(dialect, pool, query) {
+    try {
+        if (dialect === "tidb") {
+            const [rows] = await pool.query("SELECT 1 FROM snapshot_manifest WHERE scope = ? AND snap_key = ? LIMIT 1", [query.sessionId, query.entryId]);
+            return rows.length > 0;
+        }
+        const r = await pool.query("SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1", [query.sessionId, query.entryId]);
+        return r.rows.length > 0;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function legacyPurgeImpl(dialect, pool, sessionId) {
+    if (dialect === "tidb") {
+        const [r] = await pool.query("DELETE FROM snapshot_manifest WHERE scope = ?", [sessionId]);
+        return Number(r.affectedRows ?? 0);
+    }
+    const r = await pool.query("DELETE FROM snapshot_manifest WHERE scope = $1", [sessionId]);
+    return r.rowCount ?? 0;
+}
+async function legacySweepImpl(config, dialect, pool) {
+    const sql = "SELECT blob_hash FROM snapshot_blob WHERE blob_hash NOT IN (SELECT blob_hash FROM snapshot_manifest)";
+    let orphans;
+    if (dialect === "tidb") {
+        const [rows] = await pool.query(sql);
+        orphans = rows.map((r) => String(r.blob_hash));
+    }
+    else {
+        const r = await pool.query(sql);
+        orphans = r.rows.map((row) => row.blob_hash);
+    }
+    if (orphans.length === 0)
+        return 0;
+    return legacyBlobBackend(config, dialect, pool).deleteBlobs(orphans);
+}
 export function assertCloudSnapshotBlobPosture(kind, config) {
     if (kind === "local" || config.snapshotBlobStore || config.snapshotBlobAllowSql)
         return;
-    throw new Error("cloud deployments (DB_BACKEND=mysql|pg) must configure object storage for snapshot blobs " +
+    throw new Error("cloud deployments (DB_BACKEND=mysql|pg) must configure object storage for rewind file-history blobs " +
         "(MINIO_ENDPOINT/MINIO_ACCESS_KEY/MINIO_SECRET_KEY): single-row SQL blob writes hit TiDB's " +
         "txn-entry-size-limit (default 6MiB) / the mysql-protocol packet limit (bytes belong in object storage — " +
         "same ruling as the D-1 attachment store). Single-box/test rigs may explicitly opt out with " +
-        "SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true (a per-blob cap then applies; oversized blobs are rejected 413).");
-}
-export function snapshotBoundsFromConfig(config) {
-    const mb = config.rewindSnapshotMaxMb;
-    return mb !== undefined ? { ...DEFAULT_SNAPSHOT_BOUNDS, maxBytes: Math.round(mb * 1024 * 1024) } : DEFAULT_SNAPSHOT_BOUNDS;
+        "SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true (a per-blob cap then applies; an over-cap tracked file's first-touch " +
+        "backup is refused typed, which under the default DV-14 policy refuses that edit).");
 }
 class TiDBBackend {
     pool;
@@ -84,7 +133,11 @@ class TiDBBackend {
     permissionRule() { return createSqlPermissionRuleStores(mysqlDriver(this.pool)); }
     sendFileLedger() { return new TiDBSendFileLedger(this.pool); }
     sessionPolicy() { return new TiDBSessionPolicyStore(this.pool); }
-    fileSnapshot() { return new TiDBFileSnapshotStore(this.pool, snapshotBlobBackend(this.config, "tidb", this.pool), snapshotBoundsFromConfig(this.config)); }
+    fileHistory() { return new TiDBFileHistoryStore(this.pool, historyBlobBackend(this.config, "tidb", this.pool), this.config.fileHistory); }
+    memoryOptOutGrant() { return new TiDBMemoryOptOutGrantStore(this.pool); }
+    legacyRewindBoundaryProbe(query) { return legacyProbeImpl("tidb", this.pool, query); }
+    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "tidb", this.pool); }
+    legacySnapshotPurge(sessionId) { return legacyPurgeImpl("tidb", this.pool, sessionId); }
     workflowJournal() { return new TiDBWorkflowJournalStore(this.pool); }
     outcomeSink() { return new TiDBOutcomeLedger(this.pool); }
     workflowRun(onWarn) { return new TiDBWorkflowRunStore(this.pool, onWarn); }
@@ -96,6 +149,7 @@ class TiDBBackend {
     imageIndex() { return new TiDBImageIndex(this.pool); }
     imageBake() { return new TiDBImageBake(this.pool); }
     leaderRun() { return new TiDBLeaderRunStore(this.pool); }
+    device() { return new TiDBDeviceStore(this.pool); }
     retention(opts) { return new TiDBRetentionStore(this.pool, opts); }
     retentionLane() { return new TiDBRetentionLaneStore(this.pool); }
     breaker(onWriteFail) { return new TiDBBreakerState(this.pool, onWriteFail); }
@@ -124,7 +178,11 @@ class PgBackend {
     permissionRule() { return createSqlPermissionRuleStores(pgDriver(this.pool)); }
     sendFileLedger() { return new PgSendFileLedger(this.pool); }
     sessionPolicy() { return new PgSessionPolicyStore(this.pool); }
-    fileSnapshot() { return new PgFileSnapshotStore(this.pool, snapshotBlobBackend(this.config, "pg", this.pool), snapshotBoundsFromConfig(this.config)); }
+    fileHistory() { return new PgFileHistoryStore(this.pool, historyBlobBackend(this.config, "pg", this.pool), this.config.fileHistory); }
+    memoryOptOutGrant() { return new PgMemoryOptOutGrantStore(this.pool); }
+    legacyRewindBoundaryProbe(query) { return legacyProbeImpl("pg", this.pool, query); }
+    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "pg", this.pool); }
+    legacySnapshotPurge(sessionId) { return legacyPurgeImpl("pg", this.pool, sessionId); }
     workflowJournal() { return new PgWorkflowJournalStore(this.pool); }
     outcomeSink() { return new PgOutcomeLedger(this.pool); }
     workflowRun(onWarn) { return new PgWorkflowRunStore(this.pool, onWarn); }
@@ -136,6 +194,7 @@ class PgBackend {
     imageIndex() { return new PgImageIndex(this.pool); }
     imageBake() { return new PgImageBake(this.pool); }
     leaderRun() { return new PgLeaderRunStore(this.pool); }
+    device() { return new PgDeviceStore(this.pool); }
     retention(opts) { return new PgRetentionStore(this.pool, opts); }
     retentionLane() { return new PgRetentionLaneStore(this.pool); }
     breaker(onWriteFail) { return new PgBreakerState(this.pool, onWriteFail); }
@@ -166,7 +225,7 @@ class LocalBackend {
         try {
             this.fileBackend = new FileStorageBackend({
                 root,
-                ...(config.rewindSnapshotMaxMb !== undefined ? { snapshotBounds: { maxBytes: Math.round(config.rewindSnapshotMaxMb * 1024 * 1024) } } : {}),
+                ...(config.fileHistory !== undefined ? { fileHistory: config.fileHistory } : {}),
                 onCorruptRead: (info) => this.onWarn?.("file_store_corrupt_read", {
                     path: info.path,
                     reason: info.reason,
@@ -175,7 +234,7 @@ class LocalBackend {
                     note: "a durable read was treated as ABSENT because the bytes were unreadable (never a plain ENOENT). " +
                         "Consequence depends on which store read it: session-policy = that run lost its SUBTRACTIVE session-rule " +
                         "layer (deployment policy / hooks / shell gate still applied); session repo = a listing silently omitted " +
-                        "rows; file-snapshot = a snapshot or scope read as missing. Inspect the named path before deciding.",
+                        "rows; file-history = a rewind boundary or scope read as missing. Inspect the named path before deciding.",
                 }),
             });
         }
@@ -188,6 +247,7 @@ class LocalBackend {
         this.sessionStore = new LocalSessionStore(new FileSessionRepo(this.fileBackend.root), this.fileBackend.root);
         this.runStore = new FileRunStore(this.fileBackend.root, {
             error: (msg, fields) => void (this.onError ?? this.onWarn)?.(msg, fields),
+            strictHydrate: config.runStoreStrictHydrate,
         });
         this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root);
         this.approvalExemptionStore = new FileApprovalExemptionStore(this.fileBackend.root);
@@ -237,7 +297,8 @@ class LocalBackend {
     }
     checkpointStoreInst;
     sessionPolicy() { return this.fileBackend.sessionPolicyStore; }
-    fileSnapshot() { return this.fileBackend.fileSnapshotStore; }
+    fileHistory() { return this.fileBackend.fileHistoryStore; }
+    memoryOptOutGrant() { return undefined; }
     workflowJournal() { return this.workflowJournalStore; }
     outcomeSink() { return this.outcomeSinkInst; }
     session() { return this.sessionStore; }
@@ -272,6 +333,8 @@ export async function openStoreBackendWithFallback(config, logger) {
     catch (err) {
         if (err instanceof AdoptionError)
             throw err;
+        if (err instanceof RunStoreStrictHydrateError)
+            throw err;
         if (!mayFallback)
             throw err;
         logger.warn("store_db_unreachable_fallback_memory", {

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

@@ -30,9 +30,11 @@ export interface RunRecord {
     /** Which SYSTEM's credential submitted the run (oa/cc-mcp/portal…), derived at the auth gate — never
      *  self-declared. null = legacy single-token deployment (authenticated, no system identity). */
     source: string | null;
-    /** The replica that OWNS this run (the instanceId that created it). Lets a preempt/cancel handler tell
-     *  "this run is on MY replica" (consult the in-process inflight/preemptable map authoritatively) from "owned
-     *  elsewhere" (fall back to the durable cross-replica flag). null for pre-column rows. */
+    /** The replica currently HOLDING this run — written at createRun and TAKEN OVER by markResuming (S-51: a
+     *  cross-replica resume moves the seat, so a reader comparing it with its own instanceId is asking "is the
+     *  live leg here NOW", not "who minted the row"). Lets a preempt/cancel/steer handler tell "this run is on
+     *  MY replica" (consult the in-process inflight/steerable map authoritatively) from "held elsewhere" (fall
+     *  back to the durable cross-replica flag). null for pre-column rows. */
     instanceId: string | null;
     /** First ~120 chars of the objective (secret-redacted at write) — the list's "what is this task" glance.
      *  null for rows predating the column. */

package/dist/plugins/task-list-store-sql.d.ts

@@ -33,7 +33,7 @@ export declare function ensurePgTaskListSchema(q: (text: string, params?: unknow
  * 语义 = 「这个 listKey 的清单**不存在过**」:item 行 + meta 行(高水位 `next_id` / 插入序
  * `next_sort`)一并抹掉。⚠️ **meta 行必须一起删**:留着它,同一个 listKey 被重新登记后
  * (会话 id 由调用方自选、删除后可被别人 `register`)新主的第一条任务会从旧主的高水位续号 ——
- * 那是一条跨化身的信息泄漏(「上一位在这里建过 47 条」)。
+ * 那是一条跨化身的信息外泄(「上一位在这里建过 47 条」)。
  *
  * 事务内先对 meta 行 `FOR UPDATE`(与 `mutate` 同一把分区锁)⇒ 与并发的清单写串行,不会删到
  * 一半被插回新行。meta 行不在(从未写过任何任务)= 无锁可拿,DELETE 命中 0 行,幂等。