@sema-agent/server 7.137.0 → 7.138.0

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

@@ -1,13 +1,13 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import type { MailboxAckResult, MailboxAppendMessage, MailboxLease, MailboxStore } from "@sema-agent/core";
+import type { MailboxAckResult, MailboxAppendMessage, MailboxDecision, MailboxDecisionOutcome, MailboxLease, MailboxStore } from "@sema-agent/core";
 import { type IndexSpec } from "./ensure-index.js";
 import type { MailboxRecipientLifecycle, MailboxRecipientTombstone } from "./mailbox-recipient-lifecycle.js";
 export declare const MAILBOX_TABLE = "mailbox";
 export declare const MAILBOX_MSG_TABLE = "mailbox_message";
 /** [ref] 收件人墓碑表(预删除态的**唯一**真源;形与理由见 `mailbox-recipient-lifecycle.ts` 模块头)。
- *  🔴 为什么是**新表**而不是给 `mailbox` 加两列:加列走的是本仓「删库重建、不开 ALTER seam」那条政策
- *  (存量库首跑必红);而 `CREATE TABLE IF NOT EXISTS` 一张新表在存量库上零破坏、零运维动作。语义上也更干净
+ *  🔴 为什么是**新表**而不是给 `mailbox` 加两列:加列走的是本仓「启动 DDL 不开 ALTER seam」那条政策
+ *  (存量库缺列起服列册对账拒启、要运维先手工 `ALTER`);而 `CREATE TABLE IF NOT EXISTS` 一张新表在存量库上零破坏、零运维动作。语义上也更干净
  *  —— `mailbox` 行是**盒**事实(next_seq / lease),墓碑是**收件人**事实,两者的生命周期本来就不同
  *  (`drop` 同时终结两者 —— 墓碑随箱亡,理由全文见 `mailbox-recipient-lifecycle.ts` 模块头)。 */
 export declare const MAILBOX_TOMBSTONE_TABLE = "mailbox_tombstone";
@@ -69,6 +69,12 @@ export declare class TiDBMailboxStore implements MailboxStore, MailboxRecipientL
     append(scope: string, handle: string, msg: MailboxAppendMessage): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
     ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<MailboxAckResult>;
+    /**
+     * core 7.57.0 #972b —— 一条记录的留置决定从 `expect`(缺席 = 从未 held)移到 `next`:比较并设置,对每一次别的移动与 `ack` 原子
+     * (锁序与 ack / drop / reap 同为「盒行 → 消息行」,当前读);**不受租约围栏**(人从哪个终端答都行)。坏调用(词不在闭集 / seq 不是正整数 /
+     * 决定律不许的边)先于键判官与任何副作用以 `mailbox.invalid_decision_move` 拒(core 的唯一验证器 `assertMailboxDecisionMove`);判官拒的键没有箱 ⇒ gone。
+     */
+    moveDecision(scope: string, handle: string, seq: number, expect: MailboxDecision | undefined, next: MailboxDecision): Promise<MailboxDecisionOutcome>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;
     peekCount(scope: string, handle: string): Promise<number>;
     drop(scope: string, handle: string): Promise<void>;
@@ -93,6 +99,8 @@ export declare class PgMailboxStore implements MailboxStore, MailboxRecipientLif
     append(scope: string, handle: string, msg: MailboxAppendMessage): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
     ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<MailboxAckResult>;
+    /** core 7.57.0 #972b 留置决定的比较并设置(TiDB 孪生同注:验证先于一切、锁序盒行 → 消息行、不受租约围栏、判官拒的键 ⇒ gone)。 */
+    moveDecision(scope: string, handle: string, seq: number, expect: MailboxDecision | undefined, next: MailboxDecision): Promise<MailboxDecisionOutcome>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;
     peekCount(scope: string, handle: string): Promise<number>;
     drop(scope: string, handle: string): Promise<void>;

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

@@ -1,5 +1,5 @@
 import { isUtf8 } from "node:buffer";
-import { MAILBOX_INVALID_PEER_META_CODE, MAILBOX_TOMBSTONED_RECIPIENT_CODE, MailboxStoreError, readMailboxPeerMeta } from "@sema-agent/core";
+import { MAILBOX_INVALID_PEER_META_CODE, MAILBOX_RECORD_ID_MAX_CHARS, MAILBOX_TOMBSTONED_RECIPIENT_CODE, MailboxStoreError, assertMailboxDecisionMove, judgeMailboxAppendById, readMailboxAppend, readMailboxPeerMeta, readStoredMailboxDecision } from "@sema-agent/core";
 import { pgHasUnstorable, pgSanitizeText, PgUnstorableError } from "./pg-safe-json.js";
 import { isWellFormedUnicode } from "../principal-jwt.js";
 import { ensureIndexes } from "./ensure-index.js";
@@ -25,15 +25,36 @@ export const MAILBOX_KEY_MAX_UTF8_BYTES = 190;
 export function mailboxKeyProblem(what, v) {
     if (what === "scope" && (v === undefined || v === ""))
         return "MailboxStore: refusing a message without a scope (an empty scope addresses no box)";
+    const unaddressable = byteExactIdentityProblem(what, v);
+    if (unaddressable !== undefined)
+        return unaddressable;
+    if (Buffer.byteLength(v, "utf8") > MAILBOX_KEY_MAX_UTF8_BYTES) {
+        return `MailboxStore: ${what} exceeds the ${MAILBOX_KEY_MAX_UTF8_BYTES}-byte key column (refusing — a truncated key would desync from its byte-exact lookups)`;
+    }
+    return undefined;
+}
+function byteExactIdentityProblem(what, v) {
     if (!isWellFormedUnicode(v))
         return `MailboxStore: ${what} is not well-formed Unicode (lone surrogate) (refusing — the driver would store it as U+FFFD and alias a different key)`;
     if ([...v].some((ch) => ch.charCodeAt(0) < 0x20 || ch.charCodeAt(0) === 0x7f))
         return `MailboxStore: ${what} contains control characters (refusing — identity keys must be byte-exact addressable)`;
-    if (Buffer.byteLength(v, "utf8") > MAILBOX_KEY_MAX_UTF8_BYTES) {
-        return `MailboxStore: ${what} exceeds the ${MAILBOX_KEY_MAX_UTF8_BYTES}-byte key column (refusing — a truncated key would desync from its byte-exact lookups)`;
-    }
     return undefined;
 }
+function appendSnapshot(msg) {
+    const rec = readMailboxAppend(msg);
+    if (rec.id !== undefined) {
+        const problem = byteExactIdentityProblem("record id", rec.id);
+        if (problem !== undefined)
+            throw new Error(problem);
+    }
+    return rec;
+}
+function replayedSeq(held, scope, handle, logger, asStored) {
+    return judgeMailboxAppendById(rowsToMessages(held, scope, handle, logger), asStored);
+}
+function asUtf8Stored(v) {
+    return Buffer.from(v, "utf8").toString("utf8");
+}
 function assertMailboxKey(what, v) {
     const problem = mailboxKeyProblem(what, v);
     if (problem !== undefined)
@@ -130,6 +151,7 @@ function rowsToMessages(rows, scope, handle, logger) {
         };
         const hopChain = read("hop_chain", () => decodeHopChain(r.hop_chain, r.seq));
         const peerMeta = read("peer_meta", () => decodePeerMeta(r.peer_meta, r.seq));
+        const decision = decisionOfColumn(r.decision);
         out.push({
             seq: Number(r.seq),
             ...(r.from_id !== null && r.from_id !== undefined ? { from: bufToStr(r.from_id) } : {}),
@@ -137,10 +159,21 @@ function rowsToMessages(rows, scope, handle, logger) {
             sentAt: Number(r.sent_at_ms),
             ...(hopChain !== undefined ? { hopChain } : {}),
             ...(peerMeta !== undefined ? { peerMeta } : {}),
+            ...(decision !== undefined ? { decision } : {}),
+            ...(r.record_id !== null && r.record_id !== undefined ? { id: String(r.record_id) } : {}),
         });
     }
     return out;
 }
+function decisionOfColumn(raw) {
+    return raw === null || raw === undefined ? undefined : readStoredMailboxDecision(bufToStr(raw));
+}
+function decisionMoveVerdict(rows, expect) {
+    if (rows.length === 0)
+        return { ok: false, current: "gone" };
+    const current = decisionOfColumn(rows[0].decision);
+    return current === expect ? "write" : { ok: false, current: current ?? "unset" };
+}
 export async function ensureTiDBMailboxSchema(pool) {
     await pool.query(`CREATE TABLE IF NOT EXISTS ${MAILBOX_TABLE} (
     scope_key VARBINARY(190) NOT NULL,
@@ -166,8 +199,15 @@ export async function ensureTiDBMailboxSchema(pool) {
     -- peer_meta(S-90;core fc52b4d4 design/385 片2b):drain 点权威判断读的 typed peer 记录,JSON 文本;
     -- NULL = 缺席(**有语义**:pre-385/foreign 记录,drain 永不回溯准入;与空对象绝不互折)。写入面先过 core
     -- readMailboxPeerMeta(坏值带码拒于任何副作用前)+ PEER_META_MAX_BYTES 守卫关掉静默截断类。
-    -- 新列按 2026-07-26 schema policy 直接折进 CREATE(不开 ALTER seam,存量库删库重建)。
+    -- 新列直接折进 CREATE(启动 DDL 不开 ALTER seam);存量库缺列 ⇒ 起服列册对账拒启并给出可粘贴的 ALTER 语句,由运维在升级前执行。
     peer_meta TEXT NULL,
+    -- decision(core 7.57.0 #972b):收件人设置留置的这条记录的**决定**(七词闭集 MAILBOX_DECISIONS);NULL = 从未 held。
+    -- 只经 moveDecision 的比较并设置移动,从不随 append 写;随记录生随记录亡(ack / reap / drop 删行即删它)—— 决定是记录自己的字段。
+    decision VARCHAR(16) NULL,
+    -- record_id(core 7.59.0):生产者铸的记录身份;NULL = 没说身份(每次 append 都是一条新记录)。盒持有一条这身份的记录时,append 经引擎的
+    -- judgeMailboxAppendById 判(同记录 ⇒ 答它的 seq、零写;不同 ⇒ mailbox.duplicate_record_id),判在 append 的盒行锁之内 —— 盒行 FOR UPDATE 串行了
+    -- 同一只盒的全部 append,「(scope, handle, id) 在持有行里至多一行」由它成立;ack / reap / drop 删行即还身份。宽 = 引擎的 MAILBOX_RECORD_ID_MAX_CHARS(列宽读那只常量,不抄数)。
+    record_id VARCHAR(${MAILBOX_RECORD_ID_MAX_CHARS}) NULL,
     PRIMARY KEY (scope_key, handle, seq),
     KEY idx_mbm_sent (scope_key, handle, sent_at_ms)
   ) COLLATE utf8mb4_bin`);
@@ -204,6 +244,8 @@ export async function ensurePgMailboxSchema(q) {
     sent_at_ms BIGINT NOT NULL,
     hop_chain TEXT COLLATE "C", -- core 5.17.0 design/176(TiDB twin 同注:NULL = 缺席且有语义)
     peer_meta TEXT COLLATE "C", -- S-90 core fc52b4d4 design/385 片2b(TiDB twin 同注:typed peer 记录 JSON;NULL = 缺席且有语义)
+    decision VARCHAR(16) COLLATE "C", -- core 7.57.0 #972b(TiDB twin 同注:留置决定,NULL = 从未 held;只经 moveDecision 移动,随记录亡)
+    record_id VARCHAR(${MAILBOX_RECORD_ID_MAX_CHARS}) COLLATE "C", -- core 7.59.0(TiDB twin 同注:生产者铸的记录身份,NULL = 没说身份;盒行锁之内经引擎判,随记录亡)
     PRIMARY KEY (scope_key, handle, seq)
   )`);
     await q(`CREATE TABLE IF NOT EXISTS ${MAILBOX_TOMBSTONE_TABLE} (
@@ -242,8 +284,9 @@ export class TiDBMailboxStore {
     async append(scope, handle, msg) {
         assertMailboxKey("scope", scope);
         assertMailboxKey("handle", handle);
-        const hopChain = encodeHopChain(msg.hopChain);
-        const peerMeta = encodePeerMeta(msg.peerMeta);
+        const rec = appendSnapshot(msg);
+        const hopChain = encodeHopChain(rec.hopChain);
+        const peerMeta = encodePeerMeta(rec.peerMeta);
         return this.tx(async (c) => {
             await c.query(`INSERT INTO ${MAILBOX_TABLE} (scope_key, handle, scope, next_seq) VALUES (?, ?, ?, 1) ON DUPLICATE KEY UPDATE scope_key = scope_key`, [scope, handle, scope]);
             let [rows] = (await c.query(`SELECT next_seq FROM ${MAILBOX_TABLE} WHERE scope_key = ? AND handle = ? FOR UPDATE`, [scope, handle]));
@@ -254,9 +297,15 @@ export class TiDBMailboxStore {
             const [tomb] = await c.query(`SELECT 1 FROM ${MAILBOX_TOMBSTONE_TABLE} WHERE scope_key = ? AND handle = ? FOR UPDATE`, [scope, handle]);
             if (tomb.length > 0)
                 throw tombstonedRecipientError(scope, handle);
+            if (rec.id !== undefined) {
+                const [held] = await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("tidb", "hop_chain")}, ${jsonColumnText("tidb", "peer_meta")}, decision, record_id FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = ? AND handle = ? AND record_id = ? FOR UPDATE`, [scope, handle, rec.id]);
+                const replay = replayedSeq(held, scope, handle, this.logger, { ...rec, content: asUtf8Stored(rec.content), ...(rec.from !== undefined ? { from: asUtf8Stored(rec.from) } : {}) });
+                if (replay !== undefined)
+                    return replay;
+            }
             const seq = Number(rows[0].next_seq);
             await c.query(`UPDATE ${MAILBOX_TABLE} SET next_seq = ? WHERE scope_key = ? AND handle = ?`, [seq + 1, scope, handle]);
-            await c.query(`INSERT INTO ${MAILBOX_MSG_TABLE} (scope_key, handle, seq, from_id, content, sent_at_ms, hop_chain, peer_meta) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [scope, handle, seq, msg.from ?? null, msg.content, msg.sentAt, hopChain, peerMeta]);
+            await c.query(`INSERT INTO ${MAILBOX_MSG_TABLE} (scope_key, handle, seq, from_id, content, sent_at_ms, hop_chain, peer_meta, record_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [scope, handle, seq, rec.from ?? null, rec.content, rec.sentAt, hopChain, peerMeta, rec.id ?? null]);
             return seq;
         });
     }
@@ -274,7 +323,7 @@ export class TiDBMailboxStore {
                 bufToStr(box.lease_owner) !== owner) {
                 return null;
             }
-            const [msgs] = (await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("tidb", "hop_chain")}, ${jsonColumnText("tidb", "peer_meta")} FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = ? AND handle = ? ORDER BY seq FOR UPDATE`, [scope, handle]));
+            const [msgs] = (await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("tidb", "hop_chain")}, ${jsonColumnText("tidb", "peer_meta")}, decision, record_id FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = ? AND handle = ? ORDER BY seq FOR UPDATE`, [scope, handle]));
             if (msgs.length === 0)
                 return null;
             const maxSeq = Number(msgs[msgs.length - 1].seq);
@@ -295,6 +344,22 @@ export class TiDBMailboxStore {
             return { acked: true };
         });
     }
+    async moveDecision(scope, handle, seq, expect, next) {
+        assertMailboxDecisionMove(seq, expect, next);
+        if (keyless(scope, handle))
+            return { ok: false, current: "gone" };
+        return this.tx(async (c) => {
+            const [boxes] = await c.query(`SELECT 1 FROM ${MAILBOX_TABLE} WHERE scope_key = ? AND handle = ? FOR UPDATE`, [scope, handle]);
+            if (boxes.length === 0)
+                return { ok: false, current: "gone" };
+            const [rows] = await c.query(`SELECT decision FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = ? AND handle = ? AND seq = ? FOR UPDATE`, [scope, handle, seq]);
+            const verdict = decisionMoveVerdict(rows, expect);
+            if (verdict !== "write")
+                return verdict;
+            await c.query(`UPDATE ${MAILBOX_MSG_TABLE} SET decision = ? WHERE scope_key = ? AND handle = ? AND seq = ?`, [next, scope, handle, seq]);
+            return { ok: true };
+        });
+    }
     async releaseLease(scope, handle, owner) {
         if (keyless(scope, handle, owner))
             return;
@@ -384,11 +449,12 @@ export class PgMailboxStore {
     async append(scope, handle, msg) {
         assertMailboxKey("scope", scope);
         assertMailboxKey("handle", handle);
-        if (msg.from !== undefined && pgHasUnstorable(msg.from))
+        const rec = appendSnapshot(msg);
+        if (rec.from !== undefined && pgHasUnstorable(rec.from))
             throw new PgUnstorableError("mailbox from");
-        const content = pgSanitizeText(msg.content);
-        const hopChain = encodeHopChain(msg.hopChain);
-        const peerMeta = encodePeerMeta(msg.peerMeta);
+        const content = pgSanitizeText(rec.content);
+        const hopChain = encodeHopChain(rec.hopChain);
+        const peerMeta = encodePeerMeta(rec.peerMeta);
         return this.tx(async (c) => {
             await c.query(`INSERT INTO ${MAILBOX_TABLE} (scope_key, handle, scope, next_seq) VALUES ($1, $2, $3, 1) ON CONFLICT (scope_key, handle) DO NOTHING`, [
                 scope,
@@ -407,9 +473,15 @@ export class PgMailboxStore {
             const { rows: tomb } = await c.query(`SELECT 1 FROM ${MAILBOX_TOMBSTONE_TABLE} WHERE scope_key = $1 AND handle = $2 FOR UPDATE`, [scope, handle]);
             if (tomb.length > 0)
                 throw tombstonedRecipientError(scope, handle);
+            if (rec.id !== undefined) {
+                const { rows: held } = await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("pg", "hop_chain")}, ${jsonColumnText("pg", "peer_meta")}, decision, record_id FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = $1 AND handle = $2 AND record_id = $3 FOR UPDATE`, [scope, handle, rec.id]);
+                const replay = replayedSeq(held, scope, handle, this.logger, { ...rec, content });
+                if (replay !== undefined)
+                    return replay;
+            }
             const seq = Number(rows[0].next_seq);
             await c.query(`UPDATE ${MAILBOX_TABLE} SET next_seq = $1 WHERE scope_key = $2 AND handle = $3`, [seq + 1, scope, handle]);
-            await c.query(`INSERT INTO ${MAILBOX_MSG_TABLE} (scope_key, handle, seq, from_id, content, sent_at_ms, hop_chain, peer_meta) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, [scope, handle, seq, msg.from ?? null, content, msg.sentAt, hopChain, peerMeta]);
+            await c.query(`INSERT INTO ${MAILBOX_MSG_TABLE} (scope_key, handle, seq, from_id, content, sent_at_ms, hop_chain, peer_meta, record_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [scope, handle, seq, rec.from ?? null, content, rec.sentAt, hopChain, peerMeta, rec.id ?? null]);
             return seq;
         });
     }
@@ -424,7 +496,7 @@ export class PgMailboxStore {
             const box = boxes[0];
             if (box.lease_owner !== null && Number(box.lease_expires_at_ms) > now && String(box.lease_owner) !== owner)
                 return null;
-            const { rows: msgs } = await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("pg", "hop_chain")}, ${jsonColumnText("pg", "peer_meta")} FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = $1 AND handle = $2 ORDER BY seq FOR UPDATE`, [scope, handle]);
+            const { rows: msgs } = await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("pg", "hop_chain")}, ${jsonColumnText("pg", "peer_meta")}, decision, record_id FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = $1 AND handle = $2 ORDER BY seq FOR UPDATE`, [scope, handle]);
             if (msgs.length === 0)
                 return null;
             const maxSeq = Number(msgs[msgs.length - 1].seq);
@@ -445,6 +517,22 @@ export class PgMailboxStore {
             return { acked: true };
         });
     }
+    async moveDecision(scope, handle, seq, expect, next) {
+        assertMailboxDecisionMove(seq, expect, next);
+        if (keyless(scope, handle))
+            return { ok: false, current: "gone" };
+        return this.tx(async (c) => {
+            const { rows: boxes } = await c.query(`SELECT 1 FROM ${MAILBOX_TABLE} WHERE scope_key = $1 AND handle = $2 FOR UPDATE`, [scope, handle]);
+            if (boxes.length === 0)
+                return { ok: false, current: "gone" };
+            const { rows } = await c.query(`SELECT decision FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = $1 AND handle = $2 AND seq = $3 FOR UPDATE`, [scope, handle, seq]);
+            const verdict = decisionMoveVerdict(rows, expect);
+            if (verdict !== "write")
+                return verdict;
+            await c.query(`UPDATE ${MAILBOX_MSG_TABLE} SET decision = $1 WHERE scope_key = $2 AND handle = $3 AND seq = $4`, [next, scope, handle, seq]);
+            return { ok: true };
+        });
+    }
     async releaseLease(scope, handle, owner) {
         if (keyless(scope, handle, owner))
             return;

package/dist/plugins/memory-sync-store-pg.d.ts

@@ -1,4 +1,3 @@
-import type { MemorySyncCursor } from "@sema-agent/core";
 import type { PgQueryFn } from "./pg-query.js";
 import { type IndexSpec } from "./ensure-index.js";
 /** Table names (single source). SAME names as the TiDB twin (the two dialects never share one DB). */
@@ -31,12 +30,24 @@ export interface ClaimedPushQueueItem {
     /** The lease deadline this claim holds the row until (nowMs + claimLeaseMs). */
     leasedUntilMs: number;
 }
+/**
+ * 中心侧的同步游标 = 本服务作同步**中心**时,每个 (scope, peer) 的基线(`sync_cursors` 一行)—— 本服务自己的事实,本服务自己的型。
+ * 它**不是**引擎的 `MemorySyncCursor`:那一只是同步**客户端**的游标,引擎 7.59.0 起必带 `store`(客户端本地 File 店的物理根,`memorySyncStoreOf` 铸),
+ * 绑的是「这份基线是对着哪一只本地店取的」;中心这一侧的条目平面是部署的 DB 后端,没有本地店根可绑,游标也从不交给引擎判。
+ * 此前本文件借用了引擎那只型名(两者当时同形),引擎给它加了只属于客户端的成员之后,借用就成了两个事实共用一个名字 —— 本型收回。
+ */
+export interface CentralSyncCursor {
+    readonly scope: string;
+    readonly peer: string;
+    readonly baseRevs: Readonly<Record<string, string>>;
+    readonly updatedAtMs: number;
+}
 /** The dialect-neutral contract both twins implement (anti-drift: one shared integration suite,
  *  test/memory-sync-store-db-integration.test.ts, runs the SAME scenarios against BOTH engines). */
 export interface MemorySyncStore {
-    getCursor(scope: string, peer: string): Promise<MemorySyncCursor | undefined>;
+    getCursor(scope: string, peer: string): Promise<CentralSyncCursor | undefined>;
     /** Whole-row replace (round semantics — baseRevs is swapped as one map, never merged). */
-    putCursor(cursor: MemorySyncCursor): Promise<void>;
+    putCursor(cursor: CentralSyncCursor): Promise<void>;
     enqueue(item: PushQueueItem): Promise<void>;
     /** Lease-claim up to `limit` due rows (next_attempt_at_ms <= nowMs), oldest-due first. Claimed rows
      *  are invisible to other claimers until `complete`/`fail` or lease expiry (crash self-heal). */
@@ -66,8 +77,8 @@ export declare class PgMemorySyncStore implements MemorySyncStore {
     private readonly query;
     private readonly claimLeaseMs;
     constructor(query: PgQueryFn, opts?: PgMemorySyncStoreOptions);
-    getCursor(scope: string, peer: string): Promise<MemorySyncCursor | undefined>;
-    putCursor(cursor: MemorySyncCursor): Promise<void>;
+    getCursor(scope: string, peer: string): Promise<CentralSyncCursor | undefined>;
+    putCursor(cursor: CentralSyncCursor): Promise<void>;
     enqueue(item: PushQueueItem): Promise<void>;
     claimDue(nowMs: number, limit: number): Promise<ClaimedPushQueueItem[]>;
     complete(id: string): Promise<void>;

package/dist/plugins/memory-sync-store-tidb.d.ts

@@ -1,5 +1,5 @@
 import type { ClaimedPushQueueItem, MemoryHistoryAppendRow, MemoryHistoryRow, MemoryHistoryStore, MemorySyncStore, PushQueueItem } from "./memory-sync-store-pg.js";
-import type { MemorySyncCursor } from "@sema-agent/core";
+import { type CentralSyncCursor } from "./memory-sync-store-pg.js";
 import type { Pool } from "mysql2/promise";
 /** Table names (single source) — SAME names as PG_MEMORY_SYNC_TABLES (the two dialects never share
  *  one database). */
@@ -21,8 +21,8 @@ export declare class TiDBMemorySyncStore implements MemorySyncStore {
     private readonly pool;
     private readonly claimLeaseMs;
     constructor(pool: Pool, opts?: TiDBMemorySyncStoreOptions);
-    getCursor(scope: string, peer: string): Promise<MemorySyncCursor | undefined>;
-    putCursor(cursor: MemorySyncCursor): Promise<void>;
+    getCursor(scope: string, peer: string): Promise<CentralSyncCursor | undefined>;
+    putCursor(cursor: CentralSyncCursor): Promise<void>;
     enqueue(item: PushQueueItem): Promise<void>;
     claimDue(nowMs: number, limit: number): Promise<ClaimedPushQueueItem[]>;
     complete(id: string): Promise<void>;

package/dist/plugins/one-time-migrations.d.ts

@@ -227,9 +227,12 @@
  *  · **M25 单用户记忆项目层换键形**(7.133.0)—— 不在店里、不在起服里(与 M10 同为**窗内才存在的行为臂**,但它是改写):项目层键从 `repo:<sha256(项目根)[:24]>`
  *    (7.98.0–7.132.x)换成带主体、跨设备的 `userrepo:<属主段>/<档>.<摘要>`(文法 `project-layer-key.ts`)。退役键是路径哈希、反推不出路径 ⇒ 起服没法枚举改写;
  *    改为**每个项目第一次跑任务时**由项目层准备一步(`memory-project-layer.ts` `createMemoryProjectLayers`)把该 checkout 的 `repo:` 层经 core `migrateScope`
- *    折进新键(File 与两只 SQL 孪生同一条;id 保留、CAS,冲突留原地下次再试)。同一窗同删的另一半:同步客户端腿的旧游标文件 `sync-cursor-<peer>.json`(只按 peer 分区)
- *    第一轮收编为同步层的新游标(`memory-sync-client.ts` `adoptLegacyCursor`)。本条不写起服读数(`reportKeys` 空,与 M7 / M10 同形);折了什么由运行期 info
- *    `memory_project_layer_folded` / `memory_sync_cursor_adopted` 说。常设的另一条律(`r` 档时本 checkout 的 `p` 档折进当前档)不是迁移,不随本条删。
+ *    折进新键(File 与两只 SQL 孪生同一条;id 保留、CAS,冲突留原地下次再试)。本条不写起服读数(`reportKeys` 空,与 M7 / M10 同形);折了什么由运行期 info
+ *    `memory_project_layer_folded` 说。常设的另一条律(`r` 档时本 checkout 的 `p` 档折进当前档)不是迁移,不随本条删。
+ *    **曾属本条的另一半已退役(如实)**:同步客户端腿的旧游标文件 `sync-cursor-<peer>.json`(只按 peer 分区)的收编臂。引擎 7.59.0 起游标必带店绑定 `store`,
+ *    升级前落盘的旧文件都没有这一员,收编的形判从不认它 ⇒ 臂对任何存量文件都不可达,已整条删码(收编函数、守卫旗标、日志行一并删,零引用有钉:
+ *    `test/memory-sync-client.test.ts`)。旧文件不再被当游标;它只回答「同步层有没有一份店绑定之前的基线」—— 新路径上没有文件而它是同步层的无绑定基线 ⇒
+ *    同步层不同步、运维通告点名它(与新路径上的无绑定游标同一条律,`memory-sync-client.ts` 头注 ⑤;不是本条的迁移臂,不随本条删)。
  *  · **M26 删掉退役的共享断路器表 `circuit_breaker`**(7.133.0)—— 断路器键的路由段从 baseUrl **原串**换成路由身份的摘要(铸点与形 `breaker-key.ts`),
  *    新一代键写**新表** `breaker_state`(中央 DDL 建)。旧表 `circuit_breaker` 的行是旧键(`<provider>:<id>@<baseUrl>`,网关根原串 query 可带凭据),
  *    新代码不读不写它、它也没有 TTL 腿 ⇒ 不删就永远在共享库里。**整只删表**(`DROP TABLE IF EXISTS circuit_breaker`,不看任何一行的内容):

package/dist/plugins/one-time-migrations.js

@@ -393,11 +393,10 @@ export const ONE_TIME_MIGRATIONS = [
         releasedOn: "2026-10-21",
         removableAfter: "2026-11-20",
         removal: "删 `project-identity.ts` 的 `mintRepoScopeKey`(与它的窗注;`RETIRED_PROJECT_KEY_PREFIX` 留给 `isServerMintedProjectKey` 的起服拒)与 `projectLayerForTaskRoot` 的 `foldFrom` 里它那一员" +
-            "(`p` 档那一员留 —— 常设律);`memory-sync-client.ts` 的 `legacyMemorySyncCursorPath` / `adoptLegacyCursor` 与 runner 里调它的那一段(`legacyCursorChecked`);" +
-            "`test/memory-project-layer-fold.test.ts` 的 ① 格与 `test/memory-project-layer-fold-db-integration.test.ts` 整份、`test/memory-sync-client.test.ts` 的旧游标收编格、" +
+            "(`p` 档那一员留 —— 常设律);" +
+            "`test/memory-project-layer-fold.test.ts` 的 ① 格与 `test/memory-project-layer-fold-db-integration.test.ts` 整份、" +
             "`test/project-identity.test.ts` 的 `repo:` 金样格(公式金样改钉 `p` 档摘要)",
-        afterRemoval: "没有新的臂(如实):窗内一次都没跑过任务的项目,它的 `repo:` 层留在库里、不再被任何读列表包含(不读、不删;起服拒只管运维点名这一族);出路 = 升级时先过一次带本条的版本并在每个项目跑一次任务。" +
-            "同步腿的旧游标文件不再收编:同步层从空基线首轮重收敛(两边都改过的条目按冲突上报,不静默丢)",
+        afterRemoval: "没有新的臂(如实):窗内一次都没跑过任务的项目,它的 `repo:` 层留在库里、不再被任何读列表包含(不读、不删;起服拒只管运维点名这一族);出路 = 升级时先过一次带本条的版本并在每个项目跑一次任务",
         reportKeys: [],
     },
     {

package/dist/plugins/permission-rule-store-sql.js

@@ -4,7 +4,6 @@ import { applyTombstones, assertDeleteDeltaCarriesNoAdd, assertRedemptionNotQuar
 import { dialectProtocolJsonEncoder, sqlDbNowMs, SQL_DB_NOW_MS } from "./sql-driver.js";
 import { isMissingColumnError } from "./sql-errors.js";
 import { canonicalJsonStringify } from "@sema-agent/core";
-import { isPersistedRuleTool } from "../permission-rule-vocab.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn, SqlJsonColumnError } from "./sql-json-column.js";
 import { redactSecrets } from "../trace/redact.js";
@@ -31,7 +30,7 @@ const PersistedRuleRowSchema = z
     .object({
     behavior: z.string().optional(),
     rule: z.string(),
-    tool: z.string().min(1).refine(isPersistedRuleTool, { message: "not a tool the persisted-rule grammar speaks for" }),
+    tool: z.string().min(1),
     match: z.enum(PERSISTED_RULE_MATCHES),
     command: z.string(),
     scope: DurableRuleScopeSchema,
@@ -387,6 +386,19 @@ function decodeBucketRow(ownerKey, row) {
     const rules = rulesRaw.map((r) => ({ ...r, behavior: readBucketRowBehavior(r.behavior, "rule row", ownerKey) }));
     const tombstones = tombstonesRaw.map((t) => ({ ...t, behavior: readBucketRowBehavior(t.behavior, "tombstone", ownerKey) }));
     const quarantined = quarantinedRaw.map((q) => ({ ...q, behavior: readBucketRowBehavior(q.behavior, "quarantined row", ownerKey) }));
+    refuseRowsTheValidatorRefuses(ownerKey, rules, tombstones);
+    return {
+        actor: String(row.actor ?? ""),
+        counter: Number(row.counter ?? 0),
+        rev: Number(row.rev ?? 0),
+        rules,
+        tombstones,
+        quarantined,
+        ...(observedVector !== undefined ? { observedVector } : {}),
+        ...(grammar !== undefined ? { grammar } : {}),
+    };
+}
+function refuseRowsTheValidatorRefuses(ownerKey, rules, tombstones) {
     const badTombstone = tombstones.find((t) => {
         const parsed = parseRuleText(t.rule, t.behavior);
         return "reject" in parsed || parsed.rule.rule !== t.rule;
@@ -394,21 +406,11 @@ function decodeBucketRow(ownerKey, row) {
     if (badTombstone !== undefined) {
         throw new BucketRefusedError(`permission_rule bucket ${ownerKey} carries a tombstone whose rule text the single validator refuses or does not spell canonically`, `(${badTombstone.rule}) — refusing the whole bucket rather than keeping a rule alive under a tombstone that can never match it`);
     }
-    const screened = screenRuleSyncState({ rules, tombstones });
+    const screened = screenRuleSyncState({ rules: [...rules], tombstones: [...tombstones] });
     if (screened.rejected.length > 0) {
         const names = screened.rejected.map((r) => `${r.rule}(${r.reason})`).join(", ");
         throw new BucketRefusedError(`permission_rule bucket ${ownerKey} carries rows the single validator refuses`, `[${names}] — refusing the whole bucket rather than authorizing a rule whose text and matcher metadata disagree`);
     }
-    return {
-        actor: String(row.actor ?? ""),
-        counter: Number(row.counter ?? 0),
-        rev: Number(row.rev ?? 0),
-        rules,
-        tombstones,
-        quarantined,
-        ...(observedVector !== undefined ? { observedVector } : {}),
-        ...(grammar !== undefined ? { grammar } : {}),
-    };
 }
 function fencedCasWhere(dialect, firstPlaceholder, ownerKey, cas) {
     const ph = (offset) => (dialect === "tidb" ? "?" : `$${firstPlaceholder + offset}`);
@@ -422,6 +424,12 @@ async function writeBucket(exec, dialect, ownerKey, cur, next, nowMs) {
     if (!writable.success) {
         throw new Error(`refusing to write a permission_rule bucket this backend could not read back: ${writable.error.message}`);
     }
+    try {
+        refuseRowsTheValidatorRefuses(ownerKey, next.rules, next.tombstones);
+    }
+    catch (e) {
+        throw new Error(`refusing to write a permission_rule bucket this backend could not read back: ${e.message}`);
+    }
     const body = { rules: next.rules, tombstones: next.tombstones, quarantined: cur.quarantined, ...(cur.observedVector !== undefined ? { observedVector: cur.observedVector } : {}) };
     const enc = dialectProtocolJsonEncoder(dialect);
     const where = fencedCasWhere(dialect, 7, ownerKey, { column: "rev", expected: cur.rev });

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

@@ -6,6 +6,8 @@ import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type OrphanOwnerLog } from "../delegated-session-owner.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 SessionFace } from "../session-incarnation.js";
 import { type IndexSpec } from "./ensure-index.js";
 /**
@@ -55,8 +57,8 @@ export declare class PgSessionStorage extends BaseSessionStorage {
  */
 export declare class PgSessionStore implements SessionStore {
     private readonly pool;
-    /** [ref] 车1:托管留存声明(TiDB 孪生同格)。读法见 `retention-store-sql.ts` 的 {@link MANAGED_RETENTION}。 */
-    readonly retention: import("@sema-agent/core").RetentionDeclaration;
+    /** 托管留存声明 = 装配交给它的词(TiDB 孪生同格)。读法见 `retention-store-sql.ts` 的 {@link MANAGED_RETENTION}。 */
+    readonly retention: RetentionDeclaration;
     /** [ref] C18(core 5.48.0 [ref]):placement 声明(TiDB 孪生同格,义务逐条见
      *  `src/plugins/session-placement.ts` 顶注)。 */
     readonly placements: {
@@ -70,6 +72,7 @@ export declare class PgSessionStore implements SessionStore {
     private readonly log;
     constructor(pool: Pool, opts?: {
         readonly log?: OrphanOwnerLog;
+        readonly retention?: RetentionDeclaration;
     });
     acquire(sessionId?: string, opts?: PlacementAcquireOpts): Promise<AcquiredSession>;
     private load;
@@ -135,6 +138,11 @@ export declare class PgSessionStore implements SessionStore {
      *  `query_timeout` rejects AND pg-pool destroys that client, so a lock-stuck baseline write does not keep a pooled
      *  connection). */
     recordInstructionSource(sessionId: string, expected: InstructionSourceBaseline, source: string | null): Promise<void>;
+    /** @see TiDBSessionStore.readSessionWorkspace — the PG twin (same projection-as-text, same cell owner). */
+    readSessionWorkspace(sessionId: string): Promise<SessionWorkspace | undefined>;
+    /** @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 — copy the WHOLE durable history (full session_event log, compaction floor bypassed,
      *  NOT wake's bounded tail) to a NEW uuidv7 session, re-seq dense from 0, ids/parents verbatim, owner=caller. */
     fork(sourceId: string, owner?: string | null): Promise<string | null>;

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

@@ -14,11 +14,13 @@ import { createLogger } from "../observability/logger.js";
 import { classifySyncRelationshipByIds, SyncConflictError, StagedCommitOwnerChangedError, stagingIdFor, STAGING_ID_MARKER, STAGING_GC_GRACE_MS, } from "../session-sync-kernel.js";
 import { isPgUniqueViolation } from "./sql-errors.js";
 import { BASELINE_IO_DEADLINE_MS, decodeInstructionSource, encodeInstructionSource } from "../instruction-source-notice.js";
-import { MANAGED_RETENTION } from "./retention-store-sql.js";
+import { SESSION_META_WORKSPACE_COLUMN, decodeSessionWorkspaceCell, encodeSessionWorkspaceCell } from "./session-workspace-cell.js";
+import { MANAGED_RETENTION, UNMANAGED_RETENTION } from "./retention-store-sql.js";
 import { SESSION_META_INCARNATION_COLUMN, carriedIncarnation, headFromRow, incarnationFromCell, mintSessionIncarnation, sessionFaceFromRow } from "../session-incarnation.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { assertFirstOwnerWritable, forkOwnerOf, isSessionOwnerValue } from "./session-ownership.js";
-import { forkCopyOf, forkPointOf } from "./session-fork.js";
+import { selectForkRows } from "@sema-agent/core";
+import { FORK_LOG_ROW_SHAPE, forkPointOf } from "./session-fork.js";
 const isDupKey = isPgUniqueViolation;
 function baselineQuery(text, values) {
     return { text, values, query_timeout: BASELINE_IO_DEADLINE_MS };
@@ -39,6 +41,8 @@ export const PG_SESSION_SCHEMA = [
      pinned      BOOLEAN      NOT NULL DEFAULT FALSE,
      -- instruction_source(S-690):换源通告的基线 —— TiDB 孪生同名同宽,三态读法(NULL / '' / 链成员相对路径)见那里的列注。
      instruction_source VARCHAR(64) COLLATE "C",
+     -- workspace:本会话上一条腿自己的最后一帧 workspace_changed —— TiDB 孪生同名同义(列注与唯一属主见那里:src/plugins/session-workspace-cell.ts)。
+     ${SESSION_META_WORKSPACE_COLUMN.pg},
      -- #292 C18(core 5.48.0 design/323)subagent 转录持久化 —— placement 元组(TiDB 孪生同名同宽,
      -- 语义与六条义务见 src/plugins/session-placement.ts 顶注):创建时一次落行、first-write 不可变;
      -- placement_kind 在场 ⇒ 住在 placement 分区(不上宿主枚举 / claim 形 acquire 恒拒 / release=真删除 /
@@ -176,13 +180,14 @@ export class PgSessionStorage extends BaseSessionStorage {
 }
 export class PgSessionStore {
     pool;
-    retention = MANAGED_RETENTION;
+    retention;
     placements = SQL_SESSION_PLACEMENTS;
     pending = new Map();
     log;
     constructor(pool, opts = {}) {
         this.pool = pool;
         this.log = opts.log ?? createLogger();
+        this.retention = opts.retention ?? UNMANAGED_RETENTION;
     }
     async acquire(sessionId, opts) {
         if (!sessionId) {
@@ -417,6 +422,14 @@ export class PgSessionStore {
             await this.pool.query(baselineQuery("UPDATE session_meta SET instruction_source = $1 WHERE session_id = $2 AND instruction_source IS NULL", [next, sessionId]));
         }
     }
+    async readSessionWorkspace(sessionId) {
+        const res = await this.pool.query(`SELECT ${jsonColumnText("pg", "workspace")} FROM session_meta WHERE session_id = $1`, [sessionId]);
+        const row = res.rows[0];
+        return row === undefined ? undefined : decodeSessionWorkspaceCell(row.workspace, sessionId);
+    }
+    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) {
         const metaRes = await this.pool.query("SELECT leaf_id, owner FROM session_meta WHERE session_id = $1", [sourceId]);
         if (!metaRes.rows[0])
@@ -428,7 +441,7 @@ export class PgSessionStore {
             return null;
         const point = await forkPointOf(storage);
         const eventRes = await this.pool.query(`SELECT entry_id, parent_id, type, ${jsonColumnText("pg", "payload")}, ts FROM session_event WHERE session_id = $1 ORDER BY seq ASC`, [sourceId]);
-        const { rows, leafId: forkLeafId } = forkCopyOf(eventRes.rows, leafId, point);
+        const { rows, leafId: forkLeafId } = selectForkRows(eventRes.rows, leafId, point, FORK_LOG_ROW_SHAPE);
         const newId = uuidv7();
         const now = new Date();
         const conn = await this.pool.connect();
@@ -523,7 +536,7 @@ export class PgSessionStore {
             }
             await conn.query("DELETE FROM session_event WHERE session_id = $1", [sessionId]);
             await conn.query("DELETE FROM session_meta WHERE session_id = $1 AND owner IS NOT DISTINCT FROM $2 AND placement_kind IS NULL", [sessionId, owner]);
-            await this.insertValidatedLog(conn, sessionId, owner, validated, carriedIncarnation(sessionId, placedRes.rows[0], owner));
+            await this.insertValidatedLog(conn, sessionId, owner, validated, carriedIncarnation(sessionId, placedRes.rows[0]));
             await conn.query("COMMIT");
         }
         catch (err) {

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

@@ -58,14 +58,16 @@ export declare class RemoteAdbExecutionEnv implements RemoteExecutionEnv {
      * (RPC 断、传输掉),不是「一个它看不见的命名空间」⇒ 读边界的执行期复核**拒**,而不是让词法判决站着。
      * 缺席是今天每个适配器的读法(整链沉默 ⇒ 词法判决成立、命令照跑),所以这一声明是**收紧**方向。
      * 严格读法 `=== true`(core `canonicalPathIsAuthoritative`);`isSuspendable` 一族同样严格,对本仓的
-     * 布尔字面量零影响(三键都写死字面 `true`/`false`,不存在「非布尔值被读成缺席」那一形 —— 那一形由
+     * 布尔字面量零影响(四键都写死字面 `true`/`false`,不存在「非布尔值被读成缺席」那一形 —— 那一形由
      * core 的 `config.execution_env_capability_invalid` 普查响亮播报,本仓的受众表已登记)。
      * 谁该声明由闭集门看着(`test/execution-lane-caps.test.ts` 的逐 lane 对账:新 lane 不表态 = 编译红)。
      */
+    /** `sharesProcessTable`(core 7.57.0,必填):命令跑在设备上(adb shell),不在本进程所在的进程表。 */
     readonly capabilities: {
         isolation: boolean;
         suspendable: boolean;
         canonicalPathAuthoritative: boolean;
+        sharesProcessTable: boolean;
     };
     cwd: string;
     private connected;

package/dist/plugins/remote-env-adb.js

@@ -27,7 +27,7 @@ export function isAdbTransportLost(stderr) {
     return /device offline|device '.*' not found|no devices\/emulators found|connection reset|protocol fault|device disconnected/i.test(stderr);
 }
 export class RemoteAdbExecutionEnv {
-    capabilities = { isolation: false, suspendable: false, canonicalPathAuthoritative: true };
+    capabilities = { isolation: false, suspendable: false, canonicalPathAuthoritative: true, sharesProcessTable: false };
     cwd;
     connected = false;
     destroyed = false;

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

@@ -104,14 +104,16 @@ export declare class RemoteDeviceExecutionEnv implements RemoteExecutionEnv {
      * (RPC 断、传输掉),不是「一个它看不见的命名空间」⇒ 读边界的执行期复核**拒**,而不是让词法判决站着。
      * 缺席是今天每个适配器的读法(整链沉默 ⇒ 词法判决成立、命令照跑),所以这一声明是**收紧**方向。
      * 严格读法 `=== true`(core `canonicalPathIsAuthoritative`);`isSuspendable` 一族同样严格,对本仓的
-     * 布尔字面量零影响(三键都写死字面 `true`/`false`,不存在「非布尔值被读成缺席」那一形 —— 那一形由
+     * 布尔字面量零影响(四键都写死字面 `true`/`false`,不存在「非布尔值被读成缺席」那一形 —— 那一形由
      * core 的 `config.execution_env_capability_invalid` 普查响亮播报,本仓的受众表已登记)。
      * 谁该声明由闭集门看着(`test/execution-lane-caps.test.ts` 的逐 lane 对账:新 lane 不表态 = 编译红)。
      */
+    /** `sharesProcessTable`(core 7.57.0,必填):命令跑在注册设备上(设备执行器),不在本进程所在的进程表。 */
     readonly capabilities: {
         isolation: boolean;
         suspendable: boolean;
         canonicalPathAuthoritative: boolean;
+        sharesProcessTable: boolean;
     };
     readonly externalContentTarget = true;
     /** [ref]:设备路径不在 worker 宿主文件系统上 —— host-path 回执消费方据此拒绝把它当宿主路径呈现。 */

package/dist/plugins/remote-env-device.js

@@ -126,7 +126,7 @@ export class RemoteDeviceExecutionEnv {
     homeDir;
     cdPath = "unknown";
     withheldEnv = [];
-    capabilities = { isolation: false, suspendable: false, canonicalPathAuthoritative: true };
+    capabilities = { isolation: false, suspendable: false, canonicalPathAuthoritative: true, sharesProcessTable: false };
     externalContentTarget = true;
     hostLocalPaths = false;
     cwd;

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

@@ -135,10 +135,12 @@ export declare class RemoteContainerExecutionEnv implements RemoteExecutionEnv,
     constructor(config: RemoteContainerEnvConfig, deps?: RemoteContainerEnvDeps);
     /** [ref] §9: E2B is a FULL RemoteExecutionEnv — an isolated, snapshot-suspendable microVM. (SSH/ADB
      *  adapters declare {isolation:false, suspendable:false} — real machines/devices, not snapshotable.) */
+    /** `sharesProcessTable`(core 7.57.0,必填):命令跑在云沙箱里,不在本进程所在的进程表。 */
     readonly capabilities: {
         isolation: boolean;
         suspendable: boolean;
         canonicalPathAuthoritative: boolean;
+        sharesProcessTable: boolean;
     };
     workspaceHandle(): WorkspaceHandle;
     /**