@sema-agent/server 7.144.0 → 7.146.0

package/dist/plugins/pg-session-storage.d.ts

@@ -1,14 +1,14 @@
 import { BaseSessionStorage, type AcquiredSession, type PlacedSessionRow, type SessionHead, type SessionMetadata, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry, type SessionWriteOptions } from "@sema-agent/core";
 import type { Pool, PoolClient } from "pg";
 import type { SessionSummary } from "./store-contracts.js";
-import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
+import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowAnswer, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
 import type { SessionWorkspace } from "../session-workspace.js";
 import type { RetentionDeclaration } from "@sema-agent/core";
 import { type IndexSpec } from "./ensure-index.js";
-import { type ForkTarget, type ForkToOutcome } from "./session-fork.js";
+import { type ForkPlacement, type ForkTarget, type ForkToOutcome } from "./session-fork.js";
 import { type ExecutionPlacementSeat } from "../execution-placement.js";
 /**
  * PG-dialect DDL for the L1 session log, translated from tidb-pool.ts SCHEMA_STATEMENTS:
@@ -118,6 +118,17 @@ export declare class PgSessionStore implements SessionStore {
         limit: number;
         q?: string;
     }): Promise<SessionSummary[]>;
+    /** @see TiDBSessionStore.listSessionRows — the PG twin. */
+    listSessionRows(opts: {
+        owner?: string;
+        includeUnowned?: boolean;
+        cursor?: {
+            lastActivityAt: string;
+            sessionId: string;
+        };
+        limit: number;
+        q?: string;
+    }): Promise<Array<SessionRowAnswer<SessionSummary>>>;
     /** @see TiDBSessionStore.sessionSummaryOf — the PG twin (same projection, run-preview subqueries scoped to the id). */
     sessionSummaryOf(sessionId: string): Promise<SessionSummary | undefined>;
     /** @see TiDBSessionStore.listRowOf — the PG twin. */
@@ -143,8 +154,10 @@ export declare class PgSessionStore implements SessionStore {
     /** @see TiDBSessionStore.recordSessionWorkspace — the PG twin (whole-cell overwrite fenced to the occupant; `pgSafeJsonStringify` + `::jsonb`, like every PG JSON write;
      *  the general query surface — the pool-wide `DB_QUERY_TIMEOUT_MS` server-side `statement_timeout` bounds it, no per-call client timer). */
     recordSessionWorkspace(sessionId: string, incarnation: string, workspace: SessionWorkspace): Promise<void>;
-    /** @see TiDBSessionStore.fork — core 契约 `fork(sourceId, owner?)` = {@link forkTo} 的投影(新铸 uuidv7 目标,`forkByFreshId`;三店同一只)。 */
-    fork(sourceId: string, owner?: string | null): Promise<string | null>;
+    /** @see TiDBSessionStore.fork — core 契约 `fork(sourceId, owner?, opts?)` = {@link forkTo} 的投影(新铸 uuidv7 目标,`forkByFreshId`;三店同一只;`opts.placement` 进委派分区)。 */
+    fork(sourceId: string, owner?: string | null, opts?: {
+        placement?: ForkPlacement;
+    }): Promise<string | null>;
     /** @see TiDBSessionStore.forkTo — fork 续写的店契约(PG 孪生逐字同义):目标行 meta 先、主键排他;撞已在 ⇒ 回滚后在新视图读目标按属主与 fork 键分类;
      *  读不到 ⇒ 整笔重跑一次,再不行 ⇒ {@link ForkTargetUnsettledError}。 */
     forkTo(sourceId: string, owner: string | null, target: ForkTarget): Promise<ForkToOutcome | null>;

package/dist/plugins/pg-session-storage.js

@@ -320,6 +320,9 @@ export class PgSessionStore {
         }
     }
     async listSessions(opts) {
+        return (await this.listSessionRows(opts)).map((a) => a.row);
+    }
+    async listSessionRows(opts) {
         const params = [];
         const ph = (v) => {
             params.push(v);
@@ -336,7 +339,7 @@ export class PgSessionStore {
             const sid = ph(opts.cursor.sessionId);
             where.push(`(sm.updated_at < ${a} OR (sm.updated_at = ${b} AND sm.session_id < ${sid}))`);
         }
-        return (await this.selectListRows({ where, params, limit: opts.limit })).map((a) => a.row);
+        return this.selectListRows({ where, params, limit: opts.limit });
     }
     async sessionSummaryOf(sessionId) {
         return (await this.listRowOf(sessionId))?.row;
@@ -419,8 +422,8 @@ export class PgSessionStore {
     async recordSessionWorkspace(sessionId, incarnation, workspace) {
         await this.pool.query("UPDATE session_meta SET workspace = $1::jsonb WHERE session_id = $2 AND incarnation = $3", [encodeSessionWorkspaceCell(workspace, pgSafeJsonStringify, sessionId), sessionId, incarnation]);
     }
-    async fork(sourceId, owner) {
-        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner);
+    async fork(sourceId, owner, opts) {
+        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner, opts);
     }
     async forkTo(sourceId, owner, target) {
         for (let attempt = 0; attempt < 2; attempt++) {
@@ -448,7 +451,8 @@ export class PgSessionStore {
         try {
             await conn.query("BEGIN");
             try {
-                await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, fork_key) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)", [target.id, forkOwner, now, now, forkLeafId, rows.length, mintSessionIncarnation(), target.key ?? null]);
+                await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, fork_key, " +
+                    "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)", [target.id, forkOwner, now, now, forkLeafId, rows.length, mintSessionIncarnation(), target.key ?? null, ...placementInsertValues(target.placement, now)]);
             }
             catch (err) {
                 if (!isDupKey(err))

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

@@ -52,6 +52,10 @@ export declare class SqlRunStore {
      * 续跑与 wake 复用 checkpoint 的会话 —— 所以零行只在「受理之后被删」这一种竞争里出现。
      */
     createRun(taskId: string, sessionId: string, owner: string | null, instanceId: string, meta?: NewRunMeta): Promise<CreateRunOutcome>;
+    /** run 行预览的**写一次补写**(腿上装着 prompt 屏时建行不写预览,引擎交付可写的那一份之后补;律的属主 = `run-acceptance.ts`):
+     *  列仍是 NULL(没建过预览)才写 —— 建行写过的、已经补过的一律不动,所以补写永远盖不掉任何一份既有预览。不碰 `updated_at`(预览不是状态变化,
+     *  收割与列表的时序都不该因它移动)。行不在 ⇒ 0 行,无事。PG 臂过 `pgSanitizeText`(与建行写同一条:预览是模型可控标量)。 */
+    fillObjectivePreview(taskId: string, preview: string): Promise<void>;
     /** Request cancel of a RUNNING run (durable, cross-replica). Sets the flag the owning instance's heartbeat
      *  tick polls; a same-replica caller additionally aborts the in-flight controller for instant effect. Only
      *  flags a `running` row (terminal/suspended → 0 affected = no-op). Returns whether a running row was flagged.

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

@@ -6,7 +6,7 @@ import { pgSanitizeText } from "./pg-safe-json.js";
 import { toIso as iso } from "./sql-row-helpers.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { createObjectColumnReader, decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, isJsonColumnBodyProblem, jsonColumnText, readJsonObjectColumn, readNonNullJsonValueColumn } from "./sql-json-column.js";
-import { RUN_HOLDER_DEATH_CODES, RUN_STALLED_ERROR, readLegacyHolderDeathCode, settledLegObservationOf } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_STALLED_ERROR, settledLegObservationOf } from "./store-contracts.js";
 import { notifyRunTerminal, runTerminalLogLevel } from "../observability/run-terminal.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder, SQL_DB_NOW_MS, sqlDbNowMs } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
@@ -141,6 +141,9 @@ export class SqlRunStore {
             conn.release();
         }
     }
+    async fillObjectivePreview(taskId, preview) {
+        await this.db.query(this.q("UPDATE task_run SET objective_preview = ? WHERE task_id = ? AND objective_preview IS NULL", "UPDATE task_run SET objective_preview = $1 WHERE task_id = $2 AND objective_preview IS NULL"), [this.db.dialect === "mysql" ? preview : pgSanitizeText(preview), taskId]);
+    }
     async requestCancel(taskId, owner) {
         const { affected } = await this.db.query(this.q("UPDATE task_run SET cancel_requested = 1 WHERE task_id = ? AND owner <=> ? AND status = 'running'", "UPDATE task_run SET cancel_requested = 1 WHERE task_id = $1 AND owner IS NOT DISTINCT FROM $2 AND status = 'running'"), [taskId, owner]);
         return affected > 0;
@@ -307,7 +310,7 @@ export class SqlRunStore {
             status: r.status,
             result: refusing("serve a finished run as if it had produced nothing", () => decodeResultColumn(r.result, String(r.task_id))) ?? null,
             error: r.error ?? null,
-            errorCode: readLegacyHolderDeathCode({ status: String(r.status), error: r.error ?? null, errorCode: r.error_code ?? null }),
+            errorCode: r.error_code ?? null,
             jobId: r.job_id ?? null,
             source: r.source ?? null,
             identity: readRunIdentityCells(r.identity_source, r.identity_scope, r.identity_principal_inc),

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

@@ -5,9 +5,9 @@ import { ensurePgMemoryEngineSchema } from "./memory-engine-pg.js";
 import { ensurePgMemoryEmbedderMetaSchema } from "./memory-embedder-fingerprint.js";
 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 { ensureTiDBRosterSchema, ensurePgRosterSchema } from "../stores-sql/roster-store-sql.js";
 import { ensureTiDBBackgroundAgentSchema, ensurePgBackgroundAgentSchema } from "../stores-sql/background-agent-store-sql.js";
-import { ensureTiDBMailboxSchema, ensurePgMailboxSchema } from "./mailbox-store-sql.js";
+import { ensureTiDBMailboxSchema, ensurePgMailboxSchema } from "../stores-sql/mailbox-store-sql.js";
 import { ensureTiDBTaskAttachmentSchema, ensurePgTaskAttachmentSchema } from "./task-attachment-store.js";
 import { ensureTiDBUsageWindowSchema, ensurePgUsageWindowSchema } from "../stores-sql/usage-window-store-sql.js";
 import { ensureTiDBTaskListSchema, ensurePgTaskListSchema } from "./task-list-store-sql.js";

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

@@ -13,10 +13,15 @@
  * 吃一只 `Session`):唤醒出来的会话 `getEntry` 在地板之下会回读持久日志,所以判官在压缩过的会话上也看得见整条叶链。
  *
  * ## fork 续写的店契约(本文件下半)
- * 三店同一只私有体 `forkTo(sourceId, owner, { id, key? })`:目标行原子新建(唯一创建点)· 撞已在按属主与 fork 键分类({@link classifyForkTarget})·
- * local 崩溃中间态 `forking` 只许同键重试补齐 · fork 键此后每个写携带(整段换装经 `carriedRowCells`)。core 契约 `fork(sourceId, owner?)` = {@link forkByFreshId}。
+ * 三店同一只私有体 `forkTo(sourceId, owner, target)`:目标行原子新建(唯一创建点)· 撞已在按属主与 fork 键分类({@link classifyForkTarget})·
+ * local 崩溃中间态 `forking` 只许同键重试补齐 · fork 键此后每个写携带(整段换装经 `carriedRowCells`)。core 契约 `fork(sourceId, owner?, opts?)` = {@link forkByFreshId}。
+ *
+ * ## fork 进委派分区(core `SessionStore.fork` 的 `opts.placement`)
+ * fork 的创建那一笔就是一次建行:带元组的 fork 与带 placement 的 acquire 落**同一组**元组(六列 / 存档行头,first-write 不可变,`placedAt` 由店铸),
+ * 此后这一行欠 placed 行的每一条义务(不上宿主列表 · claim 形 acquire 拒 · 进分区枚举 · release = 真删除)。元组不带属主:行的属主仍是 fork 的属主参数
+ * 按 `forkOwnerOf` 的那一读(core 句:元组没有属主)。没声明分区的店照常 fork、不落元组(core 句:忽略合法,拒 fork 不合法)。
  */
-import { type ForkPoint, type ForkRowShape, type SessionStorage } from "@sema-agent/core";
+import { type ForkPoint, type ForkRowShape, type SessionStorage, type SessionStore } from "@sema-agent/core";
 /** 问引擎:这只(已唤醒的)源会话从哪里拷。SQL 孪生用它;local 店手里就是引擎的 `Session`,直接调 `settledForkOptions`。 */
 export declare function forkPointOf(storage: SessionStorage): Promise<ForkPoint>;
 /** 两只 SQL 孪生整份日志里的一行(两孪生选同一组列):父链两键交引擎挑行,其余三列原样搬进新会话、不读内容。 */
@@ -33,13 +38,27 @@ export interface ForkLogRow {
  */
 export declare const FORK_LOG_ROW_SHAPE: ForkRowShape<ForkLogRow>;
 /**
- * `forkTo` 的目标:调用方给的新会话 id 与(可选)fork 键。`key` 是服务端拼的不透明串(路由按「源 + 调用方 nonce」派生),存进新行那一格
- * `fork_key`(SQL)/ `forkKey`(local):一个事实 = 「建这一行的那次 fork 请求的键」。缺 = 非键控 fork(core 契约的现铸形)。
+ * fork 进委派分区时落的元组 —— core `SessionStore.fork` 第三参 `opts.placement` 的那一形,**直接取 core 的型、不复述**(core 当前写作 `SessionPlacement` 去掉属主:行的属主是
+ * fork 的属主参数的那一读)。本仓里这个元组型只有这一处定义:三店(local · pg · tidb)、路由店、`forkByFreshId`、引擎面声明的 fork 形参,以及建行绑定值
+ * `placementInsertValues`(`session-placement.ts`)都读它 —— core 再改 `fork` 的第三参,型面在这里一处跟着动(`SessionStore.fork` 是可选成员,所以取参数前先 `NonNullable`)。
+ */
+export type ForkPlacement = NonNullable<NonNullable<Parameters<NonNullable<SessionStore["fork"]>>[2]>["placement"]>;
+/**
+ * `forkTo` 的目标:调用方给的新会话 id,外加两者之一(或都没有):
+ *  · `key` —— 服务端拼的不透明串(路由按「源 + 调用方 nonce」派生),存进新行那一格 `fork_key`(SQL)/ `forkKey`(local):一个事实 = 「建这一行的那次 fork 请求的键」;
+ *  · `placement` —— 新行落进委派分区的元组(见文件头「fork 进委派分区」)。
+ * 两者互斥由型面说:带键的是客户端经路由的 fork(一位用户续一只会话,永不 placed —— placement 只走引擎的可信内部链),placed 的是引擎的 fork(后台 fork 子代的转录,
+ * 现铸 id、永不带键)⇒ {@link classifyForkTarget} 的重放判(键相等)永远碰不到 placed 目标。都缺 = 非键控、普通的 fork(core 契约的现铸形)。
  */
-export interface ForkTarget {
+export type ForkTarget = {
     readonly id: string;
     readonly key?: string;
-}
+    readonly placement?: undefined;
+} | {
+    readonly id: string;
+    readonly placement: ForkPlacement;
+    readonly key?: undefined;
+};
 /**
  * fork 键的**唯一**拼法(路由带键 ⇒ `forkTo(…, { id: forkId, key: forkKeyOf(源, forkNonce) })`):服务端拼的不透明串 —— 源 id 与调用方 nonce 的摘要,
  * 定长(远短于 `fork_key` 的 255),源进摘要 ⇒ 「异源同 nonce」拼出不同的键(撞同一只目标即 409,不当重放)。调用方不读它,只靠同键重试同答。
@@ -78,8 +97,11 @@ export declare class ForkTargetUnsettledError extends Error {
 /** 三店的 `forkTo` 形(私有体,经店面 `forkTo` 交出)。 */
 export type ForkToFn = (sourceId: string, owner: string | null, target: ForkTarget) => Promise<ForkToOutcome | null>;
 /**
- * core 契约 `fork(sourceId, owner?) → string | null` = `forkTo(…, { id: uuidv7() })` 的投影(三店同一只):`created` ⇒ 新 id;源不在 ⇒ `null`。
+ * core 契约 `fork(sourceId, owner?, opts?) → string | null` = `forkTo(…, { id: uuidv7(), placement? })` 的投影(三店同一只):`created` ⇒ 新 id;源不在 ⇒ `null`。
+ * `opts.placement` 原样进目标(落不落由店判:声明了分区的店落,没声明的忽略 —— 各店 `forkTo` 一处)。
  * 新铸的 uuidv7 撞上已在的行(`occupied` / `replayed`)不是一个答案,是不变量破 ⇒ 响亮抛 —— 无键请求永不答 `replayed`。
  */
-export declare function forkByFreshId(forkTo: ForkToFn, sourceId: string, owner: string | null | undefined): Promise<string | null>;
+export declare function forkByFreshId(forkTo: ForkToFn, sourceId: string, owner: string | null | undefined, opts?: {
+    placement?: ForkPlacement;
+}): Promise<string | null>;
 //# sourceMappingURL=session-fork.d.ts.map

package/dist/plugins/session-fork.js

@@ -26,9 +26,10 @@ export class ForkTargetUnsettledError extends Error {
         this.name = "ForkTargetUnsettledError";
     }
 }
-export async function forkByFreshId(forkTo, sourceId, owner) {
+export async function forkByFreshId(forkTo, sourceId, owner, opts) {
     const id = uuidv7();
-    const out = await forkTo(sourceId, owner ?? null, { id });
+    const placement = opts?.placement;
+    const out = await forkTo(sourceId, owner ?? null, placement !== undefined ? { id, placement } : { id });
     if (out === null)
         return null;
     switch (out.outcome) {

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

@@ -34,6 +34,7 @@
  *    店上,带 placement 的 acquire 必须回读到**已持久化**且同一元组身份的行,回读缺失/异组=响亮拒。
  */
 import { type PlacedSessionRow, type SessionPlacement, type SessionPlacementRecord, type SessionStore } from "@sema-agent/core";
+import type { ForkPlacement } from "./session-fork.js";
 /**
  * 三只持久会话店(SQL 两孪生 + local 后端)的**会话耐久声明**(core `SessionStore.durability`:未 placed 的会话活不活过进程重启)——
  * **单源**:三处声明(两孪生类上的顶层 `durability`、`LocalBackend` 交给店的顶层 `durability`)与委派分区的 {@link SESSION_PLACEMENTS}
@@ -93,8 +94,9 @@ export declare function placementFromRow(row: PlacementColumns | undefined): Ses
  * 消费方对它 fail-closed(永不按年龄收割)。一个「无行」与「另一个租户有行」分不清的 join 不许删东西。
  */
 export declare function placedRowFromRow(sessionId: string, row: PlacementColumns, lastActivityMs?: number): PlacedSessionRow;
-/** 创建时一次落行的六个绑定值(顺序 = {@link PLACEMENT_SELECT_COLUMNS});无 placement ⇒ 六个 NULL。 */
-export declare function placementInsertValues(placement: SessionPlacement | undefined, placedAt: Date): [string | null, string | null, string | null, string | null, string | null, Date | null];
+/** 创建时一次落行的六个绑定值(顺序 = {@link PLACEMENT_SELECT_COLUMNS});无 placement ⇒ 六个 NULL。读的只是元组(属主不在元组里 —— 它是行的属主格,建行那一笔另记):
+ *  带 placement 的 acquire 与带元组的 fork 两个建行点同调。 */
+export declare function placementInsertValues(placement: ForkPlacement | undefined, placedAt: Date): [string | null, string | null, string | null, string | null, string | null, Date | null];
 /** `acquire` 的 opts 面(core `SessionStore.acquire` 的第二参,窄成本模块要判的两键)。 */
 export interface PlacementAcquireOpts {
     requireExisting?: boolean;

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

@@ -48,7 +48,7 @@ export declare function ensureSessionDurable(hostStore: SessionStore, sessionId:
  * durable 委派分区的部署上(stage-07:core `resolveSubagentTranscriptTier(...) === "full"`),那里 core 给每只新起的后台子代铸 placement、
  * 转录生来就在 host 店 —— 所以这里**只验、不搬、不判属主**:属主是引擎判的(core 7.62.0 [ref] L1:没人派生的 run 读自己那一行、按化身绑一次,原样带给每一层子代;
  * 复活的子代 = 它自己那一行的属主),placed 行建行那一笔原样记下了它(盒义务 7,三只持久会话店 + `session-ownership.ts` 的 `placedSessionOwnerOf`)。
- * 挂点不认领、不推断、不收委派树根见证([ref] P-5;本仓的委派继承律在这一写点退役 —— 存量无主 placed 行:SQL 两店由一次性迁移 M23 在窗内回填,本机文件店没有回填臂,见 `local-session-store.ts` 头注)。
+ * 挂点不认领、不推断、不收委派树根见证([ref] P-5;本仓的委派继承律在这一写点退役 —— 存量无主 placed 行:SQL 两店由一次性迁移 M23 在窗内回填,本机文件店没有回填臂;本机文件店的建行自 7.145.0 起格先、存档后,崩在两笔之间不再新生这一形,见 `local-session-store.ts` 头注)。
  *   0. 宿主店读不出属主(没有 `headOf`,唯一判法 `headReadOf`)⇒ 响亮拒,一次读都不发。
  *   1. 在不在、有没有真内容:{@link ensureSessionDurable}(`requireExisting` 打开 + 叶子非空 + forget 收尾)。任何失败(不在、空壳、读故障)⇒ 原样上抛 = 否决
  *      (读故障也否决:说不准转录在不在,就不让一次审批押在它上面)。不判它是不是 placed 行:复活的是旧行时 id 取行上的会话(升级前停驻、当年晋升进来的普通行),

package/dist/plugins/sql-json-column.d.ts

@@ -69,7 +69,7 @@ export interface JsonColumnMember {
  *
  * 🔴 存在的唯一理由是「别名位在那里不合法」,**不是**给读腿留第二条路:读腿一律用 {@link jsonColumnText}
  * (别名是它的产物的一部分,理由见那只函数)。今天整仓**三处**消费方,各自的「别名位不合法」都是真的:
- *  · `one-time-migrations.ts` 的几条改写(M8 / M17 / M18 / M21 的候选扫描与按原文 CAS 回写)——
+ *  · `one-time-migrations.ts` 的几条改写(M17 / M18 / M21 的候选扫描与按原文 CAS 回写)——
  *    它们要在 `WHERE` 里判这一列的**文本**,而 `WHERE` 没有别名位;
  *  · `workflow-journal-store-sql.ts` 的 `loadPage`([ref] 车③a)—— 那一列的投影裹在一条
  *    `CASE WHEN LENGTH(result) > ? THEN NULL ELSE <expr> END AS result_json` 里:**别名属于整条 CASE**
@@ -202,6 +202,10 @@ export declare class StoreCorruptError extends Error {
     /** 出事的坐标(`<table>.<column> for <identity>`,由 {@link SqlJsonColumnError.where} 原样带过来)——
      *  进 wire 的 `where` 字段,人按它去找那一行。 */
     readonly where: string;
+    /** 构造函数交进来的就是这一只列错误(类型面如实:折码只在体问题上产出本类,见 {@link foldJsonColumn});子类想在同一份因由上再带一格事实时按它再构造,不必断言。 */
+    readonly cause: SqlJsonColumnError & {
+        readonly problem: SqlJsonColumnBodyProblem;
+    };
     constructor(cause: SqlJsonColumnError & {
         readonly problem: SqlJsonColumnBodyProblem;
     }, sentence: string);

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

@@ -20,7 +20,7 @@ import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-stor
 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";
+import { TiDBCheckpointStore, PgCheckpointStore } from "../stores-sql/checkpoint-store-sql.js";
 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";
@@ -92,7 +92,7 @@ export type ServiceFileHistoryStore = FileHistoryStore & {
      *  protected — never a synchronous external-store delete). Reaper-driven; SQL twins only. */
     sweepOrphanBlobs?(): Promise<number>;
 };
-/** SVC-2 (core CORE-7) WorkflowJournalStore — core's interface PLUS the service `deleteByRun` (GC extra). tidb/pg =
+/** SVC-2 (core CORE-7) WorkflowJournalStore — core's interface PLUS the service read page and age sweep below. tidb/pg =
  *  durable SQL twins (cross-replica resume journal); local = the service {@link FileWorkflowJournalStore}
  *  (single-box but RESTART-durable crash-safe JSONL, replacing core's InMemory). The shared equivalence suite keeps
  *  all three byte-matched (scope guard / idempotent-per-ordinal / oversize **refusal** —— [ref] / core 7.12.0
@@ -111,11 +111,14 @@ export type ServiceWorkflowJournalStore = WorkflowJournalStore & {
         resultJson: string | null;
         resultBytes: number;
     }>>;
-    deleteByRun?(runId: string): Promise<number>;
-    /** SVC-2 GC sweep (durable twins only): purge entries older than `maxAgeMs` — wired into the reaper to bound the
-     *  TaskResult-bearing table (the per-run deleteByRun has no run-store reap hook). Local InMemory omits it. */
+    /** SVC-2 GC sweep (durable twins only): purge entries older than `maxAgeMs` — the `workflow-journal-expired` leg of the backend sweep verb
+     *  (`plugins/store-sweep.ts`, composed in `boot/stores.ts`) bounds the TaskResult-bearing table with it; the journal's one delete path (no per-run
+     *  delete: the engine contract never had one). Local File / InMemory omit it. */
     reapExpired?(now: number, maxAgeMs: number): Promise<number>;
 };
+/** 本部署有没有 workflow journal 店、是哪一只 —— 唯一读法:开了 self-orchestration 且有后端 ⇒ 后端的 journal 店,否则无。
+ *  两处读者同读它:workflow 编排段(交 Runner 与 journal HTTP 读面的那只)与持久层组合点(按龄清扫动词的 `workflow-journal-expired` 腿)。 */
+export declare function workflowJournalOf(config: Pick<ServiceConfig, "selfOrchestrationEnabled">, backend: Pick<StoreBackend, "workflowJournal"> | undefined): ServiceWorkflowJournalStore | undefined;
 export type ImageIndex = TiDBImageIndex | PgImageIndex;
 export type ImageBake = TiDBImageBake | PgImageBake;
 /** [ref] 车4 件1:durable leader-run 登记表的双方言孪生(union 同族——TS 私有字段让具体类名义上不同)。 */
@@ -280,9 +283,9 @@ export interface StoreBackend {
      *  until a 2026-07-25 doc-rot sweep caught it). core 1.145.0 added the seam this comment was waiting for:
      *  `RunnerDeps.workflowJournalStore` (now `@sema-agent/core` `dist/core/types.d.ts`) + `journalStore` on the
      *  run_workflow tool deps (`dist/orchestration/run-workflow-tool.d.ts`), and the boot chain consumes it
-     *  end-to-end: built in `boot/workflow-orchestration.ts` (`const workflowJournalStore = …backend.workflowJournal()`),
-     *  threaded into RunnerDeps (`boot/runner-deps.ts` 的 `workflowJournalStore`), reaped on the maintenance tick
-     *  (`boot/reapers.ts` 同名字段), and read by `GET /v1/workflows/:id/journal` (`http/routes/workflows.ts`, [ref]). */
+     *  end-to-end: selected by {@link workflowJournalOf} (self-orchestration on ∧ a backend), built in `boot/workflow-orchestration.ts`,
+     *  threaded into RunnerDeps (`boot/runner-deps.ts` 的 `workflowJournalStore`), aged out by the backend sweep verb's `workflow-journal-expired`
+     *  leg (`boot/stores.ts`, same selector), and read by `GET /v1/workflows/:id/journal` (`http/routes/workflows.ts`, [ref]). */
     workflowJournal(): ServiceWorkflowJournalStore;
     /** [ref] §1 consumption sink for `RunnerDeps.onTaskOutcome` facts. REQUIRED on all backends:
      *  tidb/pg = the outcome-ledger twins (SQL rows, mapped via coreOutcomeToLedgerRow + verbatim core_outcome

package/dist/plugins/store-backend.js

@@ -33,7 +33,7 @@ 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 "../stores-sql/session-policy-store-sql.js";
-import { TiDBWorkflowJournalStore, PgWorkflowJournalStore } from "./workflow-journal-store-sql.js";
+import { TiDBWorkflowJournalStore, PgWorkflowJournalStore } from "../stores-sql/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";
 import { buildDisplaySafeUrl } from "../trace/redact.js";
@@ -41,8 +41,8 @@ import { fileMemoryControlDirFor } from "../memory-scope.js";
 import { createTidbPool, ensureSchema as ensureTidbSchema } from "./tidb-pool.js";
 import { createPgPool, ensurePgSchema, pgPoolOptions } from "./pg-pool.js";
 import { TiDBRunStore, PgRunStore } from "./run-store-sql.js";
-import { TiDBCheckpointStore, PgCheckpointStore } from "./checkpoint-store-sql.js";
-import { TiDBToolResultStore, PgToolResultStore } from "./tool-result-store-sql.js";
+import { TiDBCheckpointStore, PgCheckpointStore } from "../stores-sql/checkpoint-store-sql.js";
+import { TiDBToolResultStore, PgToolResultStore } from "../stores-sql/tool-result-store-sql.js";
 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";
@@ -59,11 +59,14 @@ import { TiDBAdoptionLogStore, PgAdoptionLogStore } from "./adoption-log-sql.js"
 import { TiDBRetentionStore, PgRetentionStore, sqlStoreRetention } from "./retention-store-sql.js";
 import { TiDBRetentionLaneStore, PgRetentionLaneStore } from "./retention-lane-store-sql.js";
 import { createSqlPermissionRuleStores } from "./permission-rule-store-sql.js";
-import { FILE_PERMISSION_RULE_DIR, createFilePermissionRuleStores } from "./permission-rule-store-file.js";
+import { FILE_PERMISSION_RULE_DIR, createFilePermissionRuleStores, fileRuleBucketOwners, isFileBucketDamaged } from "./permission-rule-store-file.js";
 import { retireImportedLayerRootAllows } from "./imported-layer-root-retirement.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { storeDegradedReasonFor } from "../store-posture.js";
 import { openWithinWait } from "./store-open-wait.js";
+export function workflowJournalOf(config, backend) {
+    return config.selfOrchestrationEnabled && backend ? backend.workflowJournal() : undefined;
+}
 function historyBlobBackend(config, dialect, pool) {
     const s = config.snapshotBlobStore;
     if (!s)
@@ -298,17 +301,15 @@ class LocalBackend {
         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 });
         const importedLayerRoot = { importedLayerRootAllowsRetired: [], importedLayerRootBucketsSkipped: [] };
         if (existsSync(join(this.fileBackend.root, FILE_PERMISSION_RULE_DIR))) {
             const rules = this.permissionRule();
-            await retireImportedLayerRootAllows({ candidateOwners: () => rules.approvals.importRecordOwners(), durable: rules.durable, isWholeBucketRefusal: () => false, isVanishedBucket: () => false }, importedLayerRoot);
+            await retireImportedLayerRootAllows({ candidateOwners: () => fileRuleBucketOwners(rules), durable: rules.durable, isWholeBucketRefusal: isFileBucketDamaged, isVanishedBucket: () => false }, importedLayerRoot);
         }
         return {
             ...NO_SQL_MIGRATIONS,
-            holderDeathCodeRowsBackfilled,
             executionPlacementsBackfilled: placements.backfilled,
             executionPlacementSessionsUnreadable: placements.unreadable,
             askExecutionLanesBackfilled: backfillLocalAskExecutionLanes(this.approvalAskStore, { lanes: this.executionLanes }),

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

@@ -168,20 +168,10 @@ export declare const RUN_HOLDER_DEATH_CODES: {
     readonly orphaned: "run.orphaned";
 };
 export type RunHolderDeathCode = (typeof RUN_HOLDER_DEATH_CODES)[keyof typeof RUN_HOLDER_DEATH_CODES];
-/**
- * 一次性迁移 **M6** 的判据(窗、删法与删后谁接住:窗口见 `plugins/one-time-migrations.ts` 登记表):7.116.0 之前写下的死亡判决行只有句子、码列为空 ——
- * 该行应有的码。两处用:local 腿的起服写回(`FileRunStore.migrateLegacyHolderDeathCodes`)与 SQL 两孪生行映射里的**读侧半场**(滚动升级窗里旧副本
- * 还会写这种行,起服写回覆盖不到;本函数随 M6 一起删)。只认两句落款的原字节(接管臂括注形按前缀认);码列已有值 / 非 `failed` / 别的句子 ⇒ 原样。
- */
-export declare function readLegacyHolderDeathCode(row: {
-    readonly status: string;
-    readonly error: string | null;
-    readonly errorCode: string | null;
-}): string | null;
 /**
  * run 行上是不是一份**持有者死亡判决**:`failed`,且行上的码是 {@link RUN_HOLDER_DEATH_CODES} 之一。判决只说「持有它的那个进程死在这条腿收场之前」,
  * 不说是谁 —— 持有者是谁读行上的 `instanceId`(判决不改它)。读者 = 用户输入受理账本的收敛判词(`src/user-input-ledger.ts` `judgeOpen`)。
- * 旧行(只有句子)由一次性迁移 M6 补上码(起服写回 + SQL 滚动窗的读侧半场,{@link readLegacyHolderDeathCode}),所以这里不再按句子判。
+ * 只认码、不按句子判:7.116.0 起两只死亡判决的写者恒同写码;只有句子、码列为空的行(更早的写者铸的)不是死亡判决(随包 MIGRATION 写了)。
  * 正常失败(别的码 / 无码)/ park 过期收割(`approval.expired`:腿 park 过)都**不是**死亡判决。
  */
 export declare function isHolderDeathVerdict(run: Pick<RunRecord, "status" | "errorCode">): boolean;

package/dist/plugins/store-contracts.js

@@ -8,15 +8,6 @@ export function buildRunOrphanedError(heldBy) {
 }
 export const RUN_HOLDER_DEATH_CODES = { stalled: "run.stalled", orphaned: "run.orphaned" };
 const RUN_HOLDER_DEATH_CODE_WORDS = new Set(Object.values(RUN_HOLDER_DEATH_CODES));
-export function readLegacyHolderDeathCode(row) {
-    if (row.errorCode !== null || row.status !== "failed" || row.error === null)
-        return row.errorCode;
-    if (row.error === RUN_STALLED_ERROR)
-        return RUN_HOLDER_DEATH_CODES.stalled;
-    if (row.error === RUN_ORPHANED_ERROR || row.error.startsWith(`${RUN_ORPHANED_ERROR} (`))
-        return RUN_HOLDER_DEATH_CODES.orphaned;
-    return null;
-}
 export function isHolderDeathVerdict(run) {
     return run.status === "failed" && run.errorCode !== null && RUN_HOLDER_DEATH_CODE_WORDS.has(run.errorCode);
 }

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

@@ -0,0 +1,63 @@
+/**
+ * 后端级按龄清扫动词 —— 一个后端的按龄清扫只有一只动词 `sweep({ nowMs })`,答每条腿删了几行。
+ *
+ * ## 律(一条)
+ * 维护 tick 只调这一只动词,不逐店探「有没有某个按龄删的方法」;每条腿的界只有一种读法({@link buildStoreSweepBounds}:部署旋钮 → 引擎的词 `maxAgeMs`,
+ * 即工具结果店 `ToolResultStore.reap(now, { maxAgeMs })`、名册 `RosterGcOptions.maxAgeMs` 的那个词;journal 店的按龄删同收 `maxAgeMs`),**每次清扫现读** —— `TOOL_RESULT_TTL_SEC` 是热键,
+ * 改了下一拍就按新值删;没给界的腿,或本后端那只座没有按龄删的面,一行不删、答 0。
+ * 形照引擎 SQL 后端包的同名动词(`SqlStorageBackend.sweep` / `SqlSweepLeg` / `SqlSweepReceipt`):腿名逐字用它的词。
+ *
+ * ## 射程(如实)
+ * 今天的三条腿:`tool-results-aged`(工具结果店的契约成员 `reap`)、`roster-aged`(名册 SQL 孪生的按龄删;File / 内存名册没有这一面 ⇒ 0)与
+ * `workflow-journal-expired`(journal SQL 孪生的按龄删 `reapExpired`,见 {@link createJournalSweepLeg};只在开了 self-orchestration 且有后端时有这只店,
+ * core 的 File journal 店没有这一面 ⇒ 0)。引擎包的腿闭集另有 `file-history-orphan-blobs`,随它的座搬进 `src/stores-sql/` 时并进来;信箱的 `reap` 是按收件箱
+ * 作用域的契约成员,引擎包的清扫腿里没有它,本动词也不收。实现仍是各座自己的方法;目录搬进引擎包之后,SQL 后端的这只动词就是包的 `sweep`。
+ *
+ * ## 失败
+ * 腿互不牵连:一条腿抛(同步抛或拒)不拦别的腿。全腿成功 ⇒ 答回执;有腿失败 ⇒ 以 {@link StoreSweepError} 拒,带上成功腿的计数与失败腿的原因,
+ * 调用方按腿各自上报。
+ */
+import type { ServiceConfig } from "../config.js";
+/** 本后端跑的清扫腿(闭集;词与引擎 SQL 后端包的 `SqlSweepLeg` 同字)。 */
+export declare const STORE_SWEEP_LEGS: readonly ["roster-aged", "tool-results-aged", "workflow-journal-expired"];
+export type StoreSweepLeg = (typeof STORE_SWEEP_LEGS)[number];
+/** 一次清扫每条腿删了几行。 */
+export type StoreSweepReceipt = Readonly<Record<StoreSweepLeg, number>>;
+/** 一条腿的界(部署陈述;词 = 引擎的 `maxAgeMs`)。 */
+export interface StoreSweepBound {
+    readonly maxAgeMs: number;
+}
+/** 各腿的界(缺一条 = 那条腿不删)。 */
+export type StoreSweepBounds = Readonly<Partial<Record<StoreSweepLeg, StoreSweepBound>>>;
+/**
+ * 部署旋钮 → 各腿的界:本仓唯一的读法。`TOOL_RESULT_TTL_SEC`(秒,> 0,热键)→ `tool-results-aged`;`ROSTER_RETENTION_MS`(毫秒,下限 1 分钟)→ `roster-aged`;
+ * `WORKFLOW_JOURNAL_RETENTION_MS`(毫秒,下限 1 分钟)→ `workflow-journal-expired`。
+ * 组合点把它包成读法函数交给 {@link createStoreSweep},每次清扫现读一次 —— 交起服那一刻的值会让热发布的新界不生效。
+ */
+export declare function buildStoreSweepBounds(config: Pick<ServiceConfig, "toolResultTtlSec" | "rosterRetentionMs" | "workflowJournalRetentionMs">): StoreSweepBounds;
+/** 一条腿的实现:删掉存了超过 `bound.maxAgeMs` 的行,答删了几行。 */
+export type StoreSweepLegRun = (nowMs: number, bound: StoreSweepBound) => Promise<number> | number;
+/**
+ * journal 店的按龄删 → `workflow-journal-expired` 腿:截止线 = 动词交来的 `nowMs` − 动词交来的 `maxAgeMs`(界每次清扫现读,腿不自存)。
+ * 店没有这一面(core 的 File / 内存 journal 店)或没有店(self-orchestration 关 / 无后端)⇒ 无腿,动词答 0。
+ */
+export declare function createJournalSweepLeg(store: {
+    reapExpired?(now: number, maxAgeMs: number): Promise<number>;
+} | undefined): StoreSweepLegRun | undefined;
+export interface StoreSweep {
+    sweep(input: {
+        readonly nowMs: number;
+    }): Promise<StoreSweepReceipt>;
+}
+/** 有腿失败的那次清扫:`receipt` 里失败腿记 0,`failed` 按腿带原因。 */
+export declare class StoreSweepError extends Error {
+    readonly receipt: StoreSweepReceipt;
+    readonly failed: ReadonlyMap<StoreSweepLeg, unknown>;
+    constructor(receipt: StoreSweepReceipt, failed: ReadonlyMap<StoreSweepLeg, unknown>);
+}
+export declare function createStoreSweep(spec: {
+    readonly legs: Readonly<Partial<Record<StoreSweepLeg, StoreSweepLegRun>>>;
+    /** 界的读法:每次清扫调一次(只收函数 —— 起服那一刻的界对象交不进来)。 */
+    readonly bounds: () => StoreSweepBounds;
+}): StoreSweep;
+//# sourceMappingURL=store-sweep.d.ts.map

package/dist/plugins/store-sweep.js

@@ -0,0 +1,48 @@
+export const STORE_SWEEP_LEGS = ["roster-aged", "tool-results-aged", "workflow-journal-expired"];
+export function buildStoreSweepBounds(config) {
+    return {
+        "roster-aged": { maxAgeMs: config.rosterRetentionMs },
+        "tool-results-aged": { maxAgeMs: config.toolResultTtlSec * 1000 },
+        "workflow-journal-expired": { maxAgeMs: config.workflowJournalRetentionMs },
+    };
+}
+export function createJournalSweepLeg(store) {
+    const reap = store?.reapExpired?.bind(store);
+    return reap === undefined ? undefined : (nowMs, { maxAgeMs }) => reap(nowMs, maxAgeMs);
+}
+export class StoreSweepError extends Error {
+    receipt;
+    failed;
+    constructor(receipt, failed) {
+        super(`store sweep: leg(s) ${[...failed.keys()].join(", ")} failed`);
+        this.receipt = receipt;
+        this.failed = failed;
+        this.name = "StoreSweepError";
+    }
+}
+export function createStoreSweep(spec) {
+    const runLeg = async (leg, nowMs, bounds) => {
+        const run = spec.legs[leg];
+        const bound = bounds[leg];
+        if (run === undefined || bound === undefined)
+            return { leg, removed: 0 };
+        try {
+            return { leg, removed: await run(nowMs, bound) };
+        }
+        catch (error) {
+            return { leg, error };
+        }
+    };
+    return {
+        async sweep({ nowMs }) {
+            const bounds = spec.bounds();
+            const settled = await Promise.all(STORE_SWEEP_LEGS.map((leg) => runLeg(leg, nowMs, bounds)));
+            const receipt = Object.fromEntries(settled.map((s) => [s.leg, "removed" in s ? s.removed : 0]));
+            const failed = new Map(settled.flatMap((s) => ("error" in s ? [[s.leg, s.error]] : [])));
+            if (failed.size > 0)
+                throw new StoreSweepError(receipt, failed);
+            return receipt;
+        },
+    };
+}
+//# sourceMappingURL=store-sweep.js.map

package/dist/plugins/tidb-pool.js

@@ -16,7 +16,7 @@ import { PRINCIPAL_MAX_UTF8_BYTES } from "../security.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { CENTRAL_SCHEMA_INDEXES } from "./schema-indexes.js";
 import { SESSION_INDEXES } from "./pg-session-storage.js";
-import { TOOL_RESULT_INDEXES } from "./tool-result-store-sql.js";
+import { TOOL_RESULT_INDEXES } from "../stores-sql/tool-result-store-sql.js";
 import { COST_QUOTA_INDEXES } from "./pg-cost-quota.js";
 import { RATE_LIMIT_INDEXES } from "./pg-rate-limiter.js";
 import { OUTCOME_LEDGER_INDEXES } from "./outcome-ledger-sql.js";

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

@@ -16,10 +16,10 @@ import { type InstructionSourceBaseline } from "../instruction-source-notice.js"
 import type { SessionWorkspace } from "../session-workspace.js";
 import type { RetentionDeclaration } from "@sema-agent/core";
 import type { SessionSummary } from "./store-contracts.js";
-import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
+import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowAnswer, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
-import { type ForkTarget, type ForkToOutcome } from "./session-fork.js";
+import { type ForkPlacement, type ForkTarget, type ForkToOutcome } from "./session-fork.js";
 import { type ExecutionPlacementSeat } from "../execution-placement.js";
 export declare class TiDBSessionStore implements SessionStore {
     private readonly pool;
@@ -130,6 +130,17 @@ export declare class TiDBSessionStore implements SessionStore {
         limit: number;
         q?: string;
     }): Promise<SessionSummary[]>;
+    /** {@link listSessions} with each row's occupant (owner + incarnation) from the same SELECT — `OwnerAwareSessionStore.listSessionRows`; the incarnation never enters the row. */
+    listSessionRows(opts: {
+        owner?: string;
+        includeUnowned?: boolean;
+        cursor?: {
+            lastActivityAt: string;
+            sessionId: string;
+        };
+        limit: number;
+        q?: string;
+    }): Promise<Array<SessionRowAnswer<SessionSummary>>>;
     /** ONE session's list row — {@link listSessions}' projection (same SELECT, same mapper) scoped to one id; `undefined` = not a
      *  row of the list face (no such session / placed). The run-preview subqueries are scoped to the same id (an index read on
      *  `task_run.session_id`, not the whole-ledger aggregate the list pays). */
@@ -194,7 +205,9 @@ export declare class TiDBSessionStore implements SessionStore {
      * We instead SELECT the entire `session_event` log ordered by seq — every durable entry, compaction floor
      * bypassed — and re-seq it dense from 0 into the new session, ids/parents/payload byte-verbatim.
      */
-    fork(sourceId: string, owner?: string | null): Promise<string | null>;
+    fork(sourceId: string, owner?: string | null, opts?: {
+        placement?: ForkPlacement;
+    }): Promise<string | null>;
     /**
      * **fork 续写的店契约**(三店同一只私有体;core `fork` 是它的投影):把源会话的整份历史拷进调用方给的目标 id。
      *  1. **原子目标创建**:事务首句 `INSERT INTO session_meta (…, fork_key) VALUES (:target, …)`,主键即排他(meta 先,随后拷事件、COMMIT);