@sema-agent/server 7.131.0 → 7.133.0

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

@@ -269,6 +269,21 @@ export class SqlRunStore {
         const { affected } = await this.db.query(this.q("UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, result = NULL, instance_id = ?, updated_at = ? WHERE task_id = ? AND status IN ('suspended','needs_review')", "UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, result = NULL, instance_id = $1, updated_at = $2 WHERE task_id = $3 AND status IN ('suspended','needs_review')"), [instanceId, new Date(), taskId]);
         return affected === 1;
     }
+    async whileHoldingClaim(sessionId, taskId, write) {
+        let fenced = { held: false };
+        await this.tx(async (conn) => {
+            const run = await conn.query(this.q("SELECT task_id FROM task_run WHERE task_id = ? AND status = 'running' FOR UPDATE", "SELECT task_id FROM task_run WHERE task_id = $1 AND status = 'running' FOR UPDATE"), [taskId]);
+            if (run.rows.length === 0)
+                return;
+            const claim = await conn.query(this.q("SELECT task_id FROM task_active WHERE session_id = ? FOR UPDATE", "SELECT task_id FROM task_active WHERE session_id = $1 FOR UPDATE"), [sessionId]);
+            const holder = claim.rows[0];
+            if (holder === undefined || String(holder.task_id) !== taskId)
+                return;
+            await conn.query(this.q("UPDATE task_run SET updated_at = ? WHERE task_id = ?", "UPDATE task_run SET updated_at = $1 WHERE task_id = $2"), [new Date(), taskId]);
+            fenced = { held: true, value: await write(conn) };
+        });
+        return fenced;
+    }
     async getActiveTaskId(sessionId) {
         const { rows } = await this.db.query(this.q("SELECT task_id FROM task_active WHERE session_id = ?", "SELECT task_id FROM task_active WHERE session_id = $1"), [sessionId]);
         return rows[0] ? String(rows[0].task_id) : undefined;
@@ -335,7 +350,10 @@ export class SqlRunStore {
                 where.push("source = ?");
                 params.push(opts.source);
             }
-            if (opts.owner !== undefined) {
+            if (opts.owner === null) {
+                where.push("owner IS NULL");
+            }
+            else if (opts.owner !== undefined) {
                 where.push("owner = ?");
                 params.push(opts.owner);
             }
@@ -362,7 +380,9 @@ export class SqlRunStore {
             where.push(`job_id = ${p(opts.jobId)}`);
         if (opts.source !== undefined)
             where.push(`source = ${p(opts.source)}`);
-        if (opts.owner !== undefined)
+        if (opts.owner === null)
+            where.push("owner IS NULL");
+        else if (opts.owner !== undefined)
             where.push(`owner = ${p(opts.owner)}`);
         if (opts.cursor) {
             const a = p(new Date(opts.cursor.createdAt));

package/dist/plugins/schema-consistency.d.ts

@@ -30,9 +30,29 @@
  * information_schema 查询抛错、或整库一行都读不出来 ⇒ **拒启**。探针的语义是「我证明了库等于代码」,
  * 证不出来时放行等于把一条保护性断言静默降级成祝福([ref]:保护型缺席必须 fail-closed)。
  * `recordFailOpen` 在这条腿上**不适用** —— 它是 F 类(装饰/缓存)的登记口,不是 P 类保护臂的逃生门。
+ *
+ * ── 第二道对账:跳版升级的库带着**退役** schema(先于建表)──────────────────────────────────────
+ * 一次性迁移 M1–M3(7.74.0–7.125.x)删掉了整树快照索引表 `snapshot_manifest` 与单座 steering 列 `checkpoint.pending_steer`,并把账本 / 已决行里
+ * 旧拼法 `unresolvable` 改写成 `ancestor_marked`;三条窗关后已删码。从没在带那三条的版本上起过服的库(跳版升级)两件退役 schema 至少一件仍在 ⇒
+ * 旧拼法的改写同样没跑过 ⇒ {@link assertRetiredSchemaAbsent} 响亮拒启({@link RetiredSchemaPresentError},同一个拒启码 `config.schema_mismatch`),
+ * 点名在场的坐标与出路(先在 7.125.x 起服一次让那三条跑完,再升)。**旧拼法不另扫**:那是一条对账本 `task_event` 的无索引整表扫(全站最大的表,
+ * PG 池级 `statement_timeout` 会把它切成拒启、每次起服重演);两件 schema 的在场就是「这只库没经过带迁移的版本」的判据(7.74.0 之前的每一版 DDL
+ * 都建它们,7.74.0 起都不再建;能写下旧拼法的 7.64.0–7.71.0 恒带两者)。
+ * 这一道**没有窗**(跳版升级的库永远可能出现),所以它住在起服对账一族而不在一次性迁移文件里 —— 那个文件里每一条都有窗,最后一条删掉时整个文件
+ * 一起删、零例外。判据读本族**唯一**的列册读者 {@link readLiveColumns}(PG 读查询真正会解析到的关系,与第一道同一读法),不另造表 / 列在场探针。
+ * **先于一切 DDL**:唯一的读处是探针口 {@link assertRetiredSchemaAbsentOnPool},唯一的调用点是 `store-backend.ts` 里 SQL 两后端的 `ensureSchema()` 包装
+ * (探针先于它的第一条 CREATE)—— 一次会拒的起服不许先在库里建出几十张本版新表(`task_run` 还带着新列),否则拒句里「没动过库」就是假话,
+ * 按拒句指路去 7.125.x 起服的人会撞上「库比 7.125.x 新」的第二道拒。嵌入方走公开序列 `createStoreBackend()` → `ensureSchema()` → `runOneTimeMigrations()`
+ * 即得到这一问,零动作。
+ * 残余(如实):运维在第一次起带迁移的版本之前就把两件退役 schema 都手工删掉的库,残留的旧拼法由门记录的读腿接住 —— 7.129.0 起(core 7.51.0 #1731)
+ * 那只读腿按 core 的档案读法读,`unresolvable` 是 core 退役词注册表里的词 ⇒ 记录原词原样读回、不改写(`trace/project.ts` `screenedGate`);local 文件车道
+ * 没有表与列,没有这一问 —— 引擎 File 店里已决 checkpoint 的记录按契约物理不可变,本仓没有合法缝改写它们,同由那条读腿接住。
  */
+import type { Pool as MysqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
 import { type SchemaDialect } from "./schema-ensure-legs.js";
 import { type SchemaProbeRead } from "./schema-live-columns.js";
+import { StoreBootRefusalError } from "./store-contracts.js";
 /** 一列:名字 + 它在 `CREATE TABLE` 里的**原样定义文本**(生成 ADD COLUMN 指路用,不另手写)。 */
 export interface ParsedColumn {
     readonly name: string;
@@ -73,4 +93,38 @@ export declare function describeSchemaMismatch(dialect: SchemaDialect, mismatche
  * 失败方向见文件头注:读抛 / 整库零行 ⇒ 拒。
  */
 export declare function assertSchemaMatchesCode(read: SchemaProbeRead, dialect: SchemaDialect): Promise<void>;
+/**
+ * 跳版升级的库的拒启:退役 schema(快照索引表 / 单座列)任一仍在。**具名类型**:锚类型不锚文案(日志消费端与测试按 `code` / 类型分派);
+ * 码取列册对账同一个 `config.schema_mismatch`,运维面一个拒启码一个读法。拒句点名在场的坐标、说明第三条(旧拼法改写)同样没跑过、给出路。
+ * 继承 {@link StoreBootRefusalError}:这是一句**确定**的拒启表态(再等也等不来另一个答案)—— `ensureSchema()` 里它不被 SQL 开库的等待窗重试、不被改写成「库打不开」的拒句。
+ */
+export declare class RetiredSchemaPresentError extends StoreBootRefusalError {
+    readonly found: readonly string[];
+    /** 机读码(与列册对账的拒启同一个)。 */
+    readonly code = "config.schema_mismatch";
+    constructor(found: readonly string[]);
+}
+/**
+ * 退役 schema 的判据(纯读,**唯一一只**;规则见文件头「第二道对账」一节):经列册读者 {@link readLiveColumns} 读一次库里的列集,
+ * 快照索引表 / 单座列任一在场 ⇒ 抛 {@link RetiredSchemaPresentError}。新库(建表之前一列都没有)⇒ 不在场、过。读抛 ⇒ 原样上抛(拒启;不是确定的拒启表态,
+ * 开库等待窗照常重试 —— 与修前两条目录探针抛出时同一个去向)。
+ */
+export declare function assertRetiredSchemaAbsent(read: SchemaProbeRead, dialect: SchemaDialect): Promise<void>;
+/** 探针口的池参数:方言与它的池一起走(判别联合 ⇒ 不靠调用方断言「这个池是哪种」)。 */
+export type RetiredSchemaProbeTarget = {
+    readonly dialect: "tidb";
+    readonly pool: MysqlPool;
+} | {
+    readonly dialect: "pg";
+    readonly pool: PgPool;
+};
+/**
+ * **探针口**(退役 schema 唯一的读处):库一连上、**任何 DDL 之前**在一条借来的连接上读一遍,在场 ⇒ 抛 {@link RetiredSchemaPresentError}。本仓唯一调用点 =
+ * `store-backend.ts` 的 `withRetiredSchemaProbe`(SQL 两后端的 `ensureSchema()` 自身:探针先于建表的先后只写在那一处)。**不在包根上**:
+ * 嵌入方经公开序列的 `ensureSchema()` 得到这一问,不需要自己排序列。
+ *
+ * 不取 `ensureSchema` 那把 advisory 锁:本口纯读(列册读),不改任何东西,与别的副本正在跑的建表 / 迁移互不相干 —— 退役 schema 只会被 7.125.x 的迁移删去、
+ * 不会被谁凭空建回。用完即还连接,拒启时连接也已归还。
+ */
+export declare function assertRetiredSchemaAbsentOnPool(target: RetiredSchemaProbeTarget): Promise<void>;
 //# sourceMappingURL=schema-consistency.d.ts.map

package/dist/plugins/schema-consistency.js

@@ -1,5 +1,6 @@
 import { recordEnsureStatements } from "./schema-ensure-legs.js";
 import { readLiveColumns } from "./schema-live-columns.js";
+import { StoreBootRefusalError } from "./store-contracts.js";
 const QUOTES = new Set(["'", '"', "`"]);
 function stripLineComments(sql) {
     let out = "";
@@ -159,4 +160,55 @@ export async function assertSchemaMatchesCode(read, dialect) {
     if (mismatches.length > 0)
         throw new Error(describeSchemaMismatch(dialect, mismatches));
 }
+const RETIRED_SNAPSHOT_TABLE = "snapshot_manifest";
+const RETIRED_STEER_SEAT = { table: "checkpoint", column: "pending_steer" };
+export class RetiredSchemaPresentError extends StoreBootRefusalError {
+    found;
+    code = SCHEMA_MISMATCH_ERROR_CODE;
+    constructor(found) {
+        super(`${SCHEMA_MISMATCH_ERROR_CODE}: this database still carries schema that the one-time migrations of server 7.74.0–7.125.x retired — refusing to start. ` +
+            `Found: ${found.join("; ")}. ` +
+            `Both come from builds that predate those migrations, so this database never booted a build that still carried them — which also means the third one never ran: ` +
+            `ask-origin gates stored under the retired spelling \`unresolvable\` (in task_event.data and in checkpoint.execution_outcome) were not rewritten to \`ancestor_marked\`. ` +
+            `This build carries none of the three and will not guess. ` +
+            `Way out: start a server 7.125.x build once against this database and let its one-time migrations finish (it drops the table and the column and rewrites the spelling; ` +
+            `while the column still holds a steering instruction that can be delivered it refuses and names the rows and its own ways out), then upgrade to this build. ` +
+            `On PostgreSQL this check reads the relation an unqualified name resolves to along search_path, while the 7.125.x migrations look only at current_schema(): ` +
+            `if the table or the checkpoint table carrying the column lives in a schema later on search_path, run the 7.125.x build with that schema first on its search_path ` +
+            `(for example ALTER ROLE <role> SET search_path = <that schema>, <the rest>), then restore the search_path and start this build. ` +
+            `The check behind this refusal is read-only and runs before this build creates any table or rewrites anything: it changed nothing in the database.`);
+        this.found = found;
+        this.name = "RetiredSchemaPresentError";
+    }
+}
+export async function assertRetiredSchemaAbsent(read, dialect) {
+    const live = await readLiveColumns(read, dialect);
+    const found = [];
+    if (live.has(RETIRED_SNAPSHOT_TABLE))
+        found.push(`table ${RETIRED_SNAPSHOT_TABLE} (the retired whole-tree snapshot index)`);
+    if (live.get(RETIRED_STEER_SEAT.table)?.has(RETIRED_STEER_SEAT.column) === true) {
+        found.push(`column ${RETIRED_STEER_SEAT.table}.${RETIRED_STEER_SEAT.column} (the retired single-seat steering column)`);
+    }
+    if (found.length > 0)
+        throw new RetiredSchemaPresentError(found);
+}
+export async function assertRetiredSchemaAbsentOnPool(target) {
+    if (target.dialect === "tidb") {
+        const conn = await target.pool.getConnection();
+        try {
+            await assertRetiredSchemaAbsent(async (sql) => (await conn.query(sql))[0], "mysql");
+        }
+        finally {
+            conn.release();
+        }
+        return;
+    }
+    const client = await target.pool.connect();
+    try {
+        await assertRetiredSchemaAbsent(async (sql) => (await client.query(sql)).rows, "pg");
+    }
+    finally {
+        client.release();
+    }
+}
 //# sourceMappingURL=schema-consistency.js.map

package/dist/plugins/schema-indexes.js

@@ -21,6 +21,8 @@ export const CENTRAL_SCHEMA_INDEXES = [
     { table: "workflow_run", name: "idx_wfrun_scope_created", columns: ["scope", "created_at_ms"] },
     { table: "workflow_run", name: "idx_wfrun_scope_status", columns: ["scope", "status"] },
     { table: "workflow_agent_session", name: "idx_wfagentsess_run", columns: ["run_id"] },
+    { table: "workflow_park_decision", name: "idx_wfparkdec_host", columns: ["host_session_id"] },
+    { table: "workflow_park_decision", name: "idx_wfparkdec_run", columns: ["run_id"] },
     { table: "workflow_completion_inbox", name: "idx_wfinbox_session_seq", columns: ["session_id", "seq"] },
     { table: "workflow_inbox_fence", name: "idx_wffence_until", columns: ["until_ms"] },
     { table: "workflow_notify_journal", name: "idx_wfnotify_acked", columns: ["acked"] },

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

@@ -1,6 +1,6 @@
 import { createHmac } from "node:crypto";
 import { uuidv7 } from "@sema-agent/core";
-import { CONTROL_AND_BIDI_STRIP_RE } from "../text-bidi.js";
+import { stripControlAndBidi } from "@sema-agent/settings-schema";
 import { presignS3CopyUrl, presignS3Url } from "./s3-presign.js";
 import { OBJECT_STORE_IO_TIMEOUT_MS } from "./blob-backend.js";
 export const PRESIGN_MAX_TTL_SEC = 604_800;
@@ -11,7 +11,7 @@ export function scopeSegment(secretKey, scope) {
 }
 export function sanitizeSendFileName(name) {
     const base = (name ?? "").split(/[/\\]/).pop() ?? "";
-    let clean = base.replace(CONTROL_AND_BIDI_STRIP_RE, "").replace(/^\.+/, "").trim();
+    let clean = stripControlAndBidi(base).replace(/^\.+/, "").trim();
     if (clean.length > 128) {
         const dot = clean.lastIndexOf(".");
         const ext = dot > 0 && clean.length - dot <= 16 ? clean.slice(dot) : "";

package/dist/plugins/session-epoch-anchor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The prompt-epoch anchor below a bounded window's floor — `SessionStorage.getEpochAnchor()` for every session storage that
+ * loads a window instead of the whole tree: the two SQL session backends (`tidb-session-storage.ts` / `pg-session-storage.ts`,
+ * the run's wake and the session view alike) and the local leg's session view (`local-session-window.ts`). One reading, three
+ * dialects: each storage hands in only its own page and reads its own rows.
+ *
+ * ## The rule: the store carries the record, the engine reads it
+ * A bounded wake loads `[floor .. leaf]`; when the loaded branch holds no epoch carrier (a rewind cut inside the kept
+ * tail, or compactions written before the engine restated the epoch), the engine's `Session.getPromptEpoch()` asks the
+ * storage for the nearest carrier BELOW the floor and reads it itself. The storage returns that record **as stored**:
+ *  · a `prompt_epoch` entry ⇒ the whole entry (the engine's branch walk reads the whole entry too);
+ *  · a compaction whose `details.promptEpoch` is present ⇒ that restatement;
+ *  · a compaction without a restatement carries nothing ⇒ the scan pages past it, to exhaustion (a session that lived
+ *    across the release that introduced epochs can hold any number of them between the floor and its pin).
+ * The storage never judges the record's shape. The engine answers a current-shape record as a pin and a retired-shape
+ * record by name (`legacy`, with whether it pinned a center artifact) — a storage that normalized the record first would
+ * turn a session pinned under a retired shape into one with no pin, and the engine would then skip the center source's
+ * handling of that pin. A record that is neither is the engine's to read as well (it reads as no record).
+ *
+ * `floorSeq <= 0` (a full load: the walk already reaches the root) or no carrier below the floor ⇒ `undefined`
+ * (a session that predates epochs).
+ *
+ * What "below the floor, newest first" walks is the storage's: the SQL twins page their `session_event` rows by `seq` (their
+ * window is cut by `seq` too); the local window pages the branch path it was cut from.
+ */
+import type { SessionTreeEntry } from "@sema-agent/core";
+/** One row of a scan: its position (`seq`, the keyset cursor). What else the row holds is the storage's — it reads the entry
+ *  out of the row itself ({@link scanEpochAnchor}'s `entryOf`), so a row is read only when the scan reaches it. */
+export interface EpochAnchorRow {
+    readonly seq: string | number;
+}
+/**
+ * Page the rows `seq < beforeSeq` that may carry an epoch record, newest first (an empty page = no older row). A page may hold
+ * other rows too — they carry nothing and the scan passes them.
+ */
+export type EpochAnchorPage<R extends EpochAnchorRow> = (beforeSeq: number) => Promise<readonly R[]>;
+/** The nearest epoch carrier below `floorSeq`, as stored; see the file header. */
+export declare function scanEpochAnchor<R extends EpochAnchorRow>(floorSeq: number, page: EpochAnchorPage<R>, entryOf: (row: R) => SessionTreeEntry): Promise<unknown>;
+//# sourceMappingURL=session-epoch-anchor.d.ts.map

package/dist/plugins/session-epoch-anchor.js

@@ -0,0 +1,22 @@
+export async function scanEpochAnchor(floorSeq, page, entryOf) {
+    if (floorSeq <= 0)
+        return undefined;
+    let cursor = floorSeq;
+    for (;;) {
+        const rows = await page(cursor);
+        if (rows.length === 0)
+            return undefined;
+        for (const row of rows) {
+            const entry = entryOf(row);
+            if (entry.type === "prompt_epoch")
+                return entry;
+            if (entry.type === "compaction") {
+                const details = entry.details;
+                if (typeof details === "object" && details !== null && "promptEpoch" in details && details.promptEpoch !== undefined)
+                    return details.promptEpoch;
+            }
+        }
+        cursor = Number(rows[rows.length - 1].seq);
+    }
+}
+//# sourceMappingURL=session-epoch-anchor.js.map

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

@@ -1,6 +1,8 @@
 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 { OwnerAwareSessionStore } from "../security.js";
 /**
  * Session-store plugin seam.
  *
@@ -43,15 +45,23 @@ export declare function ensureSessionDurable(hostStore: SessionStore, sessionId:
  * [ref] 主动晋升版 ensureChildSessionDurable(cli TiDB 真机撞获:1.263 的只查不迁形在拆店生产形下
  * 恒否决 park——bg 子会话住 subRunner 私有 TTL 店、从不在 host 店,core 收 veto 即 expire checkpoint
  * (14ms~2s)+ settle failed,赎回窗口不存在):
- *   1. 快路:已在 host 店且有真内容 → 直接通过(幂等/重入)。
+ *   0. 属主(S-1770,`delegated-session-owner.ts`):按委派继承律判一次(唯一判据 `judgeDelegatedOwner`)—— 来源集 = 见证的根这一只(调用方交出的委派树根 + 调用方判断那一刻
+ *      读到的根行住客:请求腿 = 本请求经鉴权解析的会话与受理时那一读,`/decide` 赎回腿 = 行上的 `rootSessionId` 与 claim 前后两读的那一位;core 的挂点签名只给子代 id,
+ *      场景层把见证绑进闭包交下来)。此刻根行在而住客不是见证的那一位(删了、同 id 被重新登记)⇒ **拒**(`assertRootStillWitnessed`:不按新住客晋升 / 认领);
+ *      缺席(行上没有根)或根行此刻不在 ⇒ 孤行哨兵。
+ *   1. 快路:已在 host 店且有真内容 → 通过,**前提是那一行的属主按律定得下来**(`settleDelegatedOwner`:记着别的委派树 ⇒ 抛;记着这一棵 ⇒ 按它记录的根、父再判一次
+ *      (与 M23 同读数),无主 ⇒ 认领(CAS 子行,写判断时的读数)、没落下 ⇒ 抛(只有记录委派树的 SQL 店;local 店的行不记委派树 ⇒ 不认领);此刻属主不是律给的那一只 ⇒ 那是别人的同 id 会话,
+ *      不是这只子代的转录 ⇒ 抛 = 停驻否决;与晋升建行前那一道同一只函数)。
  *   2. 晋升:routing.promoteToHost 把子会话整树从私店拷进 host 店(拷贝→私店 forget→路由记 host,
- *      三步见 ForkRoutingSessionStore.promoteToHost)。
- *   3. 复验:同一把 `ensureSessionDurable` 严检(leaf 非空)——晋升产物必须达到与既有校验完全相同的
- *      durable 标准,任何一步失败=如实 reject=veto=pre-153 行为(不放大)。
+ *      三步见 ForkRoutingSessionStore.promoteToHost),宿主行在建行那一笔里带第 0 步的属主;写的是哨兵 ⇒ 写落下之后一行 warn。
+ *   3. 复验:同一把 `ensureSessionDurable` 严检(leaf 非空)+ 同一只属主定夺 —— 晋升产物必须达到与快路完全相同的
+ *      标准,任何一步失败=如实 reject=veto=pre-153 行为(不放大)。
+ * 宿主店必须读得出属主(`delegatedOwnerHostOf`:`ownerOf` + `sessionFaceOf`;记录委派树的店另交 `placementOf` + `claimOwnerless`,两只同在或同缺;生产的 SQL / local 店与缓存包装层都满足),
+ * 否则响亮拒。
  * 调用方纪律与 {@link ensureSessionDurable} 同款:hostStore 必须是 release 非破坏性的真 durable 店
- * (main.ts 的 `config.sessionBackend === "tidb"` 门不变)。
+ * (stage-07 的 `config.sessionBackend === "tidb"` 门不变 —— 该词在 local 后端上同样归一成 `tidb`,所以本腿在 local 宿主店上也跑)。
  */
-export declare function ensureChildSessionDurableWithPromotion(hostStore: SessionStore, routing: {
-    promoteToHost(sessionId: string): Promise<void>;
-}, sessionId: string): Promise<void>;
+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>;
 //# sourceMappingURL=session-store.d.ts.map

package/dist/plugins/session-store.js

@@ -1,5 +1,6 @@
 import { TtlSessionStore } from "@sema-agent/core";
 import { CachingSessionStore } from "./caching-session-store.js";
+import { assertRootStillWitnessed, delegatedOwnerHostOf, readDelegatedOwner, reportWrittenOwner, settleDelegatedOwner, sourceFacesVia, } from "../delegated-session-owner.js";
 export function createSessionStore(config, backend, metrics) {
     if (config.sessionBackend === "tidb") {
         if (!backend)
@@ -22,14 +23,24 @@ export async function ensureSessionDurable(hostStore, sessionId) {
         await hostStore.forget?.(acquired.sessionId);
     }
 }
-export async function ensureChildSessionDurableWithPromotion(hostStore, routing, sessionId) {
+export async function ensureChildSessionDurableWithPromotion(hostStore, routing, 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 (ownerOf / sessionFaceOf), 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.sessionFaceOf));
+    assertRootStillWitnessed(sessionId, root, judged);
+    let promoted = false;
     try {
         await ensureSessionDurable(hostStore, sessionId);
-        return;
     }
     catch {
+        await routing.promoteToHost(sessionId, judged.inherited.owner, judged.tree);
+        await ensureSessionDurable(hostStore, sessionId);
+        promoted = true;
     }
-    await routing.promoteToHost(sessionId);
-    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);
 }
 //# sourceMappingURL=session-store.js.map

package/dist/plugins/shared-memory-store-sql.d.ts

@@ -125,12 +125,18 @@ export interface SqlSharedMemoryStoreOptions {
      *  hope (core puts no cap on the provider's window, so the provider must state its own). */
     maxListLimit?: number;
 }
+/**
+ * WRITE-side store-id admission. The rule is core's own judge ({@link isSharedMemoryStoreId}): a row failing it would be dropped
+ * from every listing — an id the model cannot echo back is worse than an absent one — so we refuse to store it in the first place.
+ * This module keeps no copy of the pattern (nor of the `__` ban): the protocol table's namespace separator is core's to spell.
+ */
 export declare function assertStoreId(storeId: string): void;
 export declare function assertScopeKey(scopeKey: string): void;
 /**
- * WRITE-side document-path admission. Deliberately at least as strict as core's READ-side listing gate
- * (`isListablePath`): a row core would silently drop is refused here where an operator can see it. The
- * ONE rule that is stricter on purpose is the non-BMP refusal — see the header's ORDERING section.
+ * WRITE-side document-path admission: core's own judge ({@link isSharedMemoryDocumentPath} — the SAME predicate core's listing
+ * gate applies, so a row core would silently drop is refused here where an operator can see it), plus the two rules that are
+ * stricter on purpose and are this store's own: the column width, and the non-BMP refusal — see the header's ORDERING section.
+ * This module keeps no copy of core's rule (forbidden characters, segment shape, suffix table).
  */
 export declare function assertDocumentPath(path: string): void;
 /**

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

@@ -1,20 +1,17 @@
-import { SHARED_MEMORY_READ_CAP_BYTES, SharedMemoryStoreError, } from "@sema-agent/core";
+import { isSharedMemoryDocumentPath, isSharedMemoryStoreId, SHARED_MEMORY_READ_CAP_BYTES, SharedMemoryStoreError, } from "@sema-agent/core";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
 const isDupKey = isDupKeyError;
 export const SHARED_MEMORY_SCOPE_TABLE = "shared_memory_scope";
 export const SHARED_MEMORY_STORE_TABLE = "shared_memory_store";
 export const SHARED_MEMORY_ENTRY_TABLE = "shared_memory_entry";
-const STORE_ID_RE = /^[A-Za-z0-9_.-]{1,64}$/;
 const ORG_SCOPE_RE = /^org:\S{1,185}$/;
-const FORBIDDEN_PATH_CHARS = /[\p{Cc}\p{Cf}\p{Co}\p{Cn}\p{Default_Ignorable_Code_Point}\u2028\u2029\\]/u;
-const DOCUMENT_SUFFIXES = [".md", ".txt", ".json", ".jsonl"];
 const PATH_MAX_CHARS = 512;
 const DESCRIPTION_MAX_CHARS = 512;
 const DEFAULT_MAX_LIST_LIMIT = 500;
 export function assertStoreId(storeId) {
-    if (!STORE_ID_RE.test(storeId) || storeId.includes("__")) {
-        throw new Error(`shared-memory store id ${JSON.stringify(storeId)} is not usable: it must match /^[A-Za-z0-9_.-]{1,64}$/ and must not contain "__"`);
+    if (!isSharedMemoryStoreId(storeId)) {
+        throw new Error(`shared-memory store id ${JSON.stringify(storeId)} is not usable: core's shared-memory store-id rule refuses it`);
     }
 }
 export function assertScopeKey(scopeKey) {
@@ -26,18 +23,10 @@ export function assertDocumentPath(path) {
     const refuse = (why) => {
         throw new Error(`shared-memory document path ${JSON.stringify(path)} is not usable: ${why}`);
     };
-    if (!path.startsWith("/"))
-        refuse("it must be absolute (leading \"/\")");
     if (path.length > PATH_MAX_CHARS)
         refuse(`it is ${path.length} UTF-16 units, over the ${PATH_MAX_CHARS} the column stores`);
-    if (FORBIDDEN_PATH_CHARS.test(path))
-        refuse("it carries a control/format/private-use character or a backslash");
-    const segments = path.slice(1).split("/");
-    if (!segments.every((s) => s !== "" && !s.startsWith(".")))
-        refuse("every folder segment must be non-empty and must not start with \".\"");
-    const last = segments.at(-1);
-    if (last === undefined || !DOCUMENT_SUFFIXES.some((s) => last.endsWith(s)))
-        refuse(`the filename must end in ${DOCUMENT_SUFFIXES.join(", ")}`);
+    if (!isSharedMemoryDocumentPath(path))
+        refuse("core's shared-memory document-path rule refuses it");
     for (const ch of path) {
         if (ch.codePointAt(0) > 0xffff)
             refuse("it carries a supplementary-plane character, which would make SQL ordering and core's UTF-16 cursor ordering disagree");