@sema-agent/server 7.139.0 → 7.141.0

package/dist/delegated-session-owner.d.ts

@@ -2,7 +2,7 @@
  * 🔴 **委派子代会话的属主 —— 一条律;三处写点,各自的来源集;属主 = 判断时见证到的,写只 CAS 子行自己**([ref])。
  *
  * ## 律
- * 一只委派子代会话(引擎为委派铸的 placed 会话,或停驻时从私店拷进宿主店的子代会话)的属主**不是它自己的事实**:它是发起它的那棵委派树的
+ * 一只委派子代会话(引擎为委派铸的 placed 会话;升级前停驻时晋升进宿主店的普通行在停驻挂点也按这条律比对)的属主**不是它自己的事实**:它是发起它的那棵委派树的
  * **根会话的属主**。树根是**铸行那一刻存在的那只根行**(id + 住客化身,`session-incarnation.ts`);此后同 id 另起的会话不是这棵树的根。所以写下的属主 =
  * **判断时见证到的**(读法顺序按写点交来的来源集):
  *  1. 根会话在本店有行 ⇒ 它的属主(根无主 ⇒ 子代也无主 —— 与根同读数,不是另一种读数);
@@ -29,29 +29,32 @@
  * 会话面 / fork / 删除 / 审批豁免 / notify 同读;dev-open 照旧 fleet-wide),具名主体与没有 service 凭据的无身份调用方一律与别人的行同体 404 ——
  * 所以还没定下的行只是暂时只有 fleet 面读得到,不是谁都能读。它们由一次性迁移 M23(窗内每次起服)或这一行的下一次停驻(停驻挂点的认领)
  * 定下;两处都不承诺「一次收敛」。
- * **只有记录委派树的店才认领**:SQL 两店的 placed 行记着委派树(placement 元组);local 店不实现 placement、不记委派树 ⇒ 没有可按的树 ⇒ 不认领
- * (它的无主子代行在停驻挂点照「属主不是律给的那一只 ⇒ 拒」处置;收口是 local 店的 placement 协议)。不按更松的判据认领。
+ * **只有记录委派树的行才认领**:三只持久会话店的 placed 行都记着委派树(placement 元组:SQL 两店在 `session_meta`,local 店在会话存档行头);
+ * 不记委派树的行(普通行,含升级前停驻时晋升进来的行)⇒ 没有可按的树 ⇒ 不认领(在停驻挂点照「属主不是律给的那一只 ⇒ 拒」处置)。不按更松的判据认领。
  *
  * ## 三处写点 —— 律一只,**来源集按写点不同**(都调这里,不各写一份判据)
- *  · **SQL 两店按 placement 建行**(`plugins/tidb-session-store.ts` / `plugins/pg-session-storage.ts` 的 acquire,{@link createPlacedSessionRow}):来源 = placement 上的
- *    根、父两只 id({@link ownerSourcesOf});读来源 → 判 → 一条 INSERT(属主与 placement 同一笔落库,首写律)。读来源之后来源才变有主(滚动升级窗里别的副本的
+ *  · **三只持久会话店按 placement 建行**({@link createPlacedSessionRow}:`plugins/tidb-session-store.ts` / `plugins/pg-session-storage.ts` 的 acquire 一条 INSERT,属主与 placement
+ *    同一笔落库;`plugins/local-session-store.ts` 的 acquire 先建存档(行头带元组)、再写会话元数据那一格(属主 + 化身))。来源 = placement 上的根、父两只 id({@link ownerSourcesOf});
+ *    读来源 → 判 → 写(首写律)。读来源之后来源才变有主(滚动升级窗里别的副本的
  *    M23 回填了无主的父)⇒ 写下的仍是判断时的读数 —— 按律如此;那一行若因此无主,照上一节处置。
- *  · **停驻挂点**(`plugins/session-store.ts` 的 `ensureChildSessionDurableWithPromotion`;快路 + 晋升):来源 = **调用方交出的委派树根,只有这一只**,连同
+ *  · **停驻挂点**(`plugins/session-store.ts` 的 `attestChildSessionDurable`;只验、不搬):来源 = **调用方交出的委派树根,只有这一只**,连同
  *    调用方判断那一刻读到的根行住客({@link DelegationRootWitness};见证值,判断用,不进 CAS):请求腿 = 本请求经鉴权解析的会话,住客 = 受理时那一读
  *    (`boot/resolve-spec.ts`);`/decide` 的赎回腿 = 行上的 `rootSessionId`,住客 = 赎回腿写口放行的那一位(认领之前解析器那一读;`parked-revive-surface.ts`,每一行都交)。
- *    挂点先读一次根行:它在而住客不是见证的那一位 ⇒ 根被删、同 id 换了住客 ⇒ **拒**(不按新住客晋升 / 认领,{@link assertRootStillWitnessed});它不在 ⇒ 律给哨兵
+ *    挂点先读一次根行:它在而住客不是见证的那一位 ⇒ 根被删、同 id 换了住客 ⇒ **拒**(不按新住客认领,{@link assertRootStillWitnessed});它不在 ⇒ 律给哨兵
  *    (根真没了)。不回落父:core 的挂点 `ensureChildSessionDurable(sessionId)` 只交子代 id,父 id 在这一写点拿不到;两条候选读法都读不到东西 ——
- *    ① 读 `session_meta(子代).placement_parent_session_id`:晋升的拷贝分支恰恰只在子代**没有** placed 行时才走(有 placed 行 ⇒ 快路),这一列按构造为空;
+ *    ① 读子代行记下的父:记着委派树的行(placed 行)在下面的定夺里本就按**它记录的**根、父再判一次;不记委派树的行(升级前晋升进来的普通行)没有这一格;
  *    ② 登记簿(后台子代行 / core 注册簿):core 接口没有「按子代 sessionId 查行」的读口,SQL 表 `background_agent.session_id` 无索引,加一条只在一处用的私有读腿
  *       = 多一只读法;`scope` 列还把匿名折成 `"default"`(与真名 `default` 的租户不可分)。行上没有根(没有会话的取用形)⇒ 来源集空 ⇒ 哨兵。
  *    宿主行的属主经 {@link settleDelegatedOwner} 定下:宿主行记着委派树而不是这一棵 ⇒ 拒(两边属主都是 null 也拒);记着这一棵 ⇒ 按**它记录的** placement(根、父)
  *    再判一次(与 M23 对同一行同读数 —— 见证只答「是不是这一棵、根住客换没换」,来源集取行上记的),无主 ⇒ 认领(CAS 子行),认领试了没落下 ⇒ 拒;然后比对 ——
- *    不是律给的那一只 ⇒ 停驻否决(晋升建行前那一道与停驻快路同一只函数、同一句拒因)。
+ *    不是律给的那一只 ⇒ 停驻否决。
  *  · **一次性迁移 M23**(`plugins/one-time-migrations.ts`):存量 placed 行,来源 = 根、父(扫描时同一条语句连读两行);回填 = 认领(同一句,绑扫描读到的子行化身)。
- * local 店不实现 placement(子代住私店、只经停驻挂点进宿主店),没有第一处与第三处,也不认领(上一节)。
+ * local 店没有第三处:它的 placed 行自本律起由第一处写下(属主在建行那一笔);存档在而那一格缺(建行两笔之间崩了,或同一数据根上 run-local 腿写下的 placed 存档)
+ * 读作从没被记下的属主 = 无主,照「无主的子代行」一节处置(停驻挂点的认领)。
  */
 import type { SessionPlacement } from "@sema-agent/core";
 import { type HeadRead, type SessionFace } from "./session-incarnation.js";
+import type { SqlDialect } from "./plugins/sql-driver.js";
 /** 孤行哨兵属主的前缀(保留主体前缀:`security.ts` 的 `RESERVED_PRINCIPAL_PREFIXES` 登记它,任何身份来源报出带它的主体都在鉴权边界被拒)。 */
 export declare const ORPHAN_SESSION_OWNER_PREFIX = "_orphan:";
 /** 一只推不出属主的子代会话的哨兵属主(每只会话一个值:即便哪天有谁误配出这个串,也只够得着这一只)。 */
@@ -102,8 +105,8 @@ export declare function readDelegatedOwner(childId: string, placement: Placement
 export interface OrphanOwnerLog {
     warn(msg: string, fields?: Record<string, unknown>): void;
 }
-/** 写点的名字(warn 行的 `site` 字段:运维据它知道是哪一笔写下的哨兵)。`promotion` = 停驻挂点(晋升建行,或对宿主无主行的认领)。 */
-export type DelegatedOwnerSite = "placed_create" | "promotion";
+/** 写点的名字(warn 行的 `site` 字段:运维据它知道是哪一笔写下的哨兵)。`placed_create` = 按 placement 建行;`park` = 停驻挂点对宿主无主 placed 行的认领。 */
+export type DelegatedOwnerSite = "placed_create" | "park";
 /** 一笔写**已落下**之后调:写下的是孤行哨兵 ⇒ 一行 warn(写失败的那一笔走不到这里,不留下「已写」的话)。继承来的属主(含继承自孤行祖先的哨兵)不告。 */
 export declare function reportWrittenOwner(log: OrphanOwnerLog, site: DelegatedOwnerSite, childId: string, judged: JudgedOwner): void;
 /**
@@ -112,10 +115,10 @@ export declare function reportWrittenOwner(log: OrphanOwnerLog, site: DelegatedO
  * 不改变写进去的值(律:属主 = 判断时见证到的,本文件头注)。两方言只差占位符。
  * MySQL 协议下 mysql2 缺省带 FOUND_ROWS,但条件里有 `owner IS NULL` ⇒ 匹配行数 = 改写行数。
  */
-export declare const CLAIM_OWNERLESS_PLACED_SQL: Readonly<Record<"tidb" | "pg", string>>;
+export declare const CLAIM_OWNERLESS_PLACED_SQL: Readonly<Record<SqlDialect, string>>;
 /** 认领句的绑参(两方言同序;店与 M23 都经它,不各排一份):`incarnation` = 判断时读到的子行化身。 */
 export declare function claimOwnerlessParams(sessionId: string, incarnation: string, owner: string): readonly [string, string, string];
-/** 店的认领口(SQL 两店 + 缓存包装层同一个签名):这只会话的那一位住客(`incarnation`)仍是无主的 placed 行 ⇒ 写 `owner`,返回是否写成。 */
+/** 店的认领口(三只持久会话店 + 缓存包装层同一个签名):这只会话的那一位住客(`incarnation`)仍是无主的 placed 行 ⇒ 写 `owner`,返回是否写成。 */
 export type OwnerlessClaim = (sessionId: string, incarnation: string, owner: string) => Promise<boolean>;
 /** 一只 SQL 店建 placed 行要交的 I/O(两店按各自方言交,都是店的既有读写口;读法与顺序只住在 {@link createPlacedSessionRow})。 */
 export interface PlacedRowWriter {
@@ -145,7 +148,7 @@ export interface DelegationRootWitness {
  * 根行此刻不在 ⇒ 不抛(根真没了 ⇒ 律给哨兵,不是「换了住客」)。这是**判断**的一部分;判断之后、写之前根的变化不改变写进去的值(律:属主 = 判断时见证到的)。
  */
 export declare function assertRootStillWitnessed(sessionId: string, witness: DelegationRootWitness | undefined, judged: JudgedOwner): void;
-/** 记录委派树的宿主店多交的两只口(SQL 两店与缓存包装层;local 店两只都没有 ⇒ 没有可按的树 ⇒ 不认领)。 */
+/** 记录委派树的宿主店多交的两只口(三只持久会话店与缓存包装层;无 repo 的内存店两只都没有 ⇒ 没有可按的树 ⇒ 不认领)。 */
 export interface DelegationTreeStore {
     /** 本行落库的 placement 元组(`undefined` = 本行不是 placed 行 ⇒ 不记委派树)。 */
     readonly placementOf: (sessionId: string) => Promise<PlacementSources | undefined>;
@@ -158,7 +161,7 @@ export interface DelegatedOwnerHost {
     readonly trees: DelegationTreeStore | undefined;
 }
 /**
- * 「这只宿主店能不能承载委派子代的属主」—— 只判这一处(停驻快路与晋升建行读同一只):店有按 id 的头读(`headOf`,「有没有」沿用 `headReadOf` 的同一处判法)⇒
+ * 「这只宿主店能不能承载委派子代的属主」—— 只判这一处(停驻挂点读它):店有按 id 的头读(`headOf`,「有没有」沿用 `headReadOf` 的同一处判法)⇒
  * 绑好的 {@link DelegatedOwnerHost};没有 ⇒ `undefined`(调用方响亮拒:读不回属主的宿主店上,停驻出来的就是一只谁都能读的转录)。记录委派树的两只口
  * (`placementOf` + `claimOwnerless`)**同在或同缺**:同在 ⇒ `trees`;同缺 ⇒ 不记委派树;只有一只 ⇒ `undefined`(记着树却认领不了,或认领却读不回树 —— 半只店不猜)。
  */
@@ -173,13 +176,13 @@ export interface SettledOwner {
     readonly judged: JudgedOwner | undefined;
 }
 /**
- * 宿主店里这只会话的行属主**按律定下来**(停驻快路与晋升建行前**同一只函数、同一句拒因**;拒句不带任何一方的属主值 —— 它会进停驻否决的错误面)。
- * `owner` / `tree` = 调用方按见证的根判出的属主与委派树(晋升建行写下的就是它)。
- *  1. 宿主行**记着委派树**(SQL 店的 placed 行):记下的根 ≠ `tree.root` ⇒ 抛(不以属主是否 null 为前提:那是另一棵树的行);是这一棵 ⇒ **按它记录的 placement(根、父)
+ * 宿主店里这只会话的行属主**按律定下来**(停驻挂点的那一道;拒句不带任何一方的属主值 —— 它会进停驻否决的错误面)。
+ * `owner` / `tree` = 调用方按见证的根判出的属主与委派树。
+ *  1. 宿主行**记着委派树**(placed 行):记下的根 ≠ `tree.root` ⇒ 抛(不以属主是否 null 为前提:那是另一棵树的行);是这一棵 ⇒ **按它记录的 placement(根、父)
  *     再判一次**(唯一判据 {@link judgeDelegatedOwner} —— 与 M23 / 建行复核对这一行同读数:根不在取父),调用方那一读之后根住客变了 ⇒ 抛({@link assertRootStillWitnessed},
  *     调用方的读数当见证);行无主而律给出属主 ⇒ 认领(CAS 刚读到的那一位住客;写进去的是这一次判的读数)—— **试了没落下 ⇒ 抛**(这一行在判断之后被写过 /
  *     删过 / 换了住客,不由事后的属主比对放行);
- *  2. 不记委派树的行(local 店的行、SQL 店的普通行)不认领、不再判;
+ *  2. 不记委派树的行(普通行,含升级前晋升进来的行)不认领、不再判;
  *  3. 比对 —— 此刻的属主不是律给的那一只(记着委派树 ⇒ 按记录的树判的那一只;否则 = `owner`)⇒ 抛。
  */
 export declare function settleDelegatedOwner(host: DelegatedOwnerHost, sessionId: string, owner: string | null, tree: DelegationTree): Promise<SettledOwner>;

package/dist/delegated-session-owner.js

@@ -47,7 +47,7 @@ export function reportWrittenOwner(log, site, childId, judged) {
     });
 }
 export const CLAIM_OWNERLESS_PLACED_SQL = {
-    tidb: "UPDATE session_meta SET owner = ? WHERE session_id = ? AND incarnation = ? AND owner IS NULL AND placement_kind IS NOT NULL",
+    mysql: "UPDATE session_meta SET owner = ? WHERE session_id = ? AND incarnation = ? AND owner IS NULL AND placement_kind IS NOT NULL",
     pg: "UPDATE session_meta SET owner = $1 WHERE session_id = $2 AND incarnation = $3 AND owner IS NULL AND placement_kind IS NOT NULL",
 };
 export function claimOwnerlessParams(sessionId, incarnation, owner) {
@@ -80,7 +80,7 @@ export function delegatedOwnerHostOf(store) {
 }
 export async function settleDelegatedOwner(host, sessionId, owner, tree) {
     const refuse = () => new Error(`session "${sessionId}" cannot be parked as this delegated session: the host session store holds a session with this id that is not this delegation tree's ` +
-        "(a different owner, or a different recorded delegation root), and the transcript is neither copied into it nor attested by it");
+        "(a different owner, or a different recorded delegation root), so it does not attest this delegated transcript");
     const face = sessionFaceOfHead(sessionId, await host.headOf(sessionId));
     const trees = host.trees;
     const recorded = face === undefined || trees === undefined ? undefined : await trees.placementOf(sessionId);

package/dist/deployment-shape.d.ts

@@ -9,7 +9,7 @@
  * ## 两根轴,每根轴一个读口(原始配置键只在这两个函数里被读)
  *  · `principal` —— 运维的 `REQUIRE_PRINCIPAL` 声明({@link readPrincipalAxis})。
  *  · `lane` —— `REMOTE_EXEC` 的归一车道词(`executionLaneOf`,认不出 ⇒ `undefined`,行必须 fail-closed)+ 那条车道的能力表行 +
- *    车道子旋钮(k8s 运行时类 / 快照店、隐式 host 尾臂记号)({@link readLaneAxis})。
+ *    这份部署上执行环境的能力块(唯一作者 `capabilitiesFor`;k8s 的快照店是它的输入)+ 车道子旋钮(k8s 运行时类、隐式 host 尾臂记号)({@link readLaneAxis})。
  *
  * ## 轴列不是注释,是型
  * 每行的判官只收到它**声明**的那几根轴的事实({@link DeploymentShapeFacts}),读不到配置本身 —— 判官碰一根没声明的轴 = 编译红;
@@ -21,8 +21,9 @@
  * (`mcpInjectionHonored` = 锁 ∧ 合规 ∧ `!multiTenant`;`taskHooksHonored`;身份门 …),读行、不读原始键。
  * 车道表(`execution-lane-caps.ts`)按车道词键控的布尔列(`laneIsolated` 等)是车道轴自己的事实表,不是「部署」的谓词;行读它们。
  *
- * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts`(它本身是叶),零运行期环。
+ * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts`(它本身是叶),零运行期环(引擎只 type-import)。
  */
+import type { ExecutionEnvCapabilities } from "@sema-agent/core";
 import { type ExecutionLane, type ExecutionLaneCaps } from "./execution-lane-caps.js";
 /** `principal` 轴读的配置键(`ServiceConfig` 结构上满足)。 */
 export interface PrincipalAxisInput {
@@ -48,10 +49,10 @@ export interface LaneAxisFacts {
     readonly lane: ExecutionLane | undefined;
     /** 那条车道的能力表行(认不出 ⇒ `undefined`)。 */
     readonly caps: ExecutionLaneCaps | undefined;
+    /** 这份部署上执行环境的能力块(`capabilitiesFor`;认不出 ⇒ `undefined`)。 */
+    readonly block: ExecutionEnvCapabilities | undefined;
     /** k8s 的 `runtimeClass`(别的车道 `undefined`)。 */
     readonly k8sRuntimeClass: string | undefined;
-    /** k8s 配了 S3 工作区快照店(别的车道 `false`)。 */
-    readonly k8sSnapshotStore: boolean;
     /** host 车道值上带「单机形缺省」记号(唯一写者 = `config.ts` 三元链的隐式 host 尾臂;显式 `REMOTE_EXEC=host` 与文件覆写都不带)。 */
     readonly singleMachineDefault: boolean;
 }
@@ -102,7 +103,7 @@ export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
     inProcessSingleUser: DeploymentShapePredicate<"lane" | "principal">;
     /** 任务层替部署声明宿主姿态(bypassPermissions 开写面 / host shell 继承整份环境)的射程:device 车道上跨租户宿主穿越结构性不存在(clay 裁定③)。 */
     taskHostPostureDeclarations: DeploymentShapePredicate<"lane" | "principal">;
-    /** 写门走 [ref] 代理裁决(文件平面不在 worker 本机);认不出的词 ⇒ 走代理(代理 slot 空 ⇒ 写门 fail-closed)。 */
+    /** 写门走代理裁决(执行环境块 `hostLocalPaths` 为假:路径不是本 worker 盘上的文件);认不出的词 ⇒ 走代理(代理 slot 空 ⇒ 写门 fail-closed)。 */
     sandboxPathAdjudication: DeploymentShapePredicate<"lane">;
     /** 读能力表 `sandboxSendUserFile` 位(e2b / k8s 每任务一只沙箱 ⇒ 任何租户;ssh 共享一台真机 ⇒ 只单主)。 */
     sandboxSendUserFile: DeploymentShapePredicate<"lane" | "principal">;
@@ -111,13 +112,13 @@ export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
     /** 读能力表 `tenantSeparation` 位(值来自 settings-schema 车道词表正本);唯一读者 = 跨域不变量 `multi-tenant-shared-lane`。 */
     laneSeparatesTenants: DeploymentShapePredicate<"lane" | "principal">;
     /**
-     * [ref] —— **VM 级**隔离强度(独立内核:e2b 的 Firecracker microVM;k8s 只在 Kata / gVisor 运行时类上)。与能力表 `isolation` 位
+     * [ref] —— **VM 级**隔离强度(独立内核:e2b 的 Firecracker microVM;k8s 只在 Kata / gVisor 运行时类上)。与执行环境块 `isolation` 键
      * (OS 级边界,容器即算;wire `executionLane.isolated` 的属主 `laneIsolated`)是两个问题,所以不叫「isolated」。读者:A 值路由。
      */
     vmIsolatedHands: DeploymentShapePredicate<"lane">;
     /**
-     * [ref] —— 执行环境可挂起:能力表 `suspendable` 位(「结构上能不能」)∧ k8s 的前提旋钮(配了 S3 快照店)。真作者是各适配器对 core 的
-     * `capabilities.suspendable` 声明(对账:`test/execution-lane-caps.test.ts` 拿真适配器实例逐车道核)。读者:boot `remote_exec_enabled.suspendable`。
+     * 执行环境可挂起 = 这份部署上执行环境块的 `suspendable`(唯一作者 `capabilitiesFor`,k8s 的快照店是它的输入;适配器的块是同一只函数铸的)。
+     * 读者:boot `remote_exec_enabled.suspendable`。
      */
     suspendableHands: DeploymentShapePredicate<"lane">;
     /** 读者两处:`config.ts` 车道落点一行的 `source`(覆写之前)与 `boot/execution-env.ts` 的 `remote_exec_real_system.note`(覆写之后)—— 同一个记号、两个时刻。 */

package/dist/deployment-shape.js

@@ -1,4 +1,4 @@
-import { executionLaneCaps, executionLaneOf, handsOnWorkerFilePlane } from "./execution-lane-caps.js";
+import { capabilitiesFor, executionLaneCaps, executionLaneOf, handsOnWorkerFilePlane } from "./execution-lane-caps.js";
 function readPrincipalAxis(deployment) {
     return { declared: deployment.requirePrincipal === true };
 }
@@ -8,8 +8,8 @@ function readLaneAxis(deployment) {
     return {
         lane,
         caps: lane === undefined ? undefined : executionLaneCaps(lane),
+        block: capabilitiesFor(deployment),
         k8sRuntimeClass: lane === "k8s" ? declaration?.runtimeClass : undefined,
-        k8sSnapshotStore: lane === "k8s" && Boolean(declaration?.s3Snapshot),
         singleMachineDefault: lane === "host" && declaration?.singleMachineDefault === true,
     };
 }
@@ -54,7 +54,7 @@ export const DEPLOYMENT_SHAPE_PREDICATES = Object.freeze({
     toolsOnThisHost: createPredicate(["lane"], "车道:工具跑的那台机器就是本进程这台(手挂上了且文件平面在本 worker 盘上;车道列 handsOnWorkerFilePlane)。", ({ lane }) => lane.lane !== undefined && handsOnWorkerFilePlane(lane.lane)),
     inProcessSingleUser: createPredicate(["lane", "principal"], "车道 × 租户:进程内车道(REMOTE_EXEC 未设)且部署只有一个主人。", ({ lane, principal }) => lane.lane === "in-process" && !principal.declared),
     taskHostPostureDeclarations: createPredicate(["lane", "principal"], "车道 × 租户 / 设备归属:任务层可以替部署声明宿主姿态 —— device 车道(发起者自己的设备),或单主部署。", ({ lane, principal }) => lane.lane === "device" || !principal.declared),
-    sandboxPathAdjudication: createPredicate(["lane"], "车道:写门的路径事实要经代理到执行环境里取(文件平面不在本 worker 盘上;认不出的车道也走代理)。", ({ lane }) => lane.caps === undefined || lane.caps.hostFilePlane !== "supported"),
+    sandboxPathAdjudication: createPredicate(["lane"], "车道:写门的路径事实要经代理到执行环境里取(文件平面不在本 worker 盘上;认不出的车道也走代理)。", ({ lane }) => lane.block === undefined || !lane.block.hostLocalPaths),
     sandboxSendUserFile: createPredicate(["lane", "principal"], "车道 × 租户:SendUserFile 的沙箱直传腿可以挂(沙箱盘 = 租户自己的任务工作区,或共享真机上的单主部署)。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.sandboxSendUserFile, principal)),
     remoteScratchpad: createPredicate(["lane"], "车道:执行环境里按会话分的远端 scratchpad 约定适用。", ({ lane }) => lane.caps !== undefined && lane.caps.remoteScratchpad === "supported"),
     laneSeparatesTenants: createPredicate(["lane", "principal"], "车道 × 租户:这条车道在这台部署上不让两个租户的命令落在同一个共享目标上(单主部署恒成立;认不出的车道不成立)。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.tenantSeparation, principal)),
@@ -66,7 +66,7 @@ export const DEPLOYMENT_SHAPE_PREDICATES = Object.freeze({
         const runtimeClass = (lane.k8sRuntimeClass ?? "").trim().toLowerCase();
         return runtimeClass.startsWith("kata") || VM_ISOLATION_RUNTIME_CLASSES.has(runtimeClass);
     }),
-    suspendableHands: createPredicate(["lane"], "车道:执行环境可挂起(e2b;k8s 以配了 S3 工作区快照店为前提)。", ({ lane }) => lane.caps !== undefined && lane.caps.suspendable === "supported" && (lane.lane !== "k8s" || lane.k8sSnapshotStore)),
+    suspendableHands: createPredicate(["lane"], "车道:执行环境可挂起(e2b;k8s 以配了 S3 工作区快照店为前提)。", ({ lane }) => lane.block?.suspendable === true),
     singleMachineDefaultLane: createPredicate(["lane"], "车道:host 车道是单机形缺省落点(REMOTE_EXEC 未设 ∧ CONFIG_PROVIDER=local,没人点名)。", ({ lane }) => lane.singleMachineDefault),
 });
 //# sourceMappingURL=deployment-shape.js.map

package/dist/device-store.d.ts

@@ -395,6 +395,12 @@ export interface DeviceStore {
     placeDeviceExecution(input: PlaceDeviceExecutionInput): Promise<PlaceDeviceExecutionResult>;
     /** O4 显式换绑(v2 稿 §2 步 2/3/5):目标设备门 + 写事务内锁根行读认领 + 前态 CAS + `session_rebound` 审计行同一事务。 */
     rebindDeviceExecution(input: RebindDeviceExecutionInput): Promise<RebindDeviceExecutionResult>;
+    /**
+     * 绑定数:根会话行上 writer(device, D) 的格数 —— 唯一读法 `boundDeviceOf` 的聚合(SQL 侧只缩小读的行,每行过唯一解码:`execution-placement-sql.ts`
+     * `countDeviceBindingsOn`)。数的是格,不 join 设备行(吊销设备上的格照数:格还在,会话仍放在那台设备上)。只交一个数。读故障与解码器拒的行原样抛(不折成 0)。
+     * 读者:起服门「设备入口 × 已绑设备」(`boot/device-lane.ts`)。
+     */
+    countDeviceBindings(): Promise<number>;
     appendAudit(input: AppendAuditInput): Promise<void>;
     listAudit(filter?: ListAuditFilter): Promise<DeviceAuditRow[]>;
 }
@@ -432,6 +438,7 @@ export declare class InMemoryDeviceStore implements DeviceStore {
     releaseConnection(deviceId: string, generation: number): Promise<boolean>;
     placeDeviceExecution(input: PlaceDeviceExecutionInput): Promise<PlaceDeviceExecutionResult>;
     rebindDeviceExecution(input: RebindDeviceExecutionInput): Promise<RebindDeviceExecutionResult>;
+    countDeviceBindings(): Promise<number>;
     appendAudit(input: AppendAuditInput): Promise<void>;
     listAudit(filter?: ListAuditFilter): Promise<DeviceAuditRow[]>;
     private isOnline;

package/dist/device-store.js

@@ -386,6 +386,9 @@ export class InMemoryDeviceStore {
             this.pushAudit({ event: "session_rebound", deviceId: input.targetDeviceId, owner: input.owner, detail: { from: out.from, to: input.targetDeviceId, rev: out.device.rev } });
         return out;
     }
+    async countDeviceBindings() {
+        return this.seat.countDeviceBindings();
+    }
     async appendAudit(input) {
         this.pushAudit(input);
     }

package/dist/execution-config-root.d.ts

@@ -0,0 +1,22 @@
+import { type LaneHomeDeployment, type RemoteExecProvider } from "./execution-lane-caps.js";
+/** 选中车道转进沙箱的 env 那一座(`ServiceConfig.remoteExec` 的判别联合每一臂结构上都满足:e2b / k8s 的 `sandboxEnv`、local-docker 的 `env`,别的臂两键都没有)。 */
+export interface SandboxEnvSeat {
+    readonly remoteExec?: {
+        readonly provider: RemoteExecProvider;
+        readonly sandboxEnv?: Readonly<Record<string, string>> | undefined;
+        readonly env?: Readonly<Record<string, string>> | undefined;
+    } | undefined;
+}
+/** 求配置根要读的部署事实(`ServiceConfig` 结构上满足;存体预判的问点传活配置整份)。 */
+export interface ExecutionConfigRootDeployment extends LaneHomeDeployment, SandboxEnvSeat {
+    readonly agentConfigDir?: string;
+    readonly remoteExec?: SandboxEnvSeat["remoteExec"];
+}
+/**
+ * 被选中的沙箱车道上运维点名转进沙箱的 env(e2b / k8s 的 `sandboxEnv`、local-docker 的 `env` —— 名单型旋钮经 `allowlistedEnv` 取的原值);
+ * 车道没有这一座 ⇒ 空。名单此刻交出去的名(`config.ts` 的 `sandboxEnvNamesInForce`)读的也是这一只。
+ */
+export declare function sandboxForwardedEnvOf(deployment: SandboxEnvSeat): Readonly<Record<string, string>>;
+/** 执行环境的配置根(规则见文件头);读不出 ⇒ `undefined`。 */
+export declare function executionConfigRootOf(deployment: ExecutionConfigRootDeployment): string | undefined;
+//# sourceMappingURL=execution-config-root.d.ts.map

package/dist/execution-config-root.js

@@ -0,0 +1,35 @@
+import { posix } from "node:path";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
+import { executionLaneHomeDir, executionLaneOf } from "./execution-lane-caps.js";
+import { configRootOf } from "./sema-config-dir.js";
+const CONFIG_DIR_ENV = "SEMA_CONFIG_DIR";
+export function sandboxForwardedEnvOf(deployment) {
+    const lane = executionLaneOf(deployment.remoteExec?.provider);
+    switch (lane) {
+        case "e2b":
+        case "k8s":
+            return deployment.remoteExec?.sandboxEnv ?? {};
+        case "local-docker":
+            return deployment.remoteExec?.env ?? {};
+        case "in-process":
+        case "host":
+        case "ssh":
+        case "adb":
+        case "device":
+            return {};
+        default: {
+            const unhandled = lane;
+            return unhandled;
+        }
+    }
+}
+export function executionConfigRootOf(deployment) {
+    if (!DEPLOYMENT_SHAPE_PREDICATES.sandboxPathAdjudication.holds(deployment))
+        return configRootOf(deployment);
+    const forwarded = sandboxForwardedEnvOf(deployment)[CONFIG_DIR_ENV];
+    if (forwarded !== undefined)
+        return forwarded;
+    const home = executionLaneHomeDir(deployment);
+    return home === undefined ? undefined : posix.join(home, ".sema");
+}
+//# sourceMappingURL=execution-config-root.js.map