@sema-agent/server 7.139.0 → 7.141.0

package/dist/plugins/schema-ensure-legs.d.ts

@@ -1,6 +1,5 @@
 import type { PgQueryFn } from "./pg-query.js";
-/** 录制的方言。`mysql` = MySQL 协议(TiDB / InnoDB 同腿),`pg` = PostgreSQL。 */
-export type SchemaDialect = "mysql" | "pg";
+import type { SqlDialect } from "./sql-driver.js";
 /** advisory lock 语句 —— 与 schema 无关,录制时跳过(但要答成功,否则 ensure* 走降级告警路径)。 */
 export declare const LOCK_RE: RegExp;
 /**
@@ -51,5 +50,5 @@ export declare const DRIVEN_ENSURES: {
     readonly pg: readonly string[];
 };
 /** 跑一遍一条方言的真 `ensure*` 全腿,返回**录制到的语句流**(顺序即执行顺序)。纯内存,不碰数据库。 */
-export declare function recordEnsureStatements(dialect: SchemaDialect): Promise<string[]>;
+export declare function recordEnsureStatements(dialect: SqlDialect): Promise<string[]>;
 //# sourceMappingURL=schema-ensure-legs.d.ts.map

package/dist/plugins/schema-ensure-legs.js

@@ -6,10 +6,10 @@ import { ensurePgMemoryEmbedderMetaSchema } from "./memory-embedder-fingerprint.
 import { ensureTiDBMemorySyncSchema, ensureTiDBMemoryHistorySchema } from "./memory-sync-store-tidb.js";
 import { ensurePgMemorySyncSchema, ensurePgMemoryHistorySchema } from "./memory-sync-store-pg.js";
 import { ensureTiDBRosterSchema, ensurePgRosterSchema } from "./roster-store-sql.js";
-import { ensureTiDBBackgroundAgentSchema, ensurePgBackgroundAgentSchema } from "./background-agent-store-sql.js";
+import { ensureTiDBBackgroundAgentSchema, ensurePgBackgroundAgentSchema } from "../stores-sql/background-agent-store-sql.js";
 import { ensureTiDBMailboxSchema, ensurePgMailboxSchema } from "./mailbox-store-sql.js";
 import { ensureTiDBTaskAttachmentSchema, ensurePgTaskAttachmentSchema } from "./task-attachment-store.js";
-import { ensureTiDBUsageWindowSchema, ensurePgUsageWindowSchema } from "./usage-window-store-sql.js";
+import { ensureTiDBUsageWindowSchema, ensurePgUsageWindowSchema } from "../stores-sql/usage-window-store-sql.js";
 import { ensureTiDBTaskListSchema, ensurePgTaskListSchema } from "./task-list-store-sql.js";
 import { ensureTiDBDeviceSchema, ensurePgDeviceSchema } from "./device-store-sql.js";
 export const LOCK_RE = /GET_LOCK|RELEASE_LOCK|pg_(try_)?advisory/i;

package/dist/plugins/schema-live-columns.d.ts

@@ -3,7 +3,7 @@
  * 缺这条索引的列」也读它)。叶子模块:不值依赖任何模块(列册探针那边经录制驱动 / 建表腿值依赖 `ensure-index.ts`,读者若住在那边,
  * `ensure-index.ts` 读它就是一个运行时环)。方言词是 `ensure-index.ts` 的闭集(类型边,擦除)。
  */
-import type { SqlDialect } from "./ensure-index.js";
+import type { SqlDialect } from "./sql-driver.js";
 /** 探针读口:一条 SQL → 行数组(两方言由调用方各自绑)。 */
 export type SchemaProbeRead = (sql: string) => Promise<Array<Record<string, unknown>>>;
 /**

package/dist/plugins/session-capture-record-store-sql.js

@@ -83,7 +83,7 @@ export class SqlSessionCaptureRecordStore {
 }
 export class TiDBSessionCaptureRecordStore extends SqlSessionCaptureRecordStore {
     constructor(pool) {
-        super(mysqlDriver(pool), "tidb");
+        super(mysqlDriver(pool), "mysql");
     }
 }
 export class PgSessionCaptureRecordStore extends SqlSessionCaptureRecordStore {

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

@@ -25,7 +25,8 @@ export declare function assertFirstOwnerWritable(sessionId: string, owner: unkno
 /**
  * 导入者的属主 —— 换装的写腿(公开 `importEntries` / `replaceEntries` 与暂存提交)把调用方给的属主重戳进会话行之前的唯一读法:
  * 主体名或 `null`(匿名)⇒ 原样交回;别的一切(空串、空白串、带控制 / 分隔 / 非连接符格式字符的串、非串)⇒ `TypeError` 响亮拒 ——
- * 与引擎导入口拒同一类值时同一类错、同一句开头(引擎那一判只作用于交给它的属主,而换装交给引擎的是存档自己的戳,所以这一判在本仓)。
+ * 与引擎导入口拒同一类值时同一类错、同一句开头(引擎那一判只作用于交给它的属主,而 local 店交给引擎仓的属主恒缺席 —— 引擎仓是匿名内容仓,属主只在本店的行上 ——
+ * 所以这一判在本仓)。
  * 调用方在读写任何东西之前判,拒了就一个字节没写。判官 = {@link isSessionOwnerValue}(core `principalNameOf`),不在本仓另写规则。
  */
 export declare function importerOwnerOf(owner: unknown): string | null;

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

@@ -1,6 +1,6 @@
 /**
  * [ref] C18(core 5.48.0 [ref]「不造新店」提货批,黑板 [ref] 点名义务)——**subagent 转录持久化**
- * 的 placement 语义,SQL 孪生共用的一份判据。
+ * 的 placement 语义,三只会话店(SQL 两孪生 + local)共用的一份声明与判据。
  *
  * ## 这是什么
  *
@@ -35,16 +35,29 @@
  */
 import { type PlacedSessionRow, type SessionPlacement, type SessionPlacementRecord, type SessionStore } from "@sema-agent/core";
 /**
- * 两支 SQL 孪生的 placement **声明**(core `SessionStore.placements`)。
+ * 三只持久会话店(SQL 两孪生 + local 后端)的**会话耐久声明**(core `SessionStore.durability`:未 placed 的会话活不活过进程重启)——
+ * **单源**:三处声明(两孪生类上的顶层 `durability`、`LocalBackend` 交给店的顶层 `durability`)与委派分区的 {@link SESSION_PLACEMENTS}
+ * 引用的都是这一只常量,源码里不再有第二份 `"durable"` 字面(`test/session-store-durability-declaration.test.ts` 的 AST 钉)。
+ *
+ * 为什么必须声明:core 的静态装配对**缺席**折 `"process-local"`(它不能替没表态的店猜),接线清单 `session.store` 与起服自检读的就是它 ——
+ * 不声明 ⇒ 一个真持久的 SQL 部署读成「重启即丢」,没有任何一处报错。依据同下面分区声明那一段:两孪生的会话史落在 `session_meta` + `session_event` 两张真表,
+ * local 的会话史落在数据根下的会话存档,进程重启后都能把已有会话取回来。包装层(缓存层)逐字转发;fork 路由层不声明(它自己的未 placed 会话住进程内短 TTL 店,
+ * 顶层耐久只说未 placed 的会话——见 `fork-routing-session-store.ts` 头注)。
+ */
+export declare const SESSION_DURABILITY: "durable";
+/**
+ * 三只持久会话店的 placement **声明**(core `SessionStore.placements`):两支 SQL 孪生(类上的字段)与 local 后端
+ * (`LocalBackend` 装配 `LocalSessionStore` 时交进去 —— 值与 core `FileStorageBackend` 对同一种文件 repo 的声明同)。
  *
  * 🔴 声明制,不是鸭子类型:core 的铸造门判「row store ∧ session 店声明」,不声明的店**不收** placed
  * 语义(合法降级:placement 参数被忽略,会话就是普通会话)。所以这一格只有在上面六条义务**全部**在
  * 本店实装之后才允许存在——它是一句关于本店行为的承诺,不是一个功能开关。
  * `durable` 的依据:两支孪生的会话史落在 `session_meta`+`session_event` 两张真表上,进程重启后
  * `acquire(id,{requireExisting:true})` 从事件日志重放(义务 1 的机器证在
- * `test/session-placement-db-integration.test.ts` 的跨进程复活格)。
+ * `test/session-placement-db-integration.test.ts` 的跨进程复活格);local 的会话史落在数据根下的会话存档
+ * (元组在存档行头),属主与化身在同一数据根的会话元数据边档(机器证在 `test/local-session-placement.test.ts` 的重启格)。
  */
-export declare const SQL_SESSION_PLACEMENTS: {
+export declare const SESSION_PLACEMENTS: {
     readonly subagent: {
         readonly durability: "durable";
     };

package/dist/plugins/session-placement.js

@@ -1,5 +1,6 @@
 import { SessionError } from "@sema-agent/core";
-export const SQL_SESSION_PLACEMENTS = { subagent: { durability: "durable" } };
+export const SESSION_DURABILITY = "durable";
+export const SESSION_PLACEMENTS = { subagent: { durability: SESSION_DURABILITY } };
 export const PLACEMENT_SELECT_COLUMNS = "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at";
 function toEpochMs(v) {
     if (v == null)

package/dist/plugins/session-rules-column.d.ts

@@ -10,7 +10,7 @@
  */
 export declare const SESSION_RULES_COLUMN: {
     readonly name: "rule_entries";
-    readonly tidb: "rule_entries JSON NOT NULL";
+    readonly mysql: "rule_entries JSON NOT NULL";
     readonly pg: "rule_entries JSONB NOT NULL";
 };
 //# sourceMappingURL=session-rules-column.d.ts.map

package/dist/plugins/session-rules-column.js

@@ -1,6 +1,6 @@
 export const SESSION_RULES_COLUMN = {
     name: "rule_entries",
-    tidb: "rule_entries JSON NOT NULL",
+    mysql: "rule_entries JSON NOT NULL",
     pg: "rule_entries JSONB NOT NULL",
 };
 //# sourceMappingURL=session-rules-column.js.map

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

@@ -1,7 +1,7 @@
 import { type SessionStore } from "@sema-agent/core";
 import type { ServiceConfig } from "../config-types.js";
 import type { StoreBackend } from "./store-backend.js";
-import { type DelegationRootWitness, type DelegationTree, type OrphanOwnerLog } from "../delegated-session-owner.js";
+import { type DelegationRootWitness, type OrphanOwnerLog } from "../delegated-session-owner.js";
 import type { OwnerAwareSessionStore } from "../security.js";
 /**
  * Session-store plugin seam.
@@ -37,31 +37,29 @@ export declare function createSessionStore(config: Pick<ServiceConfig, "sessionB
  * (`evictPolicy="delete"`)。本函数自己**不做**、也无法通用地做"这个 store 实例的 release 是否安全"的
  * 判别(`SessionStore` 接口没有暴露这个信息,类型层面区分不了两种店形)——上文"误判方向永远偏保守"
  * 只覆盖 `getLeafId` 那道校验,不覆盖"传了一个 release=delete 的店进来"这个前提违反。**调用方必须
- * 保证只在真正 durable(release 非破坏性)的店上调用本函数**——server 侧的强制点在 main.ts 装配区:
- * `ensureChildSessionDurable` 闭包只在 `config.sessionBackend === "tidb"` 时构造。
+ * 保证只在真正 durable(release 非破坏性)的店上调用本函数**——server 侧的强制点在 stage-07 装配区:
+ * `ensureChildSessionDurable` 闭包只在部署的子代转录档位是 `full` 时构造(core `resolveSubagentTranscriptTier`:会话店声明了 durable 的委派分区 ——
+ * 三只持久会话店;无 repo 的内存店不声明,档位不是 `full`,挂点不装)。
  */
 export declare function ensureSessionDurable(hostStore: SessionStore, sessionId: string): Promise<void>;
 /**
- * [ref] 主动晋升版 ensureChildSessionDurable(cli TiDB 真机撞获:1.263 的只查不迁形在拆店生产形下
- * 恒否决 park——bg 子会话住 subRunner 私有 TTL 店、从不在 host 店,core 收 veto 即 expire checkpoint
- * (14ms~2s)+ settle failed,赎回窗口不存在):
- *   0. 属主([ref],`delegated-session-owner.ts`):按委派继承律判一次(唯一判据 `judgeDelegatedOwner`)—— 来源集 = 见证的根这一只(调用方交出的委派树根 + 调用方判断那一刻
+ * core `SubagentToolOptions.background.ensureChildSessionDurable` 的实现体 —— 停驻挂点的**见证**:这只后台子代的转录此刻是 host 店里一只有真内容、
+ * 属主按委派继承律定得下来的会话,才放行停驻;任何一步不成立 ⇒ 抛 = 否决(core 收 veto 即 expire checkpoint + settle failed,pre-153 行为,不放大)。
+ *
+ * 规则(`fork-routing-session-store.ts` 头注):一只后台子代的 durable 行在,它的转录就是 host 店委派分区里的一只 placed 行。挂点只装在声明了
+ * durable 委派分区的部署上(stage-07:core `resolveSubagentTranscriptTier(...) === "full"`),那里 core 给每只新起的后台子代铸 placement、
+ * 转录生来就在 host 店 —— 所以这里**只验、不搬**(此前的「晋升」把私店的转录整树拷进 host 店,随这条规则退役)。
+ *   0. 属主(`delegated-session-owner.ts`):按委派继承律判一次(唯一判据 `judgeDelegatedOwner`)—— 来源集 = 见证的根这一只(调用方交出的委派树根 + 调用方判断那一刻
  *      读到的根行住客:请求腿 = 本请求经鉴权解析的会话与受理时那一读,`/decide` 赎回腿 = 行上的 `rootSessionId` 与写口放行的那一位(认领之前解析器那一读);core 的挂点签名只给子代 id,
- *      场景层把见证绑进闭包交下来)。此刻根行在而住客不是见证的那一位(删了、同 id 被重新登记)⇒ **拒**(`assertRootStillWitnessed`:不按新住客晋升 / 认领);
+ *      场景层把见证绑进闭包交下来)。此刻根行在而住客不是见证的那一位(删了、同 id 被重新登记)⇒ **拒**(`assertRootStillWitnessed`);
  *      缺席(行上没有根)或根行此刻不在 ⇒ 孤行哨兵。
- *   1. 快路:已在 host 店且有真内容 → 通过,**前提是那一行的属主按律定得下来**(`settleDelegatedOwner`:记着别的委派树 ⇒ 抛;记着这一棵 ⇒ 按它记录的根、父再判一次
- *      (与 M23 同读数),无主 ⇒ 认领(CAS 子行,写判断时的读数)、没落下 ⇒ 抛(只有记录委派树的 SQL 店;local 店的行不记委派树 ⇒ 不认领);此刻属主不是律给的那一只 ⇒ 那是别人的同 id 会话,
- *      不是这只子代的转录 ⇒ 抛 = 停驻否决;与晋升建行前那一道同一只函数)。
- *   2. 晋升:routing.promoteToHost 把子会话整树从私店拷进 host 店(拷贝→私店 forget→路由记 host,
- *      三步见 ForkRoutingSessionStore.promoteToHost),宿主行在建行那一笔里带第 0 步的属主;写的是哨兵 ⇒ 写落下之后一行 warn。
- *   3. 复验:同一把 `ensureSessionDurable` 严检(leaf 非空)+ 同一只属主定夺 —— 晋升产物必须达到与快路完全相同的
- *      标准,任何一步失败=如实 reject=veto=pre-153 行为(不放大)。
+ *   1. 在不在、有没有真内容:{@link ensureSessionDurable}(`requireExisting` 打开 + 叶子非空 + forget 收尾)。任何失败(不在、空壳、读故障)⇒ 原样上抛 = 否决
+ *      (读故障也否决:说不准转录在不在,就不让一次审批押在它上面)。这里**不判它是不是 placed 行**:复活的是旧行时 id 取行上的会话(升级前停驻、当年晋升进来的普通行),
+ *      它照样是这只子代的转录;判据只问「host 店里有这份真内容」。
+ *   2. 属主定夺(`settleDelegatedOwner`):记着别的委派树 ⇒ 抛;记着这一棵 ⇒ 按它记录的根、父再判一次(与 M23 同读数),无主 ⇒ 认领(CAS 子行,写判断时的读数)、没落下 ⇒ 抛;
+ *      此刻属主不是律给的那一只 ⇒ 那是别人的同 id 会话,不是这只子代的转录 ⇒ 抛 = 停驻否决。认领写下的是哨兵 ⇒ 写落下之后一行 warn(`site: "park"`)。
  * 宿主店必须读得出属主(`delegatedOwnerHostOf`:`headOf`;记录委派树的店另交 `placementOf` + `claimOwnerless`,两只同在或同缺;生产的 SQL / local 店与缓存包装层都满足),
  * 否则响亮拒。
- * 调用方纪律与 {@link ensureSessionDurable} 同款:hostStore 必须是 release 非破坏性的真 durable 店
- * (stage-07 的 `config.sessionBackend === "tidb"` 门不变 —— 该词在 local 后端上同样归一成 `tidb`,所以本腿在 local 宿主店上也跑)。
  */
-export declare function ensureChildSessionDurableWithPromotion(hostStore: OwnerAwareSessionStore, routing: {
-    promoteToHost(sessionId: string, owner: string | null, tree: DelegationTree): Promise<void>;
-}, sessionId: string, root: DelegationRootWitness | undefined, log: OrphanOwnerLog): Promise<void>;
+export declare function attestChildSessionDurable(hostStore: OwnerAwareSessionStore, sessionId: string, root: DelegationRootWitness | undefined, log: OrphanOwnerLog): Promise<void>;
 //# sourceMappingURL=session-store.d.ts.map

package/dist/plugins/session-store.js

@@ -23,24 +23,16 @@ export async function ensureSessionDurable(hostStore, sessionId) {
         await hostStore.forget?.(acquired.sessionId);
     }
 }
-export async function ensureChildSessionDurableWithPromotion(hostStore, routing, sessionId, root, log) {
+export async function attestChildSessionDurable(hostStore, sessionId, root, log) {
     const host = delegatedOwnerHostOf(hostStore);
     if (host === undefined) {
         throw new Error(`session "${sessionId}" cannot be parked: the host session store cannot read a session's owner (headOf), or records delegation trees without being able to claim under them (placementOf / claimOwnerless), so the delegated transcript's owner cannot be derived or checked`);
     }
     const judged = await readDelegatedOwner(sessionId, root === undefined ? {} : { rootSessionId: root.sessionId }, sourceFacesVia(host.headOf));
     assertRootStillWitnessed(sessionId, root, judged);
-    let promoted = false;
-    try {
-        await ensureSessionDurable(hostStore, sessionId);
-    }
-    catch {
-        await routing.promoteToHost(sessionId, judged.inherited.owner, judged.tree);
-        await ensureSessionDurable(hostStore, sessionId);
-        promoted = true;
-    }
+    await ensureSessionDurable(hostStore, sessionId);
     const settled = await settleDelegatedOwner(host, sessionId, judged.inherited.owner, judged.tree);
-    if (promoted || settled.claimed)
-        reportWrittenOwner(log, "promotion", sessionId, settled.judged ?? judged);
+    if (settled.claimed)
+        reportWrittenOwner(log, "park", sessionId, settled.judged ?? judged);
 }
 //# sourceMappingURL=session-store.js.map

package/dist/plugins/session-workspace-cell.d.ts

@@ -3,7 +3,7 @@ import { type JsonColumnReader } from "./sql-json-column.js";
 /** 列定义的唯一属主(两方言 DDL 内插它;存量库缺这一列 ⇒ 起服列册对账拒启,拒句里的 ALTER 由建表语句生成)。 */
 export declare const SESSION_META_WORKSPACE_COLUMN: {
     readonly name: "workspace";
-    readonly tidb: "workspace JSON NULL";
+    readonly mysql: "workspace JSON NULL";
     readonly pg: "workspace JSONB";
 };
 /** 这一格的形读者(三只店与帧投影同一只;写前也过它 —— 写得进的就是读得出的)。 */

package/dist/plugins/session-workspace-cell.js

@@ -4,7 +4,7 @@ import { recordFailOpen } from "../observability/fail-open.js";
 import { assertJsonColumnWritable, createZodColumnReader, decodeJsonColumn, isJsonColumnBodyProblem } from "./sql-json-column.js";
 export const SESSION_META_WORKSPACE_COLUMN = {
     name: "workspace",
-    tidb: "workspace JSON NULL",
+    mysql: "workspace JSON NULL",
     pg: "workspace JSONB",
 };
 const SESSION_WORKSPACE_SHAPE = z.object({

package/dist/plugins/shared-memory-store-sql.js

@@ -106,8 +106,8 @@ export class SqlSharedMemoryStore {
         this.now = opts.now ?? Date.now;
         this.maxListLimit = opts.maxListLimit ?? DEFAULT_MAX_LIST_LIMIT;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async snapshot(ctx, opts) {
         throwIfAborted(opts.signal);

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

@@ -68,7 +68,7 @@
  * ─────────────────────────────────────────────────────────────────────────────────────────────────
  * Reference collapses: image-bake-store-sql.ts (class + transactions) and checkpoint-store-sql.ts
  * (class, no transactions). Function-style stores follow task-list-store-sql.ts instead (inline
- * `dialect === "tidb" ? … : …` ternaries, no driver object) — pick the shape the pair already has.
+ * `dialect === "mysql" ? … : …` ternaries, no driver object) — pick the shape the pair already has.
  *
  * STEPS
  *  1. Read BOTH twins end to end first. List every method and mark it identical / SQL-text-only /
@@ -79,7 +79,7 @@
  *  3. Per statement, write BOTH texts at the call site via a 2-arg `q(tidbSql, pgSql)` helper.
  *     Never build one text with a placeholder-numbering loop — the point is that a reviewer sees
  *     the two statements adjacent.
- *  4. Genuinely-divergent algorithms get an `if (dialect === "tidb") { … } else { … }` block with a
+ *  4. Genuinely-divergent algorithms get an `if (dialect === "mysql") { … } else { … }` block with a
  *     🔴 comment saying WHY both are correct. Never "unify" them by picking one engine's algorithm.
  *  5. Old files become thin re-export shims. Class names, ctor arity, exported constants/types and
  *     helper names stay EXACTLY as they were — consumers and tests must not move.
@@ -98,7 +98,7 @@
  *   (pgSafeJsonStringify / pgProtocolJsonStringify / pgSanitizeText / pgHasUnstorable) · DDL. Each arm's
  *   BEHAVIOR (what pgSafeJsonStringify/pgProtocolJsonStringify actually do to the bytes) stays written out
  *   in `pg-safe-json.ts`, untouched — `dialectJsonEncoder`/`dialectProtocolJsonEncoder` below ([ref]
- *   redesign①) only collect the identical `dialect === "tidb" ? JSON.stringify(v) : pgSafe…(v)` DISPATCH
+ *   redesign①) only collect the identical `dialect === "mysql" ? JSON.stringify(v) : pgSafe…(v)` DISPATCH
  *   ternary that five call sites duplicated verbatim; they are not a new abstraction over the encodings
  *   themselves, so this does not violate the rule above.
  *
@@ -112,7 +112,12 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import type { Logger } from "../observability/logger.js";
-export type SqlDialect = "tidb" | "pg";
+/**
+ * SQL **文本**的语法族(调用方说,不探):`mysql` = MySQL 协议(TiDB / MySQL InnoDB / MariaDB 同一套语句),`pg` = PostgreSQL。
+ * 与 `@sema-agent/core-stores-sql` 公面的 `SqlDialect` 同词同集 —— 部署词 / 引擎词都不是它的别名:谁在答是另一轴 {@link SqlEngine}(驱动探)。
+ * 本仓只这一份方言闭集(加腿 = 编译错,不是运行期的 `default` 臂)。
+ */
+export type SqlDialect = "mysql" | "pg";
 export type SqlRow = Record<string, unknown>;
 /** Normalized statement result: `rows` for SELECTs, `affected` for INSERT/UPDATE/DELETE. */
 export interface SqlResult {
@@ -337,7 +342,7 @@ export declare function sqlWallsOf(engine: SqlEngineReading | undefined): SqlWal
  * 放在某一只店里会让下一个需要它的店要么 import 一整只无关的店、要么自己抄一份(抄出来的两份会漂)。
  */
 export declare const SQL_DB_NOW_MS: {
-    readonly tidb: "CAST(UNIX_TIMESTAMP(NOW(3)) * 1000 AS SIGNED)";
+    readonly mysql: "CAST(UNIX_TIMESTAMP(NOW(3)) * 1000 AS SIGNED)";
     readonly pg: "(EXTRACT(EPOCH FROM clock_timestamp()) * 1000)::bigint";
 };
 /**

package/dist/plugins/sql-driver.js

@@ -48,7 +48,7 @@ export function sqlWallsOf(engine) {
     switch (engine.dialect) {
         case "pg":
             return NO_WALLS;
-        case "tidb":
+        case "mysql":
             return SQL_FACTS_ABSENT_WALLS;
         default: {
             const unhandled = engine.dialect;
@@ -57,11 +57,11 @@ export function sqlWallsOf(engine) {
     }
 }
 export const SQL_DB_NOW_MS = {
-    tidb: "CAST(UNIX_TIMESTAMP(NOW(3)) * 1000 AS SIGNED)",
+    mysql: "CAST(UNIX_TIMESTAMP(NOW(3)) * 1000 AS SIGNED)",
     pg: "(EXTRACT(EPOCH FROM clock_timestamp()) * 1000)::bigint",
 };
 export async function sqlDbNowMs(db, subject) {
-    const sql = db.dialect === "tidb" ? `SELECT ${SQL_DB_NOW_MS.tidb} AS db_now_ms` : `SELECT ${SQL_DB_NOW_MS.pg} AS db_now_ms`;
+    const sql = `SELECT ${SQL_DB_NOW_MS[db.dialect]} AS db_now_ms`;
     const { rows } = await db.query(sql, []);
     const n = Number(rows[0]?.["db_now_ms"] ?? Number.NaN);
     if (!Number.isFinite(n))
@@ -375,7 +375,7 @@ export function createCloseAwarePool(pool) {
 export function mysqlDriver(pool) {
     const session = poolSession(pool);
     return {
-        dialect: "tidb",
+        dialect: "mysql",
         get facts() {
             return session.facts;
         },
@@ -471,6 +471,6 @@ export function pgDriver(pool) {
         },
     };
 }
-export const dialectJsonEncoder = (dialect) => dialect === "tidb" ? JSON.stringify : pgSafeJsonStringify;
-export const dialectProtocolJsonEncoder = (dialect) => dialect === "tidb" ? (v) => JSON.stringify(v) : pgProtocolJsonStringify;
+export const dialectJsonEncoder = (dialect) => dialect === "mysql" ? JSON.stringify : pgSafeJsonStringify;
+export const dialectProtocolJsonEncoder = (dialect) => dialect === "mysql" ? (v) => JSON.stringify(v) : pgProtocolJsonStringify;
 //# sourceMappingURL=sql-driver.js.map

package/dist/plugins/sql-errors.js

@@ -13,7 +13,7 @@ export function isPgUniqueViolation(err) {
     return String(keyOf(err, "code")) === PG_UNIQUE_VIOLATION_SQLSTATE;
 }
 export function isDupKeyError(dialect, err) {
-    return dialect === "tidb" ? isMysqlDupKeyError(err) : isPgUniqueViolation(err);
+    return dialect === "mysql" ? isMysqlDupKeyError(err) : isPgUniqueViolation(err);
 }
 export const PG_UNDEFINED_COLUMN_SQLSTATE = "42703";
 export const MYSQL_ER_BAD_FIELD_ERRNO = 1054;

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

@@ -5,6 +5,7 @@ import { type OutcomeSink } from "./file-outcome-sink.js";
 import { type InboxWarn } from "./workflow-run-store-sql.js";
 import { FileRunStore } from "./file-run-store.js";
 import { type OneTimeMigrationReport } from "./one-time-migrations.js";
+import type { LocalSessionRows } from "./local-session-window.js";
 import type { SessionHeadReader } from "./caching-session-store.js";
 import { LocalCheckpointStore } from "./local-checkpoint-store.js";
 import { FileResumeAnchorStore } from "./file-resume-anchor-store.js";
@@ -16,7 +17,7 @@ import { type MemoryOptOutGrantStore } from "./memory-optout-grant-store-sql.js"
 import { type SendFileLedger } from "./send-file-ledger.js";
 import type { UserInputLedgerStore } from "../user-input-ledger.js";
 import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
-import { type SessionPolicyStoreLogger } from "./session-policy-store-sql.js";
+import { type SessionPolicyStoreLogger } from "../stores-sql/session-policy-store-sql.js";
 import type { ServiceConfig } from "../config-types.js";
 import { TiDBRunStore, PgRunStore } from "./run-store-sql.js";
 import { TiDBCheckpointStore, PgCheckpointStore } from "./checkpoint-store-sql.js";
@@ -256,11 +257,9 @@ export interface StoreBackend {
      *  `fileSessionCaptureRecordStore(controlDir)` 按平面现造,依托是**记忆引擎的控制面目录** ⇒ 记忆面暗的
      *  部署上该平面不存在,于是这一支**随引擎接线门缺席**(唯一的 `undefined` 成因,逐字理由见 LocalBackend 的实装注)。
      *
-     *  🔴 修前 local 恒 `undefined` 且注称「缺席是一个真答案」—— 那句话在**事实层面**成立(单机的正确载体
-     *  确实就是文件三腿)、在**接线层面**是假的:core 的 `captureCarrierUnsupported`
-     *  (core 7.13.0 `prepare-task.js`)判的是「这个席位在不在」而不是「文件形能不能用」,叠上
-     *  `isRemoteExecutionEnv` 的接口形鸭子判(`remote-env.js`)把本仓 host lane 一并算作 remote,
-     *  于是单机默认部署上 `memoryCapture:"off"` 两条 ingress 结构性不可达([ref])。
+     *  🔴 local 不能答 `undefined`:引擎的 `captureCarrierUnsupported`(`prepare-task.js`)判的是「这个席位在不在」而不是「文件形能不能用」,
+     *  叠上执行环境块 `hostLocalPaths` 为假 —— 本地后端上跑沙箱 / 远端车道的部署,席位缺席 ⇒ `memoryCapture:"off"` 两条 ingress 结构性不可达。
+     *  (引擎按接口形判 remote 的那些版本里 host 车道也在射程;今天按块判,host 不在,供店对它是无害的同址声明。)
      *  刻意仍不给 local 一个**内存** twin:内存形会在重启时把一条隐私记录静默丢掉(比文件三腿严格更差)。 */
     sessionCaptureRecords(): SessionCaptureRecordSource | undefined;
     /** Retired-epoch byte hygiene: GC grace-passed orphan `snapshot_blob` rows/objects — the whole-tree snapshot
@@ -410,6 +409,36 @@ export interface StoreBackend {
  *  编辑被拒)。云形缺 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;
+/**
+ * LOCAL backend (clay 2026-06-25 seamless local↔cloud; P0.5 variant-2 + variant-1 file-backed 2026-06-26): a DB-less StoreBackend
+ * so a locally-run HTTP service serves the SAME contract a cloud worker does (runs + trace + sessions + resume;
+ * long-term memory rides the [ref] memory ENGINE, not this backend). Sessions / per-session policy / file snapshots are
+ * FILE-BACKED via core's `FileStorageBackend` over `root`, so a session SURVIVES a process restart and the resume
+ * picker (GET /v1/sessions → LocalSessionStore.listSessions) is restart-visible — the 2c "first local, then sync"
+ * hard prerequisite.
+ *
+ * The session store stays the §0.5 owner-aware {@link LocalSessionStore} wrapper, but over a fresh `FileSessionRepo`
+ * (NOT `fileBackend.sessionStore`, which is core's bare `TtlSessionStore` lacking the §0.5 owner/list/fork/delete
+ * ops); policy/snapshot delegate to the fileBackend's own file stores. The fileBackend takes a coarse boot
+ * single-instance lock on `root/LOCK` (an `O_EXCL`+`linkSync` PIDFILE, not flock — [ref] F4; same-host only:
+ * liveness = `process.kill(pid,0)`, so a foreign PID namespace or NFS defeats it, see DEPLOY-PREREQS) —
+ * `close()` MUST `dispose()` it so a graceful restart can
+ * re-acquire (a stale lock from a dead PID is pruned by core, but graceful restart relies on the release).
+ *
+ * P0.5 variant-1 (clay 2026-06-26): `run()`/`resumeAnchor()` are now FILE-backed too (FileRunStore /
+ * FileResumeAnchorStore over core 1.138.0's crash-safe fs primitives — atomicWriteFile/writeThenLink/AppendLog), so the
+ * runs ledger + trace event log + E18 anchors SURVIVE a process restart, completing variant-2's promised follow-on. The
+ * picker still lists from the session abstraction (variant-2), but a restart now also re-reads run history + resume
+ * anchors. Session owners are persisted too (7.119.0: in the session-meta sidecar, next to the incarnation — see
+ * LocalSessionStore), so an owner survives a restart like the SQL twins' column does. The cloud-only stores
+ * (checkpoint/approval/toolResult/imageIndex/imageBake/breaker/costQuota/rateLimiter) are OMITTED → the consumers'
+ * `backend?.X?.()` gates degrade them exactly like a no-DB env.
+ */
+/**
+ * The local session store's rows for the session view's window (`local-session-window.ts`): the local backend's own session store — its row
+ * projection and its log export — and `undefined` on any other backend. The one place that answers "is there a local store to read rows from".
+ */
+export declare function localSessionRowsOf(backend: StoreBackend | undefined): LocalSessionRows | undefined;
 /**
  * 启动日志里「跨副本 or 进程内」那一格的标签。
  *

package/dist/plugins/store-backend.js

@@ -17,6 +17,7 @@ import { NO_SQL_MIGRATIONS, assertExecutionPlacementSwitchAdmissibleOnPool, back
 import { deployedExecutionLanes } from "../execution-lane-caps.js";
 import { assertRetiredSchemaAbsentOnPool } from "./schema-consistency.js";
 import { LocalSessionStore, createLocalSessionRepo } from "./local-session-store.js";
+import { SESSION_DURABILITY, SESSION_PLACEMENTS } from "./session-placement.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";
@@ -30,7 +31,7 @@ import { TiDBSendFileLedger, PgSendFileLedger, FileSendFileLedger } from "./send
 import { FileUserInputLedgerStore } from "./user-input-ledger-file.js";
 import { TiDBUserInputLedgerStore, PgUserInputLedgerStore } from "./user-input-ledger-sql.js";
 import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
-import { TiDBSessionPolicyStore, PgSessionPolicyStore } from "./session-policy-store-sql.js";
+import { TiDBSessionPolicyStore, PgSessionPolicyStore } from "../stores-sql/session-policy-store-sql.js";
 import { TiDBWorkflowJournalStore, PgWorkflowJournalStore } from "./workflow-journal-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";
@@ -92,7 +93,7 @@ function legacyBlobBackend(config, dialect, pool) {
 async function legacySweepImpl(config, dialect, pool) {
     const sql = "SELECT blob_hash FROM snapshot_blob";
     let orphans;
-    if (dialect === "tidb") {
+    if (dialect === "mysql") {
         const [rows] = await pool.query(sql);
         orphans = rows.map((r) => String(r.blob_hash));
     }
@@ -135,12 +136,12 @@ class TiDBBackend {
     sendFileLedger() { return new TiDBSendFileLedger(this.pool); }
     userInputLedger() { return new TiDBUserInputLedgerStore(this.pool); }
     sessionPolicy(logger) { return new TiDBSessionPolicyStore(this.pool, logger); }
-    fileHistory() { return new TiDBFileHistoryStore(this.pool, historyBlobBackend(this.config, "tidb", this.pool), this.config.fileHistory); }
+    fileHistory() { return new TiDBFileHistoryStore(this.pool, historyBlobBackend(this.config, "mysql", this.pool), this.config.fileHistory); }
     memoryOptOutGrant() { return new TiDBMemoryOptOutGrantStore(this.pool); }
     sessionCaptureRecords() { return () => (this.captureRecordsInst ??= new TiDBSessionCaptureRecordStore(this.pool)); }
     captureRecordsInst;
-    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "tidb", this.pool); }
-    runOneTimeMigrations() { return runSqlOneTimeMigrations("tidb", this.pool, { lanes: deployedExecutionLanes(this.config) }); }
+    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "mysql", this.pool); }
+    runOneTimeMigrations() { return runSqlOneTimeMigrations("mysql", this.pool, { lanes: deployedExecutionLanes(this.config) }); }
     workflowJournal() { return new TiDBWorkflowJournalStore(this.pool); }
     outcomeSink() { return new TiDBOutcomeLedger(this.pool); }
     workflowRun(onWarn) { return new TiDBWorkflowRunStore(this.pool, onWarn); }
@@ -150,7 +151,7 @@ class TiDBBackend {
     workflowParkDecisions() { return (this.parkDecisionsInst ??= new SqlWorkflowParkDecisionStore(this.run())); }
     parkDecisionsInst;
     sharedMemoryStore(authorizer) { return new TiDBSharedMemoryStore(this.pool, authorizer); }
-    checkpoint(logger) { return new TiDBCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
+    checkpoint(logger) { return new TiDBCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep), claims: this.run() }); }
     checkpointReadView() { return this.checkpoint(); }
     toolResult() { return new TiDBToolResultStore(this.pool, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
     imageIndex() { return new TiDBImageIndex(this.pool); }
@@ -204,7 +205,7 @@ class PgBackend {
     workflowParkDecisions() { return (this.parkDecisionsInst ??= new SqlWorkflowParkDecisionStore(this.run())); }
     parkDecisionsInst;
     sharedMemoryStore(authorizer) { return new PgSharedMemoryStore(this.pool, authorizer); }
-    checkpoint(logger) { return new PgCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
+    checkpoint(logger) { return new PgCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep), claims: this.run() }); }
     checkpointReadView() { return this.checkpoint(); }
     toolResult() { return new PgToolResultStore(this.pool, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
     imageIndex() { return new PgImageIndex(this.pool); }
@@ -222,6 +223,9 @@ class PgBackend {
     pgPool() { return this.pool; }
     async dbNowMs() { const res = await this.pool.query("SELECT ROUND(EXTRACT(EPOCH FROM now())*1000) AS ms"); return Number(res.rows[0]?.ms); }
 }
+export function localSessionRowsOf(backend) {
+    return backend instanceof LocalBackend ? backend.session() : undefined;
+}
 class LocalBackend {
     kind = "local";
     fileBackend;
@@ -265,7 +269,11 @@ class LocalBackend {
             error: (msg, fields) => void (this.onError ?? this.onWarn)?.(msg, fields),
             strictHydrate: config.runStoreStrictHydrate,
         });
-        this.sessionStore = new LocalSessionStore(createLocalSessionRepo(this.fileBackend.root), this.runStore, this.fileBackend.root, { log: createLogger(config.logLevel) });
+        this.sessionStore = new LocalSessionStore(createLocalSessionRepo(this.fileBackend.root), this.runStore, this.fileBackend.root, {
+            log: createLogger(config.logLevel),
+            durability: SESSION_DURABILITY,
+            placements: SESSION_PLACEMENTS,
+        });
         this.parkDecisionLedgerRoot = config.workflowRunStoreBackend === "memory" ? undefined : join(this.fileBackend.root, "workflows");
         this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root);
         this.approvalExemptionStore = new FileApprovalExemptionStore(this.fileBackend.root, { warn: corruptReadWarn });
@@ -283,9 +291,12 @@ class LocalBackend {
             ? undefined
             : (plane) => fileSessionCaptureRecordStore(plane?.controlDir ?? ownControlDir);
     }
-    async ensureSchema() { }
+    async ensureSchema() {
+        await this.sessionStore.settleArchiveSnapshots();
+    }
     async runOneTimeMigrations() {
         const holderDeathCodeRowsBackfilled = this.runStore.migrateLegacyHolderDeathCodes();
+        const archives = await this.sessionStore.migrateLocalArchives();
         const placements = await backfillLocalExecutionPlacements(this.runStore.sessionIdsWithRuns(), this.sessionStore.executionPlacementBackfill, { lanes: this.executionLanes });
         return {
             ...NO_SQL_MIGRATIONS,
@@ -293,6 +304,11 @@ class LocalBackend {
             executionPlacementsBackfilled: placements.backfilled,
             executionPlacementSessionsUnreadable: placements.unreadable,
             askExecutionLanesBackfilled: backfillLocalAskExecutionLanes(this.approvalAskStore, { lanes: this.executionLanes }),
+            localArchiveRowFactsBackfilled: archives.rowFactsBackfilled,
+            localArchivesAnonymized: archives.anonymized,
+            localArchivesKeptStamped: archives.keptStamped,
+            localArchivesUnreadable: archives.unreadable,
+            localArchiveSnapshotsRecovered: archives.snapshotsRecovered,
         };
     }
     async close() {
@@ -336,6 +352,7 @@ class LocalBackend {
         return (this.checkpointStoreInst ??= new LocalCheckpointStore(this.fileBackend.root, {
             getActiveTaskId: (sessionId) => this.runStore.getActiveTaskId(sessionId),
             readSessionOwner: async (sessionId) => (await this.sessionStore.headOf(sessionId))?.owner,
+            claims: this.runStore,
         }));
     }
     checkpoint() {
@@ -380,7 +397,7 @@ export function createStoreBackend(config, onWarn, onError) {
     if (!config.tidb)
         return undefined;
     const pool = createTidbPool(config);
-    return withRetiredSchemaProbe(new TiDBBackend(pool, config), { dialect: "tidb", pool }, { lanes: deployedExecutionLanes(config) });
+    return withRetiredSchemaProbe(new TiDBBackend(pool, config), { dialect: "mysql", pool }, { lanes: deployedExecutionLanes(config) });
 }
 function withRetiredSchemaProbe(inner, target, executionPlacementSwitch) {
     const guarded = Object.create(inner);

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

@@ -307,6 +307,13 @@ export type CreateRunOutcome = {
     activeTaskId?: undefined;
     sessionAbsent: true;
 };
+/**
+ * 认领栅栏交给 `write` 的那一行 run 此刻的事实(SQL = 锁住那一行读的;进程内 = 同步段里读的)。认领与 `running` 只认 taskId,而续跑腿让同一个 taskId
+ * 停驻之后回到 `running`、认领仍在 —— 「接下这笔写的那条腿还是不是这条 run 的腿」要按腿问的写者拿它问(今天:副本 `instanceId`,续跑的 CAS 赢点把它改成接手的副本)。
+ */
+export interface FencedRun {
+    readonly instanceId: string | null;
+}
 /** SQL 认领栅栏的结局:`held: false` = 认领此刻不是这条 run 的(或它已不在跑),`write` 一次都没调。 */
 export type ClaimFenced<T> = {
     readonly held: true;
@@ -325,13 +332,13 @@ export type FenceLanded = typeof FENCE_LANDED;
  * **宿主会话的认领当写栅栏用 —— 进程内那一形**(属主 = run 店;Memory / File 两孪生同律)。认领 = 会话 → 持有它的 taskId,
  * 由 {@link CreateRunOutcome} 的建行(或续跑腿的 markResuming)取得、终局 / 收割放掉 —— 「这次受理还持有会话吗」只问它,不另记身份。
  *
- * `whileHoldingClaim(sessionId, taskId, write)`:**只有** `taskId` 此刻持有 `sessionId` 的认领、且这条 run 是活的(`running`)时才调 `write`、答 `true`,
+ * `whileHoldingClaim(sessionId, taskId, write)`:**只有** `taskId` 此刻持有 `sessionId` 的认领、且这条 run 是活的(`running`)时才调 `write`(交给它那一行的 {@link FencedRun})、答 `true`,
  * 同一拍把这条 run 的活性戳刷新(一次栅栏写也是一次心跳);否则一次都不调、答 `false`。整只是**同步**的 —— `write` 也是:判、刷新、`write` 落定是同一个同步段,
  * 中间没有让出,所以认领在 `write` 落定之前挪不动(这一条由类型担保 —— `write` 必须同步交回 {@link FENCE_LANDED},不靠「这里恰好没有 await」)。
  * SQL 孪生的栅栏是一个事务(`run-store-sql.ts` `SqlRunStore.whileHoldingClaim`,`write` 收那只事务连接,结局 {@link ClaimFenced}),不是本型。
  */
 export interface InProcessClaimFence {
-    whileHoldingClaim(sessionId: string, taskId: string, write: () => FenceLanded): boolean;
+    whileHoldingClaim(sessionId: string, taskId: string, write: (run: FencedRun) => FenceLanded): boolean;
 }
 /**
  * `RunRecord["status"]`(= `"running" | TaskStatus`)的**唯一分类表** —— 词表的属主 = 判据的属主,