@sema-agent/server 7.142.0 → 7.144.0

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

@@ -1,8 +1,6 @@
 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 OrphanOwnerLog } from "../delegated-session-owner.js";
-import type { OwnerAwareSessionStore } from "../security.js";
 /**
  * Session-store plugin seam.
  *
@@ -43,23 +41,22 @@ export declare function createSessionStore(config: Pick<ServiceConfig, "sessionB
  */
 export declare function ensureSessionDurable(hostStore: SessionStore, sessionId: string): Promise<void>;
 /**
- * core `SubagentToolOptions.background.ensureChildSessionDurable` 的实现体 —— 停驻挂点的**见证**:这只后台子代的转录此刻是 host 店里一只有真内容、
- * 属主按委派继承律定得下来的会话,才放行停驻;任何一步不成立 ⇒ 抛 = 否决(core 收 veto 即 expire checkpoint + settle failed,pre-153 行为,不放大)。
+ * core `SubagentToolOptions.background.ensureChildSessionDurable(sessionId, given)` 的实现体 —— 停驻挂点的**见证**:这只后台子代的转录此刻是 host 店里一只有真内容、
+ * 属主恰是引擎交来的委派树属主(`given.owner`)的会话,才放行停驻;任何一步不成立 ⇒ 抛 = 否决(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`);
- *      缺席(行上没有根)或根行此刻不在 ⇒ 孤行哨兵。
+ * 转录生来就在 host 店 —— 所以这里**只验、不搬、不判属主**:属主是引擎判的(core 7.62.0 [ref] L1:没人派生的 run 读自己那一行、按化身绑一次,原样带给每一层子代;
+ * 复活的子代 = 它自己那一行的属主),placed 行建行那一笔原样记下了它(盒义务 7,三只持久会话店 + `session-ownership.ts` 的 `placedSessionOwnerOf`)。
+ * 挂点不认领、不推断、不收委派树根见证([ref] P-5;本仓的委派继承律在这一写点退役 —— 存量无主 placed 行:SQL 两店由一次性迁移 M23 在窗内回填,本机文件店没有回填臂,见 `local-session-store.ts` 头注)。
+ *   0. 宿主店读不出属主(没有 `headOf`,唯一判法 `headReadOf`)⇒ 响亮拒,一次读都不发。
  *   1. 在不在、有没有真内容:{@link ensureSessionDurable}(`requireExisting` 打开 + 叶子非空 + forget 收尾)。任何失败(不在、空壳、读故障)⇒ 原样上抛 = 否决
- *      (读故障也否决:说不准转录在不在,就不让一次审批押在它上面)。这里**不判它是不是 placed 行**:复活的是旧行时 id 取行上的会话(升级前停驻、当年晋升进来的普通行),
- *      它照样是这只子代的转录;判据只问「host 店里有这份真内容」。
- *   2. 属主定夺(`settleDelegatedOwner`):记着别的委派树 ⇒ 抛;记着这一棵 ⇒ 按它记录的根、父再判一次(与 M23 同读数),无主 ⇒ 认领(CAS 子行,写判断时的读数)、没落下 ⇒ 抛;
- *      此刻属主不是律给的那一只 ⇒ 那是别人的同 id 会话,不是这只子代的转录 ⇒ 抛 = 停驻否决。认领写下的是哨兵 ⇒ 写落下之后一行 warn(`site: "park"`)。
- * 宿主店必须读得出属主(`delegatedOwnerHostOf`:`headOf`;记录委派树的店另交 `placementOf` + `claimOwnerless`,两只同在或同缺;生产的 SQL / local 店与缓存包装层都满足),
- * 否则响亮拒。
+ *      (读故障也否决:说不准转录在不在,就不让一次审批押在它上面)。不判它是不是 placed 行:复活的是旧行时 id 取行上的会话(升级前停驻、当年晋升进来的普通行),
+ *      它照样是这只子代的转录。
+ *   2. 此刻行上的属主 ≠ `given.owner` ⇒ 那是别人的同 id 会话,或这一行在引擎读之后被改写 ⇒ 抛 = 停驻否决(拒句不带任何一方的属主值 —— 它会进停驻否决的错误面)。
+ *      契约只承诺属主值相等(化身不比:复活腿的 `given` 只带属主)。
  */
-export declare function attestChildSessionDurable(hostStore: OwnerAwareSessionStore, sessionId: string, root: DelegationRootWitness | undefined, log: OrphanOwnerLog): Promise<void>;
+export declare function attestChildSessionDurable(hostStore: SessionStore, sessionId: string, given: {
+    readonly owner: string | null;
+}): Promise<void>;
 //# sourceMappingURL=session-store.d.ts.map

package/dist/plugins/session-store.js

@@ -1,6 +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";
+import { headReadOf } from "../session-incarnation.js";
 export function createSessionStore(config, backend, metrics) {
     if (config.sessionBackend === "tidb") {
         if (!backend)
@@ -23,16 +23,15 @@ export async function ensureSessionDurable(hostStore, sessionId) {
         await hostStore.forget?.(acquired.sessionId);
     }
 }
-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`);
+export async function attestChildSessionDurable(hostStore, sessionId, given) {
+    const headOf = headReadOf(hostStore);
+    if (headOf === undefined) {
+        throw new Error(`session "${sessionId}" cannot be parked: the host session store cannot read a session's owner (headOf), so the delegated transcript's owner cannot be checked`);
     }
-    const judged = await readDelegatedOwner(sessionId, root === undefined ? {} : { rootSessionId: root.sessionId }, sourceFacesVia(host.headOf));
-    assertRootStillWitnessed(sessionId, root, judged);
     await ensureSessionDurable(hostStore, sessionId);
-    const settled = await settleDelegatedOwner(host, sessionId, judged.inherited.owner, judged.tree);
-    if (settled.claimed)
-        reportWrittenOwner(log, "park", sessionId, settled.judged ?? judged);
+    if ((await headOf(sessionId))?.owner !== given.owner) {
+        throw new Error(`session "${sessionId}" cannot be parked as this delegated session: the host session store holds a session with this id whose owner is not this delegation tree's owner, ` +
+            "so it does not attest this delegated transcript");
+    }
 }
 //# sourceMappingURL=session-store.js.map

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

@@ -1,7 +1,8 @@
 /**
  * SQL 驱动错误的**方言判别**——「这是不是唯一键冲突」的单一属主([ref] P1-①,病族
  * single-semantic-multi-site-drift)。`sql-escape.ts` / `sql-row-helpers.ts` / `store-contracts.ts`
- * 的同级叶子:零 store 逻辑、零驱动依赖(不 import mysql2/pg),纯谓词。
+ * 的同级叶子:零 store 逻辑、零驱动依赖(不 import mysql2/pg),纯谓词 —— 外加死锁判据唯一的消费形 {@link retryOnDeadlock}
+ * (「撞死锁重来几次」与「什么算死锁」住在一处:上界只有一个数,不在各店各写一个)。
  *
  * ## 为什么必须只有一份
  * 收编前这条谓词在 src/ 手铸 ≥7 处,而且**识别集互相漂移**:一半站点只认 `code === "ER_DUP_ENTRY"`,
@@ -96,6 +97,14 @@ export declare const PG_DEADLOCK_DETECTED_SQLSTATE = "40P01";
  * **MySQL 协议腿**,两方言都认只是为了让店不必自己判引擎。
  */
 export declare function isDeadlockError(dialect: SqlDialect, err: unknown): boolean;
+/** 引擎仲裁之后整段重来的**唯一**上界(全仓每一条「撞死锁就重来」的腿共用这一个数)。8 = 锁形并发套的并发度:缺行首写的 N 路竞争每轮至多多走一轮([ref] 读数 1 成 7 死锁)。 */
+export declare const DEADLOCK_RETRY_LIMIT = 8;
+/**
+ * 「引擎判了死锁 ⇒ 整段重来」的**唯一**写法:有界({@link DEADLOCK_RETRY_LIMIT}),判据 {@link isDeadlockError};用尽 / 其它错误原样抛。
+ * `attempt` 必须整段重做语义等价(读-判-写全在里面的一只事务,或一条幂等语句)。`alsoArbitrated`:店自己认的另一种仲裁产物(例:缺行首写撞主键 ——
+ * 并发的另一只首写赢了,重读即走更新腿),与死锁同族、同一个上界。锁等待超时不在任何一族里(延迟信号,见 {@link isDeadlockError} 的注):它照抛。
+ */
+export declare function retryOnDeadlock<T>(dialect: SqlDialect, attempt: () => Promise<T>, alsoArbitrated?: (err: unknown) => boolean): Promise<T>;
 /** TiDB `ErrEntryTooLarge` (one row's key + value over `txn-entry-size-limit`, 6 MiB by default) — TiDB's own
  *  errno, which mysql2 carries without a symbolic name. */
 export declare const TIDB_ER_ENTRY_TOO_LARGE_ERRNO = 8025;

package/dist/plugins/sql-errors.js

@@ -45,6 +45,19 @@ export function isDeadlockError(dialect, err) {
         return keyOf(err, "code") === PG_DEADLOCK_DETECTED_SQLSTATE;
     return keyOf(err, "errno") === MYSQL_ER_LOCK_DEADLOCK_ERRNO || keyOf(err, "code") === MYSQL_ER_LOCK_DEADLOCK_CODE;
 }
+export const DEADLOCK_RETRY_LIMIT = 8;
+export async function retryOnDeadlock(dialect, attempt, alsoArbitrated) {
+    for (let tries = 0;; tries++) {
+        try {
+            return await attempt();
+        }
+        catch (err) {
+            if (tries < DEADLOCK_RETRY_LIMIT && (isDeadlockError(dialect, err) || alsoArbitrated?.(err) === true))
+                continue;
+            throw err;
+        }
+    }
+}
 export const TIDB_ER_ENTRY_TOO_LARGE_ERRNO = 8025;
 export const MYSQL_ER_NET_PACKET_TOO_LARGE_ERRNO = 1153;
 export const MYSQL_ER_NET_PACKET_TOO_LARGE_CODE = "ER_NET_PACKET_TOO_LARGE";

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

@@ -68,12 +68,13 @@ export interface JsonColumnMember {
  * 同一只投影的**裸表达式**(不带别名)—— 给 `WHERE` / `UPDATE … WHERE` 这种**没有别名位**的地方用。
  *
  * 🔴 存在的唯一理由是「别名位在那里不合法」,**不是**给读腿留第二条路:读腿一律用 {@link jsonColumnText}
- * (别名是它的产物的一部分,理由见那只函数)。今天整仓**两处**消费方,各自的「别名位不合法」都是真的:
+ * (别名是它的产物的一部分,理由见那只函数)。今天整仓**三处**消费方,各自的「别名位不合法」都是真的:
  *  · `one-time-migrations.ts` 的几条改写(M8 / 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**
  *    (`result_json`,因为超字节门的那一支要给 `NULL`),CASE 里面的表达式位上写别名是语法错。
+ *  · 本模块的 {@link jsonColumnTextSha256} —— 投影裹在摘要函数里,**别名属于整条摘要表达式**(产物是摘要不是体)。
  * 而「怎么把一列 JSON 取成文本」这件事整仓只能有一种写法:两种承载(真 JSON 列 / LONGTEXT 别名)在这条
  * 表达式下合成同一只串,迁移的判等、分页腿的取文本因此与读腿的判形**看同一份字节**。
  *
@@ -82,6 +83,20 @@ export interface JsonColumnMember {
  * 误用的落点是真库上当场的 `SqlJsonColumnError("not-text")` 响亮抛(行上没有那个键 ⇒ `undefined`),不是静默。
  */
 export declare function jsonColumnTextExpr(dialect: SqlDialect, column: string, memberKey?: string): string;
+/**
+ * 一列 JSON 的**投影文本的 sha256**(十六进制小写,引擎内算 —— 整只文档不出库),带别名。输入恰是 {@link jsonColumnTextExpr} 那一只投影:
+ * 同一行、同一次读里,本表达式的摘要就是 {@link jsonColumnText} 交给读腿的那串字节的摘要,于是「字节没变 ⇒ 摘要没变」只有一种读法。
+ * MySQL 协议 `SHA2(<文本>, 256)`(TiDB / MySQL / MariaDB 都认);PG `encode(sha256(convert_to(<文本>, 'UTF8')), 'hex')`(PG 11+)。
+ *
+ * 读者今天一处:`checkpoint-store-sql.ts` 的停驻行投影记忆(运维队列 / 调度视图对一份停驻行字节的判决按 (摘要, 引擎构建) 记,
+ * 记忆命中就不拉整只文档)。产物是摘要不是体,所以它**不是**体的第二条投影路;回读走 {@link readJsonColumnTextSha256}。
+ */
+export declare function jsonColumnTextSha256(dialect: SqlDialect, column: string, as: string): string;
+/**
+ * {@link jsonColumnTextSha256} 那一格的回读:恒是 64 位十六进制小写串。别的一切(键不在 = 读腿漏了投影;串形不对 = 驱动换了行为)都是**码坏**,
+ * 响亮抛 —— 不当作「这一行没有摘要」退成每次整行读(那会让记忆静默失效,代价无声地涨回去)。
+ */
+export declare function readJsonColumnTextSha256(cell: unknown, where: string): string;
 /**
  * 一次读回失败的**种别**(店层码,**闭集**;运行期词表在这里,类型从它推导 —— 一张词表只有一个写者):
  *  · `not-text` —— 拿到的不是串 = **读腿漏了投影**,那是**码的问题不是数据的问题** ⇒ 响亮的程序错,
@@ -114,7 +129,12 @@ export declare class SqlJsonColumnError extends Error {
     readonly problem: SqlJsonColumnProblem;
     /** 出事的坐标(`<table>.<column> for <identity>`)—— 进错误文案,让运维知道去看哪一行。 */
     readonly where: string;
-    constructor(problem: SqlJsonColumnProblem, where: string, detail: string);
+    /**
+     * `malformed` 时形读者交出的「它不认得的键」({@link JsonColumnShapeBad.unknownKeys};别的种别 / 读者说不出 ⇒ 空)—— 体是更新的写者写下的那一形的判据
+     * (例:local 数据根的严格边档据它把拒句点名成「比本构建新」)。判词只有形读者一个写者,本类原样携带。
+     */
+    readonly unknownKeys: readonly string[];
+    constructor(problem: SqlJsonColumnProblem, where: string, detail: string, unknownKeys?: readonly string[]);
 }
 /** 形读者认了:带上收窄后的值。 */
 export interface JsonColumnShapeOk<T> {
@@ -125,6 +145,8 @@ export interface JsonColumnShapeOk<T> {
 export interface JsonColumnShapeBad {
     readonly value?: undefined;
     readonly problem: string;
+    /** 读者因为**不认得**而拒的键(去重、排序;没有 / 读者说不出 ⇒ 缺)—— 更新的写者给这一形加了位。{@link decodeJsonColumn} 原样交给 {@link SqlJsonColumnError.unknownKeys}。 */
+    readonly unknownKeys?: readonly string[];
 }
 /** {@link JsonColumnReader} 的答复。 */
 export type JsonColumnShape<T> = JsonColumnShapeOk<T> | JsonColumnShapeBad;

package/dist/plugins/sql-json-column.js

@@ -20,15 +20,30 @@ export function jsonColumnTextExpr(dialect, column, memberKey) {
     }
     return dialect === "pg" ? `(${column}::jsonb -> '${memberKey}')::text` : `CAST(JSON_EXTRACT(${column}, '$.${memberKey}') AS CHAR)`;
 }
+export function jsonColumnTextSha256(dialect, column, as) {
+    if (!MEMBER_ALIAS_RE.test(as)) {
+        throw new Error(`jsonColumnTextSha256: alias ${JSON.stringify(as)} must be a lower-case bare identifier — PostgreSQL folds unquoted aliases to lower case, so any other spelling would give the two dialects different row keys`);
+    }
+    const text = jsonColumnTextExpr(dialect, column);
+    return dialect === "pg" ? `encode(sha256(convert_to(${text}, 'UTF8')), 'hex') AS ${as}` : `SHA2(${text}, 256) AS ${as}`;
+}
+const SHA256_HEX_RE = /^[0-9a-f]{64}$/;
+export function readJsonColumnTextSha256(cell, where) {
+    if (typeof cell === "string" && SHA256_HEX_RE.test(cell))
+        return cell;
+    throw new Error(`${where}: expected a lower-case sha256 hex digest from the read leg, got ${cell === undefined ? "no such key (the SELECT dropped the projection)" : typeof cell} — refusing rather than guess`);
+}
 export const SQL_JSON_COLUMN_PROBLEMS = ["not-text", "not-json", "malformed"];
 export class SqlJsonColumnError extends Error {
     problem;
     where;
-    constructor(problem, where, detail) {
+    unknownKeys;
+    constructor(problem, where, detail, unknownKeys = []) {
         super(`${where}: ${detail}`);
         this.name = "SqlJsonColumnError";
         this.problem = problem;
         this.where = where;
+        this.unknownKeys = unknownKeys;
     }
 }
 function describeBody(body) {
@@ -53,7 +68,7 @@ export function decodeJsonColumn(text, read, where) {
     }
     const shape = read(body);
     if (shape.problem !== undefined) {
-        throw new SqlJsonColumnError("malformed", where, `carries ${describeBody(body)} that this store cannot read (${shape.problem}) — refusing rather than serve it as an empty/partial value`);
+        throw new SqlJsonColumnError("malformed", where, `carries ${describeBody(body)} that this store cannot read (${shape.problem}) — refusing rather than serve it as an empty/partial value`, shape.unknownKeys);
     }
     return shape.value;
 }
@@ -85,8 +100,28 @@ export function assertJsonColumnWritable(text, read, where) {
 export function createZodColumnReader(schema) {
     return (body) => {
         const parsed = schema.safeParse(body);
-        return parsed.success ? { value: parsed.data } : { problem: parsed.error.message };
+        if (parsed.success)
+            return { value: parsed.data };
+        const unknownKeys = unrecognizedKeysOf(parsed.error.issues);
+        return { problem: parsed.error.message, ...(unknownKeys.length > 0 ? { unknownKeys } : {}) };
+    };
+}
+function unrecognizedKeysOf(issues) {
+    const keys = new Set();
+    const walk = (list) => {
+        for (const issue of list) {
+            if (issue.code === "unrecognized_keys")
+                for (const key of issue.keys)
+                    keys.add(key);
+            else if (issue.code === "invalid_union")
+                for (const branch of issue.errors)
+                    walk(branch);
+            else if (issue.code === "invalid_key" || issue.code === "invalid_element")
+                walk(issue.issues);
+        }
     };
+    walk(issues);
+    return [...keys].sort();
 }
 export function createObjectColumnReader() {
     return (body) => (isJsonObject(body) ? { value: body } : { problem: "expected a JSON object" });

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

@@ -1,6 +1,6 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import type { SessionStore, SessionPolicyStore, FileHistoryStore, WorkflowJournalStore, ToolResultStore, SessionCaptureRecordStore, UsageWindowStore } from "@sema-agent/core";
+import type { SessionStore, SessionPolicyStore, FileHistoryStore, FileHistoryBlobExchange, FileHistoryError, WorkflowJournalStore, ToolResultStore, SessionCaptureRecordStore, UsageWindowStore } from "@sema-agent/core";
 import { type OutcomeSink } from "./file-outcome-sink.js";
 import { type InboxWarn } from "./workflow-run-store-sql.js";
 import { FileRunStore } from "./file-run-store.js";
@@ -60,37 +60,37 @@ export type ServiceSessionPolicyStore = SessionPolicyStore;
  *  carry (optional so the local lane's core `FileFileHistoryStore` still fits). Replaces the retired E19
  *  whole-tree `ServiceFileSnapshotStore` ([ref]: the boundary covers the TRACKED set only — files this
  *  session edited; there is no whole-tree manifest anymore). Also the 2c history-transfer store
- *  (exportHistory/importHistory + the blob negotiation faces below). */
+ *  (exportHistory/importHistory + the blob exchange below). */
 /**
- * The 2c `putBlob` answer: core's `FileHistoryResult` plus ONE arm — the SQL blob judge refused the blob on the connection that
- * would have written it ({@link import("./blob-backend.js").BlobTooLargeError}, code `blob_too_large_for_sql`). `PUT /sync/blobs`
- * answers that arm 413 (the store's sentence, plus the machine-readable `wallSource` = where the cap came from) and every other failure 502 (retryable).
+ * The SQL twins' blob exchange — core's {@link FileHistoryBlobExchange} group (`put` / `get` / `has`, all three or none, read only
+ * through `blobExchangeOf` in `session-sync.ts`, which defers to core's judge) with ONE narrowing: a `put` refusal may carry
+ * `blobCap`, the SQL blob judge's refusal on the connection that would have written the blob
+ * ({@link import("./blob-backend.js").BlobTooLargeError}). Present ⟺ that refusal; `PUT /sync/blobs` answers it 413
+ * `blob_too_large_for_sql` (the judge's sentence, plus the machine-readable `wallSource` = where the cap came from). The content-address
+ * refusal is core's own (`adopt_failed`, `permanence: "terminal"`, nothing stored); every other failure is a write fault the route answers 502.
  */
-export type SyncBlobPutResult = import("@sema-agent/core").FileHistoryResult | {
+export type SqlBlobPutResult = {
+    readonly ok: true;
+} | {
     readonly ok: false;
-    readonly error: {
-        readonly code: import("./blob-backend.js").BlobTooLargeError["code"];
-        readonly message: string;
-        readonly wallSource: import("./blob-backend.js").SqlBlobCapReading["source"];
+    readonly error: FileHistoryError & {
+        readonly blobCap?: {
+            readonly wallSource: import("./blob-backend.js").SqlBlobCapReading["source"];
+        };
     };
 };
+export interface ServiceBlobExchange extends FileHistoryBlobExchange {
+    put(hash: string, bytes: Uint8Array): Promise<SqlBlobPutResult>;
+}
 export type ServiceFileHistoryStore = FileHistoryStore & {
-    /** 2c sync blob-face marker — see SqlFileHistoryStore.syncBlobFaces (codex R2-high: name-probing
-     *  `putBlob` on an arbitrary store collides with the local core store's PRIVATE void helper). */
-    syncBlobFaces?: true;
+    /** The blob exchange (SQL twins only; core's local File store carries none). Narrowed per {@link ServiceBlobExchange}. */
+    readonly blobExchange?: ServiceBlobExchange;
     /** E21 purge / overwrite-dst sync wipe: drop the WHOLE scope incl. v1 baselines + DV-14 markers
      *  (`reap(scope, [])` deliberately retains those while the scope lives — not a purge). SQL twins only. */
     deleteBySession?(scope: string): Promise<number>;
     /** Async byte-GC for the file_history_blob domain (orphans left by reap/purge/lost mint races; grace-window
      *  protected — never a synchronous external-store delete). Reaper-driven; SQL twins only. */
     sweepOrphanBlobs?(): Promise<number>;
-    /** 2c blob negotiation: upload one content-addressed blob ahead of importHistory. SQL twins only. */
-    putBlob?(hash: string, bytes: Uint8Array): Promise<SyncBlobPutResult>;
-    /** 2c blob read face (scope-checked by the route against the session's history graph). SQL twins only. */
-    getBlob?(hash: string): Promise<Uint8Array | undefined>;
-    /** The subset of `hashes` already present — a cheap SQL INDEX probe (the import presence pre-check,
-     *  never N full getBlob GETs). SQL twins only. */
-    hasBlobs?(hashes: string[]): Promise<Set<string>>;
 };
 /** SVC-2 (core CORE-7) WorkflowJournalStore — core's interface PLUS the service `deleteByRun` (GC extra). tidb/pg =
  *  durable SQL twins (cross-replica resume journal); local = the service {@link FileWorkflowJournalStore}
@@ -128,15 +128,10 @@ export type CheckpointStoreFull = TiDBCheckpointStore | PgCheckpointStore | Loca
 /** The full tool-result store: core `ToolResultStore` + the service maintenance extras. The SQL twins carry
  *  both extras; the LOCAL lane returns core's `FileToolResultStore` (core 1.219 — durable across a
  *  process restart, the TOC "ReadToolResult(ref) 恒空" fix) which since core 5.28.0 carries `deleteBySession`
- *  (owner sidecar 判属主,无边车存量计 unattributable 不删)but still NOT `reapOlderThan` — consumers must
- *  optional-call (`store.reapOlderThan?.()`,local 上恒 no-op)。(R5 复扫纠:旧句「carries NEITHER」自
- *  core 5.28 起半假——本类型注是消费方第一落点,与 LocalBackend 内部注必须同真。)
+ *  (owner sidecar 判属主,无边车存量计 unattributable 不删)and since core 7.61.0 the age bound `reap(now, { maxAgeMs })`
+ *  — both are core `ToolResultStore`'s own optional members, so consumers optional-call them (`store.reap?.(…)`).
  *  Structural (not a nominal union) so all three backends flow through one seam. */
-export type ToolResultStoreFull = ToolResultStore & {
-    /** TTL sweep (SQL twins only): purge rows older than the cutoff. Local file store omits it (CC posture:
-     *  a single user's tool-result files persist like transcripts; bounded by being text previews). */
-    reapOlderThan?(cutoffMs: number): Promise<number>;
-};
+export type ToolResultStoreFull = ToolResultStore & {};
 /** Cross-replica counter twins expose the write-behind lifecycle (startRefresh/stop) main.ts drives. */
 export type BreakerStateStore = TiDBBreakerState | PgBreakerState;
 export type CostQuotaStore = TiDBCostQuota | PgCostQuota;

package/dist/plugins/store-backend.js

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { createCorruptReadSeat, createDurableAbsenceSeat } from "../observability/corrupt-read-seat.js";
 import { createLogger } from "../observability/logger.js";
 import { join } from "node:path";
+import { existsSync } from "node:fs";
 import { AdoptionError, FileStorageBackend } from "@sema-agent/core";
 import { FileWorkflowJournalStore } from "@sema-agent/core";
 import { fileSessionCaptureRecordStore } from "@sema-agent/core";
@@ -58,7 +59,8 @@ 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 { createFilePermissionRuleStores } from "./permission-rule-store-file.js";
+import { FILE_PERMISSION_RULE_DIR, createFilePermissionRuleStores } 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";
@@ -163,7 +165,7 @@ class TiDBBackend {
     breaker(onWriteFail) { return new TiDBBreakerState(this.pool, onWriteFail); }
     costQuota(limitMicroUsd, windowMs, onDegraded) { return new TiDBCostQuota(this.pool, limitMicroUsd, windowMs, undefined, onDegraded, this.config.dbQueryTimeoutMs); }
     rateLimiter(limit, onDegraded) { return new TiDBRateLimiter(this.pool, limit, undefined, undefined, onDegraded, this.config.dbQueryTimeoutMs); }
-    session() { return new TiDBSessionStore(this.pool, { log: createLogger(this.config.logLevel), retention: sqlStoreRetention(this.config.retentionSweep) }); }
+    session() { return new TiDBSessionStore(this.pool, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
     adoptionLog() { return new TiDBAdoptionLogStore(this.pool); }
     mysqlPool() { return this.pool; }
     pgPool() { return undefined; }
@@ -217,7 +219,7 @@ class PgBackend {
     breaker(onWriteFail) { return new PgBreakerState(this.pool, onWriteFail); }
     costQuota(limitMicroUsd, windowMs, onDegraded) { return new PgCostQuota(this.pool, limitMicroUsd, windowMs, undefined, onDegraded, this.config.dbQueryTimeoutMs); }
     rateLimiter(limit, onDegraded) { return new PgRateLimiter(this.pool, limit, undefined, undefined, onDegraded, this.config.dbQueryTimeoutMs); }
-    session() { return new PgSessionStore(this.pool, { log: createLogger(this.config.logLevel), retention: sqlStoreRetention(this.config.retentionSweep) }); }
+    session() { return new PgSessionStore(this.pool, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
     adoptionLog() { return new PgAdoptionLogStore(this.pool); }
     mysqlPool() { return undefined; }
     pgPool() { return this.pool; }
@@ -292,12 +294,18 @@ class LocalBackend {
             : (plane) => fileSessionCaptureRecordStore(plane?.controlDir ?? ownControlDir);
     }
     async ensureSchema() {
+        await this.sessionStore.assertStrictSidecarsReadable();
         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);
+        }
         return {
             ...NO_SQL_MIGRATIONS,
             holderDeathCodeRowsBackfilled,
@@ -310,6 +318,7 @@ class LocalBackend {
             localArchivesKeptStamped: archives.keptStamped,
             localArchivesUnreadable: archives.unreadable,
             localArchiveSnapshotsRecovered: archives.snapshotsRecovered,
+            ...importedLayerRoot,
         };
     }
     async close() {

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

@@ -578,6 +578,24 @@ export interface LatestRunRef {
 }
 /** 引擎对一条腿实际挂上的记忆读集的观测(core `TaskResult.effectiveMemoryScopes` 的值;core 包根不单独导出这只型,从结果型取)。 */
 export type EffectiveMemoryScopes = NonNullable<PersistedTaskResult["effectiveMemoryScopes"]>;
+/**
+ * [ref] —— **空观测**的因由(闭集;词表属主 = 本文件,唯一铸点 = {@link settledLegObservationOf})。两词都只说**那条已结腿的记录里有什么**,不猜它为什么停 ——
+ * 停因的真源是那一条 run 自己的终局(`GET /v1/runs/:id` 的 `status` / `errorCode`),这里不复述第二份:
+ *  · `run_result_missing`    —— 记录里**没有结果**:本服务结算它时手里没有引擎的结果(持有它的实例丢了被收割、腿在引擎答出之前抛),或收割时写空了它(停驻过期被收割 ——
+ *    [ref] 律:收割把停驻结果写空,停驻时那份结果里的观测随之不在;本读口不另存一份);
+ *  · `run_result_unobserved` —— 记录里**有结果、结果里没有观测**:引擎的律是「缺席 ⇔ prepare 没走完」(引擎在准备阶段拒了 / 失败了它),
+ *    另两形同答 —— 引擎答出之前就被取消、由本服务铸的取消终局,与比这一观测更早的引擎写下的结果。
+ * 自铸 wire 值登记 = `trace/self-minted-wire.ts` 的 `sessionMemoryUnobservedReason`(`satisfies Record<…>`:加 / 删一个词而登记没跟 ⇒ tsc 红)。
+ */
+export declare const MEMORY_OBSERVATION_ABSENT_REASONS: readonly ["run_result_missing", "run_result_unobserved"];
+export type MemoryObservationAbsentReason = (typeof MEMORY_OBSERVATION_ABSENT_REASONS)[number];
+/** [ref] —— 空观测记号:与引擎三态同一只字段、同一个判别位 `state`(闭集加一词 `absent`;引擎哪天自己长出同名一态 ⇒ `trace/core-keyset-guard.ts` 的跨界钉当场红)。 */
+export interface AbsentMemoryObservation {
+    readonly state: "absent";
+    readonly reason: MemoryObservationAbsentReason;
+}
+/** 一条已结腿的记忆观测 —— 四态闭集:引擎铸的三态原样(`mounted` / `memoryless` / `none`)∪ 空观测({@link AbsentMemoryObservation})。消费方按 `state` 穷举分支。 */
+export type LegMemoryObservation = EffectiveMemoryScopes | AbsentMemoryObservation;
 /**
  * 「这个会话**最近一条已结腿**与它的记忆观测」的窄读面(run 店的 `latestMemoryObservationForSession` 的回值)—— 会话记忆同步触发口
  * (`POST /v1/sessions/:id/memory/sync`)的**会话读集**只读这一只:读集 = 最近一条已结腿结果里引擎铸的观测(引擎一处铸、随 run 行持久;路由不重铸 spec)。
@@ -586,17 +604,23 @@ export type EffectiveMemoryScopes = NonNullable<PersistedTaskResult["effectiveMe
  *  · 已结 = {@link isTerminalRunStatus}(成功 / 非成功终局;在飞与停在门上的腿还占着会话的认领,不算;读不懂的词同向保守判「未结」)。两孪生调这只谓词;
  *    SQL 两方言按本文件的惯例写字面词集 `status IN ('completed','failed','blocked')`,与谓词的同源由 `test/source-hygiene-gate.test.ts` 的方言对 parity 门钉;
  *    取最近一条(排序口径与 {@link LatestRunRef} 逐字同一句:`created_at DESC, task_id DESC`);
- *  · `effectiveMemoryScopes` = 那一条腿结果里的观测**原样**(三态:`mounted` / `memoryless` / `none`,读法归调用方);
- *  · 那一条腿结了而**没有观测**(结果为空 / 结果里没有这一键 —— prepare 没走完)⇒ 交回那一条、观测缺席,**不往更早的腿找**
- *    (读集是「最近一条已结腿」的,不是「最近一条有观测的腿」的)。
+ *  · `observation` = 那一条腿的观测,**恒在场**,四态之一({@link LegMemoryObservation}):结果里有引擎的观测 ⇒ 原样;没有 ⇒ 空观测记号,因由说记录里有什么
+ *    ({@link MemoryObservationAbsentReason})。**不往更早的腿找**:读集是「最近一条已结腿」的,不是「最近一条有观测的腿」的 —— 空观测是那一条的值,不是去找下一条的信号。
+ * 空观测**不落盘**:它是行上已有事实(结果列、结果里那一键的缺席)的一只纯函数,铸在读口({@link settledLegObservationOf},三店共用);落一份 = 第二真源
+ * (与引擎「缺席 ⇔ prepare 没走完」那条律并存、两份要对得上),且终局写口二十余处、收割器整行写空结果的 SQL 两方言语句与存量行都得各补一份。
  * 结果列读不出 ⇒ 抛(与 `getRun` 同一个失败方向:不把一条结了的腿当成没有结果)。
  */
 export interface SettledLegMemoryObservation {
     readonly taskId: string;
-    readonly effectiveMemoryScopes: EffectiveMemoryScopes | undefined;
+    readonly observation: LegMemoryObservation;
 }
-/** {@link SettledLegMemoryObservation} 的一只投影(三只实现共用):一条已结腿的结果 → 读口的回值。 */
+/** {@link SettledLegMemoryObservation} 的**唯一铸点**(三只实现共用):一条已结腿的结果 → 读口的回值(空观测记号只在这里铸)。 */
 export declare function settledLegObservationOf(taskId: string, result: PersistedTaskResult | null): SettledLegMemoryObservation;
+/**
+ * run 店账本的一条事件 —— 三只孪生的 `getEvents` 都交出写口收下的那一形(按 seq 升序、每读一份新拷贝)。存形是孪生的私事、读者看不见:
+ * File 孪生把 `wiring_manifest` 行的容器段按会话存成块(`<root>/run-blobs/<会话>.jsonl`,律与唯一编解码 = `wiring-section-codec.ts`),行里只留引用,
+ * 读口装回整帧;装不回的那一帧不交出(F 类留痕),绝不交出缺段的清单。SQL / Memory 孪生整帧存。
+ */
 export interface RunEvent {
     seq: number;
     type: string;

package/dist/plugins/store-contracts.js

@@ -56,7 +56,10 @@ export function sessionTempoOfRunStatus(lastStatus) {
 export function runProvenElsewhere(run, thisInstanceId) {
     return typeof run.instanceId === "string" && run.instanceId.length > 0 && thisInstanceId !== undefined && run.instanceId !== thisInstanceId;
 }
+export const MEMORY_OBSERVATION_ABSENT_REASONS = ["run_result_missing", "run_result_unobserved"];
 export function settledLegObservationOf(taskId, result) {
-    return { taskId, effectiveMemoryScopes: result?.effectiveMemoryScopes ?? undefined };
+    if (result === null)
+        return { taskId, observation: { state: "absent", reason: "run_result_missing" } };
+    return { taskId, observation: result.effectiveMemoryScopes ?? { state: "absent", reason: "run_result_unobserved" } };
 }
 //# sourceMappingURL=store-contracts.js.map

package/dist/plugins/task-attachment-store.d.ts

@@ -23,7 +23,7 @@
  *  - 布尔列:无(遵 1.287.0 归一约定,若未来加,PG 用 SMALLINT 0/1)。
  *  - 绑定:`bind` 把行钉到 sessionId,两条律都在店里、都不是先读后写(契约见 {@link TaskAttachmentStore.bind}):
  *    **一经绑定不再改绑**(UPDATE 谓词只放行未绑的行与已绑本会话的行,行级原子;同会话重绑 —— 首交重试、续跑腿重放存量体 —— 不改 `bound_at_ms`);
- *    **一只会话一只种子**(未绑的项目包只在这只会话还没有项目包时绑上:SQL 两方言是锚行加锁的一只事务,进程内的店是一段不被打断的判与改:内存店同一段同步,local 店的变更口同排一条串行段、bind 判在副本上、落成的行才合回)。
+ *    **一只会话一只种子**(未绑的项目包只在这只会话还没有项目包时绑上:SQL 两方言是表上的唯一键 —— 种子键 `seed_session_id`(项目包行的会话,由引擎从 `mime` 与 `session_id` 推导)上的 `uq_att_seed`,第二只项目包的绑定被引擎拒;进程内的店是一段不被打断的判与改:内存店同一段同步,local 店的变更口同排一条串行段、bind 判在副本上、落成的行才合回)。
  *    同 session 多 task 共享自然成立(listBySession 是物化输入)。
  *    未绑定行 = 上传后从未被任何 task 引用 ⇒ reapUnbound(TTL)。
  */
@@ -259,7 +259,7 @@ export declare class PgTaskAttachmentStore implements TaskAttachmentStore {
     private readonly bytes;
     private readonly db;
     private readonly q;
-    /** 收池(不是裸 `PgQueryFn`):绑定的种子腿要一只事务({@link bindOnSql}),事务要一条借出的连接。 */
+    /** 收池:绑定({@link bindOnSql})走与 TiDB 孪生同一只驱动形({@link pgDriver})。 */
     constructor(pool: PgPool, bytes: AttachmentBytesStore);
     put(rec: TaskAttachmentRecord & {
         content: Uint8Array;