@sema-agent/server 7.142.0 → 7.144.0

package/dist/config-root-migration.js

@@ -0,0 +1,99 @@
+import { formatConfigPath } from "@sema-agent/settings-schema";
+import { migrateEnvModelsDecision } from "@sema-agent/settings-schema/node";
+import { envModelsDocumentPath } from "./env-model-table-gate.js";
+const markerWriteFailureAnnounced = new Set();
+export function runEnvModelsMigration(input) {
+    return migrateEnvModelsDecision({ root: input.root, env: input.env });
+}
+export function logEnvModelsMigration(log, input, m) {
+    const dir = input.root;
+    switch (m.kind) {
+        case "already_ran":
+        case "not_minter":
+            return;
+        case "marker_unreadable":
+            log.warn("config_env_models_marker_unreadable", {
+                dir,
+                reason: m.reason,
+                note: "the SS-M11 run marker on this config root does not read — it counts as run, so no decision is minted for anyone; an absent decision reads as kept",
+            });
+            return;
+        case "marker_write_failed":
+            if (markerWriteFailureAnnounced.has(dir))
+                return;
+            markerWriteFailureAnnounced.add(dir);
+            log.warn("config_dir_migration_failed", {
+                dir,
+                migration: "SS-M11",
+                reason: m.error,
+                ...(m.errno !== undefined ? { errno: m.errno } : {}),
+                wayOut: m.wayOut,
+                note: "the SS-M11 run marker could not be created, so no decision was minted — an absent decision reads as kept (a decision written by hand still applies); said once per process",
+            });
+            return;
+        case "recorded":
+            logMint(log, input, m.mint, m.createdRoot, m.decision.kind);
+            return;
+        default: {
+            const unhandled = m;
+            throw new Error(`SS-M11 migration: unknown result ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+function logMint(log, input, mint, createdRoot, decisionBefore) {
+    const dir = input.root;
+    const decisionFile = envModelsDocumentPath(dir);
+    switch (mint.kind) {
+        case "minted":
+            log.info("config_dir_migrated", {
+                dir,
+                receipts: [{ migration: mint.receipt.migration, document: mint.receipt.document, path: formatConfigPath(mint.receipt.path), appliedAs: mint.receipt.appliedAs }],
+                written: [decisionFile],
+                removed: [],
+                createdRoot,
+                migration: "SS-M11",
+                minted: true,
+                note: "settings-schema one-time migration SS-M11 recorded that a catalog managing the model plane replaces the env model table on this config root (the reading before the decision existed); it runs once per config root",
+            });
+            if (mint.replacedEnvModels.length > 0 && !input.envTableIsPlaceholder) {
+                log.warn("config_env_models_replaced_by_migration", {
+                    dir,
+                    envModels: mint.replacedEnvModels.map((e) => ({ id: e.id, env: e.env })),
+                    decisionFile,
+                    note: `the local catalog keeps replacing these env models (as before this version). To serve the env models instead, delete ${decisionFile} or write it as {"envModels":"kept"}; a running process keeps the catalog it serves until the next start`,
+                });
+            }
+            return;
+        case "exists":
+        case "skipped":
+            log.info("config_dir_migrated", {
+                dir,
+                receipts: [],
+                written: [],
+                removed: [],
+                createdRoot,
+                migration: "SS-M11",
+                minted: false,
+                why: mint.kind === "exists" ? "decision_written_meanwhile" : mint.why,
+                decisionBefore,
+                note: "settings-schema one-time migration SS-M11 ran on this config root and minted nothing; an absent decision reads as kept from now on",
+            });
+            return;
+        case "failed":
+        case "models_unreadable":
+            log.warn("config_env_models_mint_failed", {
+                dir,
+                cause: mint.kind === "failed" ? "decision_write_failed" : "models_unreadable",
+                reason: mint.error,
+                ...(mint.errno !== undefined ? { errno: mint.errno } : {}),
+                wayOut: mint.wayOut,
+                note: "SS-M11 did not mint the decision and will not try again on this config root (its run marker is in place) — an absent decision reads as kept, so a local catalog that manages the model plane is refused while env models are declared",
+            });
+            return;
+        default: {
+            const unhandled = mint;
+            throw new Error(`SS-M11 migration: unknown mint outcome ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+//# sourceMappingURL=config-root-migration.js.map

package/dist/config-types.d.ts

@@ -748,7 +748,7 @@ export interface ServiceConfigFlat {
      *  git pull 落下的文件都还认),它只是不 harvest;而 declared-false 的部署连收编都不做。 */
     memoryPersistenceCapable?: boolean;
     /** 142-S2.5-W1: TOC 同步 client 腿 —— file memory 形态把本地记忆盘与中心(DB 权威,
-     *  POST /v1/memory/sync/:scope)做一轮一 RTT 双向同步。env 三键:`MEMORY_SYNC_URL`(设了=开;缺省
+     *  POST /v2/memory/sync/:scope)做一轮一 RTT 双向同步。env 三键:`MEMORY_SYNC_URL`(设了=开;缺省
      *  undefined=纯本地现状零变化)/`MEMORY_SYNC_TOKEN`(Bearer)/`MEMORY_SYNC_SCOPE`(可选,缺省 =
      *  memoryScope 本身**仅当它已是 v2 typed key**;非 typed 键 ⇒ 拒启,[ref] —— 旧 formatUserScope 派生臂铸出的是本部署
      *  从不写的层,见 loadConfig)。半配置 fail-loud
@@ -762,7 +762,7 @@ export interface ServiceConfigFlat {
         maxPullEntries?: number;
     };
     /** [ref] R2:中心(DB 记忆平面)声明的**同步身份** —— 客户端用来到达本中心同步口的基址(env `MEMORY_SYNC_SERVE_IDENTITY`)。
-     *  一处声明、三个读者:能力面 `memorySyncServe.identity` 逐字公开;中心入站 `POST /v1/memory/sync/:scope` 的 `peer` 按串与它比(不等 ⇒ 409,零写);
+     *  一处声明、三个读者:能力面 `memorySyncServe.identity` 逐字公开;中心入站 `POST /v2/memory/sync/:scope` 的 `peer` 按串与它比(不等 ⇒ 409,零写);
      *  缺席 ⇒ 本中心不服务同步(501 `feature.memory_sync_serve_disabled`)。必须已是规范形(铸点 `memory-sync-identity.ts`),否则拒启 —— 无条件解析。 */
     memorySyncServeIdentity?: string;
     /** [ref](黑板 [ref]/[ref] 两裁):记忆检索的**向量面**接线 —— OpenAI 兼容 `/embeddings` 端点。
@@ -1330,9 +1330,9 @@ export interface ServiceConfigFlat {
      * env `LOCKED_CONFIG_KEYS`(csv;词表 = core 的 `LOCKED_KEY_REGISTRY` 闭集,未知键 boot 拒 =
      * `config.locked_registry`「不解析的安全控件不得半开」)。
      *
-     * ⚠️ 本仓的两条**装配相容性**判据在 boot/governance-seams.ts(`assertLockAssemblable`):
-     * `toolPolicy` 锁与本仓「每条腿自铸 spec.toolPolicy」的装配形结构性冲突,`mcp` 锁与「部署自带 MCP
-     * 基线」冲突 —— 两者都在启动期拒,而不是让每条任务腿在 prepare 期各撞一次 `config.locked_key`。
+     * ⚠️ 本仓的**装配相容性**判据在 boot/governance-seams.ts(`assertGovernanceAssemblable`,部署 MCP / A2A 基线物化之后判一次):
+     * `toolPolicy` 锁与本仓「每条腿自铸 spec.toolPolicy」的装配形结构性冲突,`mcp` / `a2a` 锁与「部署自带 MCP 服务器 /
+     * A2A 对端」冲突 —— 都在启动期拒,而不是让每条任务腿在 prepare 期各撞一次 `config.locked_key`。
      */
     lockedConfigKeys?: readonly LockedKey[];
     /**

package/dist/config.d.ts

@@ -264,10 +264,11 @@ export declare function applyAutoCompactWindow(m: Model, explicit?: number): "ex
 /**
  * **严格名册布防**的唯一判据(boot 就绪门 `boot/web-admin.ts` 与装配第 2 段的路由端点判官同调这一只)。
  *
- * 布防 = 远程 registry ∧ 非 dryRun ∧ `CONFIG_REQUIRE_ROSTER=true`(严格 `"true"`,直读 env、不进 ServiceConfig —— 纯
+ * 布防 = 声明了中心(`webAdmin` 在场)∧ 非 dryRun ∧ `CONFIG_REQUIRE_ROSTER=true`(严格 `"true"`,直读 env、不进 ServiceConfig —— 纯
  * boot 期姿势旋钮,原判据逐字搬来,零语义变化)。布防时运维声明 env MODEL_ID 是**占位**:名册落地前计费提交 503、
- * `/health` ready:false,落地后整张模型表被中心目录换装。dryRun 是 compare-only(名册从不被应用),local / 纯 env
- * 部署没有「中心」可等 ⇒ 都不布防。
+ * `/health` ready:false,落地后整张模型表被中心目录换装。判据**不看配置源形态**:`CONFIG_PROVIDER=local` 而同时声明了中心与
+ * `CONFIG_REQUIRE_ROSTER=true` 的部署同样布防,env 表同样按占位读(路由判官、本地腿的 env 模型表闸都不判它)。没有声明中心的
+ * local / 纯 env 部署没有「中心」可等 ⇒ 不布防;dryRun 是 compare-only(名册从不被应用)⇒ 不布防。
  */
 export declare function isRosterGateArmed(webAdmin: ServiceConfig["webAdmin"]): boolean;
 /**

package/dist/config.js

@@ -1742,7 +1742,7 @@ function parseMemoryDomain(ctx) {
     }
     else {
         if (memoryEngineBackend !== "file") {
-            throw new Error(`MEMORY_SYNC_URL is a FILE-memory (TOC client) knob, but MEMORY_ENGINE_BACKEND=${memoryEngineBackend} — the DB memory plane IS the central sync authority (it serves POST /v1/memory/sync/:scope) and must not also run the client leg; unset MEMORY_SYNC_* here`);
+            throw new Error(`MEMORY_SYNC_URL is a FILE-memory (TOC client) knob, but MEMORY_ENGINE_BACKEND=${memoryEngineBackend} — the DB memory plane IS the central sync authority (it serves POST /v2/memory/sync/:scope) and must not also run the client leg; unset MEMORY_SYNC_* here`);
         }
         if (memorySyncToken === undefined) {
             throw new Error("MEMORY_SYNC_URL is set but MEMORY_SYNC_TOKEN is not — refusing to start half-configured (the central sync face requires a bearer token)");

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

@@ -1,59 +1,33 @@
 /**
- * 🔴 **委派子代会话的属主 —— 一条律;三处写点,各自的来源集;属主 = 判断时见证到的,写只 CAS 子行自己**([ref])。
+ * 🔴 **委派子代会话的属主 —— 引擎判、店原样记**(core 7.62.0 [ref];[ref];server 7.144.0 起)。本模块只剩三件:存量行的一次性回填(M23)的判据与写句、
+ * 孤行哨兵属主的保留前缀、委派树根的见证形。
  *
- * ## 律
- * 一只委派子代会话(引擎为委派铸的 placed 会话;升级前停驻时晋升进宿主店的普通行在停驻挂点也按这条律比对)的属主**不是它自己的事实**:它是发起它的那棵委派树的
- * **根会话的属主**。树根是**铸行那一刻存在的那只根行**(id + 住客化身,`session-incarnation.ts`);此后同 id 另起的会话不是这棵树的根。所以写下的属主 =
- * **判断时见证到的**(读法顺序按写点交来的来源集):
- *  1. 根会话在本店有行 ⇒ 它的属主(根无主 ⇒ 子代也无主 —— 与根同读数,不是另一种读数);
- *  2. 根行不在 ⇒ 父会话的行(同上);
- *  3. 来源集里一只都不在本店(孤行)⇒ 写一只**任何已验身份都不可能等于**的哨兵属主 `_orphan:<子代 id>`(前缀登记在 `security.ts` 的保留主体前缀里,
- *     鉴权边界拒任何报出它的主体)+ 写落下之后一行 warn `delegated_session_owner_orphaned`。宁可没人能读,也不让谁都能读。
- * 一只记下的根 / 父是空串(`''`)⇒ 读作没有那一格(与 `session-placement.ts` 的 `placementFromRow` 同一个读法;M23 的扫描句在同一条语句里对连接键套
- * `NULLIF(…, '')`,与判据同读)。
- * **与引擎属主对说法不同(如实登记,收口在引擎)**:引擎 7.55.0 的属主对把「acquire 建的行」与 placed 行一并列为记 `null`(匿名);本律对**每一只** placed 行
- * 在建行那一笔记委派树的属主(哨兵只是「来源都不在」那一形)—— 照引擎的读法记 `null`,在本服务的门上就只有 fleet 调用方读得到(发起它的主体自己读不到;`security.ts` 的 `ownerlessRowOpen`)、且留在认领句 / M23 的射程里,
- * 照引擎「匿名 = 对每个主体放行」的字面读法则是拿到 id 的人都读得到;哨兵两条路都不走。引擎会话店试剂盒「对已有的行
- * register 什么都不做」一格因此在 SQL 两店上登记待翻格,盒那一格的不变量(register 不认领任何已有的行)另由正向钉逐步断言(`test/store-contract-kit-db-integration.test.ts` §9b)。
- * **写只 CAS 子行自己**:`owner IS NULL ∧ incarnation = 判断时读到的子行化身 ∧ placed`({@link CLAIM_OWNERLESS_PLACED_SQL},两方言各一句)。判断与写之间
- * 根 / 父被删、被同 id 重建、换住客 —— 写进去的仍是**判断时那棵树**的属主,这正是律要的:不锁根、不读根、不要求「根到写时还是那个根」。之后与任何会话一样
- * 首写不可变(`register` 的首写律)。判断那一刻的检查照旧在判断里做、不进 CAS:宿主行记下的根是不是这一棵;调用方见证之后根行换没换住客
- * (停驻挂点,{@link assertRootStillWitnessed})。
+ * ## 律(唯一来源 = 引擎)
+ * 委派树的属主 D 由引擎判:没人派生的 run 读自己那一行(`sessions.headOf`,按化身绑一次),原样带给每一层子代(`SessionPlacement.owner: string | null`;`null` = 根匿名);
+ * 复活的子代 = 它自己那一行的属主。本仓两处只读它:
+ *  · 三只持久会话店的 placing write 把 `placement.owner` 原样记进行的属主格(盒义务 7;唯一读法 `plugins/session-ownership.ts` 的 `placedSessionOwnerOf`);
+ *  · 停驻挂点(`plugins/session-store.ts` 的 `attestChildSessionDurable`)只比对宿主行属主与引擎交来的 `given.owner`,不认领、不推断。
+ * 本仓此前自己的委派继承律([ref]:建行那一笔读根 / 父推断、来源都不在写孤行哨兵、停驻挂点按记录的树认领无主行、根见证换住客即拒)在这两处随之退役 ——
+ * 一个事实两份判据(引擎的 D 与本仓的推断)是双真源([ref] (a)),收成引擎那一份。
  *
- * **根先于父**:父的属主按同一条律恒等于根的属主,读根一次就到;而读父会把「父行是升级前写下的无主 placed 行」(滚动升级窗里旧副本建的、
- * 一次性迁移还没回填的)那一格 NULL 传下去。父只在根行不在时才读。
+ * ## 还在的:一次性迁移 M23 的回填(窗随 M23,登记表 M23 行;窗关同删本节全部)
+ * 7.132.x 及更早写下的 placed 行属主恒 NULL(当年 SQL 两店建行不记属主)。M23 每次起服按**旧律**给它们回填一次(引擎的 D 当时没有被记下来,读不回):
+ *  1. 根会话在本店有行 ⇒ 它的属主(根无主 ⇒ 子代也无主 —— 与根同读数);
+ *  2. 根行不在 ⇒ 父会话的行(同上);
+ *  3. 两者都不在本店(孤行)⇒ 一只任何已验身份都不可能等于的哨兵属主 `_orphan:<子代 id>`(前缀登记在 `security.ts` 的保留主体前缀里,鉴权边界拒任何报出它的主体)。
+ * 一只记下的根 / 父是空串(`''`)⇒ 读作没有那一格(与 `session-placement.ts` 的 `placementFromRow` 同一个读法;M23 的扫描句对连接键套 `NULLIF(…, '')`,与判据同读)。
+ * 写只 CAS 子行自己:`owner IS NULL ∧ incarnation = 扫描读到的子行化身 ∧ placed`({@link CLAIM_OWNERLESS_PLACED_SQL})。
+ * 对同一棵树,旧律的「根行的属主」与引擎的 D(根 run 读到的自己那一行的属主)是同一格的读数;两者只在「根行已不在」时分开(旧律取父 / 哨兵,引擎那时的读数没有留下)。
  *
- * ## 无主的子代行
- * 属主为 NULL 的 placed 行有两种来历:律给的(根无主 —— 一棵无身份调用方的树),或还没定下的(7.132.x 及更早写下的;判断时它读到的来源本身还是一只无主的
- * 委派子代行)。会话行属主门上的无主放行臂对它**只对 fleet 调用方成立**(出示 service 凭据、不报主体;唯一判据 `security.ts` 的 `ownerlessRowOpen`,
- * 会话面 / fork / 删除 / 审批豁免 / notify 同读;dev-open 照旧 fleet-wide),具名主体与没有 service 凭据的无身份调用方一律与别人的行同体 404 ——
- * 所以还没定下的行只是暂时只有 fleet 面读得到,不是谁都能读。它们由一次性迁移 M23(窗内每次起服)或这一行的下一次停驻(停驻挂点的认领)
- * 定下;两处都不承诺「一次收敛」。
- * **只有记录委派树的行才认领**:三只持久会话店的 placed 行都记着委派树(placement 元组:SQL 两店在 `session_meta`,local 店在会话存档行头);
- * 不记委派树的行(普通行,含升级前停驻时晋升进来的行)⇒ 没有可按的树 ⇒ 不认领(在停驻挂点照「属主不是律给的那一只 ⇒ 拒」处置)。不按更松的判据认领。
+ * ## 孤行哨兵前缀 —— **永久保留**(不随 M23 删)
+ * 已落库的行可能带着它(7.133.0–7.143.x 的建行推断与 M23 写下的);前缀从保留主体前缀里拿掉 = 让一个能自报 `_orphan:<id>` 的主体读到那些行。
  *
- * ## 三处写点 —— 律一只,**来源集按写点不同**(都调这里,不各写一份判据)
- *  · **三只持久会话店按 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` 的 `attestChildSessionDurable`;只验、不搬):来源 = **调用方交出的委派树根,只有这一只**,连同
- *    调用方判断那一刻读到的根行住客({@link DelegationRootWitness};见证值,判断用,不进 CAS):请求腿 = 本请求经鉴权解析的会话,住客 = 受理时那一读
- *    (`boot/resolve-spec.ts`);`/decide` 的赎回腿 = 行上的 `rootSessionId`,住客 = 赎回腿写口放行的那一位(认领之前解析器那一读;`parked-revive-surface.ts`,每一行都交)。
- *    挂点先读一次根行:它在而住客不是见证的那一位 ⇒ 根被删、同 id 换了住客 ⇒ **拒**(不按新住客认领,{@link assertRootStillWitnessed});它不在 ⇒ 律给哨兵
- *    (根真没了)。不回落父:core 的挂点 `ensureChildSessionDurable(sessionId)` 只交子代 id,父 id 在这一写点拿不到;两条候选读法都读不到东西 ——
- *    ① 读子代行记下的父:记着委派树的行(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 店没有第三处:它的 placed 行自本律起由第一处写下(属主在建行那一笔);存档在而那一格缺(建行两笔之间崩了,或同一数据根上 run-local 腿写下的 placed 存档)
- * 读作从没被记下的属主 = 无主,照「无主的子代行」一节处置(停驻挂点的认领)。
+ * ## 委派树根的见证 —— Runner 之外的后台子代完成 relay 的地址
+ * {@link DelegationRootWitness}:根会话 id + 调用方判断那一刻读到的根行住客(属主与化身)。读者 = 会话通知门的 relay(`session-notify-door.ts`)、会话行记录座、
+ * 请求腿的腿事实;停驻挂点自 7.144.0 起不读它。
  */
 import type { SessionPlacement } from "@sema-agent/core";
-import { type HeadRead, type SessionFace } from "./session-incarnation.js";
+import 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:";
@@ -63,7 +37,7 @@ export declare function orphanSessionOwner(sessionId: string): string;
 export declare function isOrphanSessionOwner(owner: string | null): boolean;
 /** 一只来源行在本店的读数:`undefined` = 本店没有这一行;`null` = 行在、无主;串 = 属主(与 `headOf(id)?.owner` 的三态同义)。 */
 export type SourceOwnerReading = string | null | undefined;
-/** 律的判决:继承自哪一行(属主可以是 `null` = 来源行无主),或孤行(哨兵属主)。 */
+/** 旧律的判决:继承自哪一行(属主可以是 `null` = 来源行无主),或孤行(哨兵属主)。 */
 export type InheritedOwner = {
     readonly kind: "inherited";
     readonly owner: string | null;
@@ -72,120 +46,30 @@ export type InheritedOwner = {
     readonly kind: "orphan";
     readonly owner: string;
 };
-/** placement 上律要读的两格(调用方交的 `SessionPlacement`,或店里落库的那一份元组)。 */
+/** placement 上旧律要读的两格(M23 扫描行上记下的那一份元组)。 */
 export type PlacementSources = Pick<SessionPlacement, "rootSessionId" | "parentSessionId">;
 /** placement 上的来源 id,按读法顺序(根在前、父在后;去空、去重 —— 一层子代的根就是父)。 */
 export declare function ownerSourcesOf(placement: PlacementSources): readonly string[];
-/** 律本身(纯函数)。`sources` = 按读法顺序的 `[来源 id, 本店读数]`;第一只**在本店有行**的来源给出属主,一只都没有 ⇒ 孤行。 */
+/** 旧律本身(纯函数)。`sources` = 按读法顺序的 `[来源 id, 本店读数]`;第一只**在本店有行**的来源给出属主,一只都没有 ⇒ 孤行。 */
 export declare function inheritedOwnerOf(childId: string, sources: ReadonlyArray<readonly [string, SourceOwnerReading]>): InheritedOwner;
+/** M23 的**唯一判据**(纯函数):按记录的来源(placement 上的根、父)与它们此刻在本店的会话面(本店没有的 id 不在表里)判一次。 */
+export declare function judgeDelegatedOwner(childId: string, placement: PlacementSources, faces: ReadonlyMap<string, SessionFace>): InheritedOwner;
 /**
- * 判据读到的**委派树**:记下的根(`null` = 没有根 —— 缺或空串)+ 判据那一读里根行的住客(化身;`null` = 那一读里根行不在本店)。
- * 只在判断里用(停驻挂点:宿主行记下的根是不是这一棵、调用方见证之后根住客换没换);**不进认领句**(律:写只 CAS 子行自己)。
- */
-export interface DelegationTree {
-    readonly root: string | null;
-    readonly rootIncarnation: string | null;
-}
-/** 律的一次判:判决 + 读的来源 id(warn 行用)+ 判据读到的委派树(判断用)。 */
-export interface JudgedOwner {
-    readonly inherited: InheritedOwner;
-    readonly sources: readonly string[];
-    readonly tree: DelegationTree;
-}
-/**
- * **唯一的判据**(纯函数;三处写点都调它):按记录的来源(placement 上的根、父)与它们此刻在本店的会话面(属主 + 化身;本店没有的 id 不在表里)判一次 ——
- * 律给出属主(判断时见证到的),同时交出判据读到的委派树(判断用)。
- */
-export declare function judgeDelegatedOwner(childId: string, placement: PlacementSources, faces: ReadonlyMap<string, SessionFace>): JudgedOwner;
-/** 一次读回若干来源行的会话面(属主 + 化身;本店没有的 id 不在表里)。 */
-export type SourceFacesReader = (ids: readonly string[]) => Promise<ReadonlyMap<string, SessionFace>>;
-/** 按律读一次来源行、判一次(纯读,不告警 —— 孤行 warn 只在写落下之后,{@link reportWrittenOwner})。读失败照原样上抛(调用方的写随之失败,不猜一个属主)。 */
-export declare function readDelegatedOwner(childId: string, placement: PlacementSources, read: SourceFacesReader): Promise<JudgedOwner>;
-/** 孤行那一行 warn 的去处(logger 的子集)。 */
-export interface OrphanOwnerLog {
-    warn(msg: string, fields?: Record<string, unknown>): void;
-}
-/** 写点的名字(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;
-/**
- * 委派继承律的**认领句**(唯一的写法;停驻挂点对宿主无主行的认领与一次性迁移 M23 的回填**同一只**,都按 {@link claimOwnerlessParams} 绑参;窗随 M23)。
- * **只 CAS 子行自己**:这一位住客(判断时读到的化身)、仍无主、placed 行(原文 CAS,第二次命中零行)。不读根、不锁根、不连接 —— 判断与写之间根 / 父的变化
- * 不改变写进去的值(律:属主 = 判断时见证到的,本文件头注)。两方言只差占位符。
+ * M23 回填的**认领句**(唯一的写法;按 {@link claimOwnerlessParams} 绑参;窗随 M23)。**只 CAS 子行自己**:这一位住客(扫描读到的化身)、仍无主、placed 行
+ * (原文 CAS,第二次命中零行)。不读根、不锁根、不连接。两方言只差占位符。
  * MySQL 协议下 mysql2 缺省带 FOUND_ROWS,但条件里有 `owner IS NULL` ⇒ 匹配行数 = 改写行数。
  */
 export declare const CLAIM_OWNERLESS_PLACED_SQL: Readonly<Record<SqlDialect, string>>;
-/** 认领句的绑参(两方言同序;店与 M23 都经它,不各排一份):`incarnation` = 判断时读到的子行化身。 */
+/** 认领句的绑参(两方言同序):`incarnation` = 扫描读到的子行化身。 */
 export declare function claimOwnerlessParams(sessionId: string, incarnation: string, owner: string): readonly [string, string, string];
-/** 店的认领口(三只持久会话店 + 缓存包装层同一个签名):这只会话的那一位住客(`incarnation`)仍是无主的 placed 行 ⇒ 写 `owner`,返回是否写成。 */
-export type OwnerlessClaim = (sessionId: string, incarnation: string, owner: string) => Promise<boolean>;
-/** 一只 SQL 店建 placed 行要交的 I/O(两店按各自方言交,都是店的既有读写口;读法与顺序只住在 {@link createPlacedSessionRow})。 */
-export interface PlacedRowWriter {
-    /** 来源行的会话面一次读回。 */
-    readonly readFaces: SourceFacesReader;
-    /** 建行那一条 INSERT(属主与 placement 同一条落库;行已在 ⇒ 一个字节不动,首写律)。 */
-    insert(owner: string | null): Promise<void>;
-    /** 写后读回本行的属主(店的头读 `headOf(id)?.owner`:`undefined` = 行不在)—— 只为判「本笔的哨兵落没落下」。 */
-    readOwner(): Promise<string | null | undefined>;
-}
-/**
- * **SQL 两店建 placed 行的那一只**:读来源 → 判 → INSERT(属主 = 判断时见证到的,与 placement 同一笔落库)。INSERT 是首写律(行已在 ⇒ 不动),
- * 所以落库的那一行未必是本笔写的(同 id 的另一位建行者先落了)⇒ 读回属主:带着本笔判出的孤行哨兵才告一行 warn;别的 ⇒ 什么都没写下,不告。
- * 不写后复核:判断之后来源才变有主,写下的仍是判断时的读数(律;那一行若因此无主,由无主放行臂的判据挡住非 fleet 调用方、由 M23 / 下一次停驻定下 —— 本文件头注)。
- */
-export declare function createPlacedSessionRow(sessionId: string, placement: PlacementSources, io: PlacedRowWriter, log: OrphanOwnerLog): Promise<void>;
 /**
- * 停驻挂点的**见证**:调用方交出的委派树根 + 调用方判断那一刻读到的根行住客(化身;`null` = 那一读里根行不在)。请求腿 = 鉴权解析的会话与受理时那一读;
- * 赎回腿 = 行上的根与写口放行的那一位住客(认领之前解析器那一读)。
+ * **委派树根的见证**:调用方交出的委派树根 + 调用方判断那一刻读到的根行住客(属主与化身,同一读;化身 `null` = 那一读里根行不在,此时属主恒 `null`)。
+ * 请求腿 = 鉴权解析的会话与受理时那一读;赎回腿 = 行上的根与写口放行的那一位住客(认领之前解析器那一读)。
+ * 读者:后台子代完成 relay(属主与化身,会话通知门的目标住客)、会话行记录座(化身)、请求腿的腿事实。
  */
 export interface DelegationRootWitness {
     readonly sessionId: string;
+    readonly owner: string | null;
     readonly incarnation: string | null;
 }
-/**
- * 「根行的化身已换 ⇒ 拒」在停驻挂点的那一道(挂点的见证是更早的一读,不是这一读):此刻根行在、而住客不是见证的那一位(见证那一读里不在,或是另一位)⇒ 抛。
- * 根行此刻不在 ⇒ 不抛(根真没了 ⇒ 律给哨兵,不是「换了住客」)。这是**判断**的一部分;判断之后、写之前根的变化不改变写进去的值(律:属主 = 判断时见证到的)。
- */
-export declare function assertRootStillWitnessed(sessionId: string, witness: DelegationRootWitness | undefined, judged: JudgedOwner): void;
-/** 记录委派树的宿主店多交的两只口(三只持久会话店与缓存包装层;无 repo 的内存店两只都没有 ⇒ 没有可按的树 ⇒ 不认领)。 */
-export interface DelegationTreeStore {
-    /** 本行落库的 placement 元组(`undefined` = 本行不是 placed 行 ⇒ 不记委派树)。 */
-    readonly placementOf: (sessionId: string) => Promise<PlacementSources | undefined>;
-    readonly claimOwnerless: OwnerlessClaim;
-}
-/** 停驻挂点要的宿主店口(按 id 读一行的唯一读口 `headOf` —— 属主与住客都是它的投影;记录委派树的店另有 {@link DelegationTreeStore})。 */
-export interface DelegatedOwnerHost {
-    readonly headOf: HeadRead;
-    /** 缺席 = 这只店不记委派树(不实现 placement)。 */
-    readonly trees: DelegationTreeStore | undefined;
-}
-/**
- * 「这只宿主店能不能承载委派子代的属主」—— 只判这一处(停驻挂点读它):店有按 id 的头读(`headOf`,「有没有」沿用 `headReadOf` 的同一处判法)⇒
- * 绑好的 {@link DelegatedOwnerHost};没有 ⇒ `undefined`(调用方响亮拒:读不回属主的宿主店上,停驻出来的就是一只谁都能读的转录)。记录委派树的两只口
- * (`placementOf` + `claimOwnerless`)**同在或同缺**:同在 ⇒ `trees`;同缺 ⇒ 不记委派树;只有一只 ⇒ `undefined`(记着树却认领不了,或认领却读不回树 —— 半只店不猜)。
- */
-export declare function delegatedOwnerHostOf(store: {
-    readonly headOf?: unknown;
-    readonly placementOf?: (sessionId: string) => Promise<PlacementSources | undefined>;
-    readonly claimOwnerless?: OwnerlessClaim;
-}): DelegatedOwnerHost | undefined;
-/** {@link settleDelegatedOwner} 的结果:这一笔是否写下了属主(认领成了);`judged` = 宿主行记着委派树时按**它记录的树**的那一次判(缺席 = 行不记委派树,按调用方的判)。 */
-export interface SettledOwner {
-    readonly claimed: boolean;
-    readonly judged: JudgedOwner | undefined;
-}
-/**
- * 宿主店里这只会话的行属主**按律定下来**(停驻挂点的那一道;拒句不带任何一方的属主值 —— 它会进停驻否决的错误面)。
- * `owner` / `tree` = 调用方按见证的根判出的属主与委派树。
- *  1. 宿主行**记着委派树**(placed 行):记下的根 ≠ `tree.root` ⇒ 抛(不以属主是否 null 为前提:那是另一棵树的行);是这一棵 ⇒ **按它记录的 placement(根、父)
- *     再判一次**(唯一判据 {@link judgeDelegatedOwner} —— 与 M23 / 建行复核对这一行同读数:根不在取父),调用方那一读之后根住客变了 ⇒ 抛({@link assertRootStillWitnessed},
- *     调用方的读数当见证);行无主而律给出属主 ⇒ 认领(CAS 刚读到的那一位住客;写进去的是这一次判的读数)—— **试了没落下 ⇒ 抛**(这一行在判断之后被写过 /
- *     删过 / 换了住客,不由事后的属主比对放行);
- *  2. 不记委派树的行(普通行,含升级前晋升进来的行)不认领、不再判;
- *  3. 比对 —— 此刻的属主不是律给的那一只(记着委派树 ⇒ 按记录的树判的那一只;否则 = `owner`)⇒ 抛。
- */
-export declare function settleDelegatedOwner(host: DelegatedOwnerHost, sessionId: string, owner: string | null, tree: DelegationTree): Promise<SettledOwner>;
-/** 按 id 逐只读头的店(`headOf`,活住客经 `sessionFaceOfHead` 投影 —— 空化身响亮拒)→ {@link SourceFacesReader}。 */
-export declare function sourceFacesVia(headOf: HeadRead): SourceFacesReader;
 //# sourceMappingURL=delegated-session-owner.d.ts.map

package/dist/delegated-session-owner.js

@@ -1,4 +1,3 @@
-import { headReadOf, sessionFaceOfHead } from "./session-incarnation.js";
 export const ORPHAN_SESSION_OWNER_PREFIX = "_orphan:";
 export function orphanSessionOwner(sessionId) {
     return `${ORPHAN_SESSION_OWNER_PREFIX}${sessionId}`;
@@ -25,26 +24,7 @@ export function inheritedOwnerOf(childId, sources) {
     return { kind: "orphan", owner: orphanSessionOwner(childId) };
 }
 export function judgeDelegatedOwner(childId, placement, faces) {
-    const sources = ownerSourcesOf(placement);
-    const inherited = inheritedOwnerOf(childId, sources.map((id) => [id, faces.get(id)?.owner]));
-    const root = sourceIdOf(placement.rootSessionId) ?? null;
-    return { inherited, sources, tree: { root, rootIncarnation: root === null ? null : (faces.get(root)?.incarnation ?? null) } };
-}
-export async function readDelegatedOwner(childId, placement, read) {
-    const ids = ownerSourcesOf(placement);
-    return judgeDelegatedOwner(childId, placement, ids.length === 0 ? new Map() : await read(ids));
-}
-export function reportWrittenOwner(log, site, childId, judged) {
-    if (judged.inherited.kind !== "orphan")
-        return;
-    log.warn("delegated_session_owner_orphaned", {
-        sessionId: childId,
-        site,
-        sources: judged.sources,
-        owner: judged.inherited.owner,
-        note: "a delegated session's owner could not be derived: none of the sessions it was delegated from has a row in this session store (none was named, or they are gone), " +
-            "so the session was written with an owner no caller can match — only fleet-wide and operator faces reach it. If someone should read it, set its owner in the session store by hand",
-    });
+    return inheritedOwnerOf(childId, ownerSourcesOf(placement).map((id) => [id, faces.get(id)?.owner]));
 }
 export const CLAIM_OWNERLESS_PLACED_SQL = {
     mysql: "UPDATE session_meta SET owner = ? WHERE session_id = ? AND incarnation = ? AND owner IS NULL AND placement_kind IS NOT NULL",
@@ -53,66 +33,4 @@ export const CLAIM_OWNERLESS_PLACED_SQL = {
 export function claimOwnerlessParams(sessionId, incarnation, owner) {
     return [owner, sessionId, incarnation];
 }
-export async function createPlacedSessionRow(sessionId, placement, io, log) {
-    const judged = await readDelegatedOwner(sessionId, placement, io.readFaces);
-    await io.insert(judged.inherited.owner);
-    if (judged.inherited.kind === "orphan" && (await io.readOwner()) === judged.inherited.owner)
-        reportWrittenOwner(log, "placed_create", sessionId, judged);
-}
-export function assertRootStillWitnessed(sessionId, witness, judged) {
-    if (witness === undefined || judged.tree.rootIncarnation === null || judged.tree.rootIncarnation === witness.incarnation)
-        return;
-    throw new Error(`session "${sessionId}" cannot be parked as this delegated session: its delegation tree's root session was deleted and its id registered again since the delegation was judged, ` +
-        "so the root's current owner is not the owner of this delegation tree");
-}
-export function delegatedOwnerHostOf(store) {
-    const headOf = headReadOf(store);
-    const placementOf = store.placementOf;
-    const claimOwnerless = store.claimOwnerless;
-    if (headOf === undefined)
-        return undefined;
-    if ((typeof placementOf === "function") !== (typeof claimOwnerless === "function"))
-        return undefined;
-    const trees = typeof placementOf === "function" && typeof claimOwnerless === "function"
-        ? { placementOf: (id) => placementOf.call(store, id), claimOwnerless: (id, incarnation, owner) => claimOwnerless.call(store, id, incarnation, owner) }
-        : undefined;
-    return { headOf, trees };
-}
-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), 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);
-    let expected = owner;
-    let judged;
-    let claimed = false;
-    if (face !== undefined && trees !== undefined && recorded !== undefined) {
-        if ((sourceIdOf(recorded.rootSessionId) ?? null) !== tree.root)
-            throw refuse();
-        judged = await readDelegatedOwner(sessionId, recorded, sourceFacesVia(host.headOf));
-        if (tree.root !== null)
-            assertRootStillWitnessed(sessionId, { sessionId: tree.root, incarnation: tree.rootIncarnation }, judged);
-        expected = judged.inherited.owner;
-        if (face.owner === null && expected !== null) {
-            claimed = await trees.claimOwnerless(sessionId, face.incarnation, expected);
-            if (!claimed)
-                throw refuse();
-        }
-    }
-    if ((await host.headOf(sessionId))?.owner !== expected)
-        throw refuse();
-    return { claimed, judged };
-}
-export function sourceFacesVia(headOf) {
-    return async (ids) => {
-        const out = new Map();
-        for (const id of ids) {
-            const face = sessionFaceOfHead(id, await headOf(id));
-            if (face !== undefined)
-                out.set(id, face);
-        }
-        return out;
-    };
-}
 //# sourceMappingURL=delegated-session-owner.js.map

package/dist/device-ws-protocol.d.ts

@@ -75,6 +75,7 @@ export declare const DEVICE_OUTCOME_ERROR_CODES_BY_REVISION: {
     readonly 1: readonly ["aborted", "already_exists", "auth_failed", "callback_error", "invalid", "is_directory", "not_directory", "not_found", "not_supported", "outcome_unknown", "permission_denied", "precondition_failed", "shell_unavailable", "spawn_error", "suspended", "target_unavailable", "timeout", "transport_lost", "unknown"];
     readonly 2: readonly ["liveness_no_output"];
     readonly 3: readonly ["name_too_long"];
+    readonly 4: readonly ["symlink_loop"];
 };
 /** 本包认得的协议修订号(= 增量表的行键)。 */
 export type DeviceProtocolRevision = keyof typeof DEVICE_OUTCOME_ERROR_CODES_BY_REVISION;

package/dist/device-ws-protocol.js

@@ -1,7 +1,7 @@
 import { createPublicKey, randomBytes, randomInt, verify as edVerify } from "node:crypto";
 import { MAX_TIMER_DELAY_MS, inWholeNumberBounds, wholeNumberBoundsRule } from "./config-types.js";
 export const DEVICE_WS_PATH = "/v1/device/ws";
-export const DEVICE_PROTOCOL_VERSION = 3;
+export const DEVICE_PROTOCOL_VERSION = 4;
 export const DEVICE_MIN_PROTOCOL_VERSION = 1;
 export const DEVICE_HELLO_DOMAIN_TAG = "sema.device.hello.v1";
 export const DEVICE_WS_LIMITS = {
@@ -67,6 +67,7 @@ export const DEVICE_OUTCOME_ERROR_CODES_BY_REVISION = {
     ],
     2: ["liveness_no_output"],
     3: ["name_too_long"],
+    4: ["symlink_loop"],
 };
 export function deviceOutcomeErrorCodesAt(revision) {
     if (!Number.isInteger(revision) || revision < 1 || revision > DEVICE_PROTOCOL_VERSION) {

package/dist/entry-mode-clamp-notice.d.ts

@@ -18,7 +18,7 @@
  * `{ requested, effective, ceiling, sessionId }` —— `requested` = 被折的那个词(体的生效词:顶层 `permissionMode` 或
  * `settings.permissions.defaultMode`)、`effective` = run 起步的词、`ceiling` = 折它的地板,三个都是 core 的模式闭集词;`sessionId` = 归属键。
  * 🔴 **无 `runId`**:钳制发生在受理门,引擎的 run 身份要到 prepare 才铸,这一刻不存在(core 码册那一行写了 `runId`;本仓不编造,
- * 归属看它落在哪条 run 的流 / 账本上 —— 与 `instructions.source_changed` / `session.records_skipped` 同形)。
+ * 归属看它落在哪条 run 的流 / 账本上 —— 与 `instructions.source_changed` 同形)。
  * 什么时候不铸:没有地板;没声明词(取地板本身不算改词,`clamped` 为假);请求的词不比地板松;会话 id 缺席(无处可投,宁缺不串)。
  */
 import type { EngineNotice, EngineNoticeCode } from "@sema-agent/core";

package/dist/env-model-table-gate.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 本地配置腿上「一份管模型面的目录能不能顶替已声明的 env 模型表」—— **唯一判官**与它的拒句;以及候选随身带的那一份事实 {@link CatalogSource}。
+ *
+ * ## 律(一条)
+ * 一份候选的模型面被组拒 `config.catalog_replaces_env_models`,当且仅当四件同时成立:
+ *  ① 候选来自**本地配置腿**({@link CatalogSource} 的 `local` 臂;中心腿不守卫 —— 中心发布的目录照旧整表顶替 env 表);
+ *  ② 候选**管**模型面(模型面 stage 已走过「一条启用条目也没有 ⇒ 不管」那条捷径 —— 本判官只在它之后被问);
+ *  ③ env 模型表**已声明**且不是占位(`MODEL_ID` 铸出了条目;严格名册布防时 env 表是占位、不算);
+ *  ④ 配置根上的决定读数**不是** `replaced`(缺席 / `kept` / 读不懂 —— 运行记录在场之后缺席 ≡ `kept`,读不懂的不许读成确认)。
+ * 拒 ⇒ 模型面这一组停在上一代(起服:env 表;刷新拍:在服的那一代),其余组照落;拒句点名被顶替的 env 模型、决定文件的路径与两条出路。
+ *
+ * 执法点:模型面 stage 经登记条 `config-invariants.ts` 的 `env-table-replacement-acknowledged` 调本判官(候选的事实随 `CrossInvariantInput.candidate` 交来)。
+ *
+ * ## 一个读者
+ * 决定文件的字节只有契约的 `readEnvModelsDecision` 打开:`LocalConfigProvider.fetchEffective` 在读候选的**同一拍**调它,读数随候选交出
+ * (`FetchEffectiveResult.catalogSource`;本地 etag 由同一份读数的身份 `envModelsDecisionTag` 并入)。本模块与模型面 stage 只读这份读数,不开文件。
+ * 「env 表已声明」读的是引擎**自己铸的那张** env 表(模型面 stage 的 env 快照),不再读一遍 env。
+ */
+import { CATALOG_REPLACES_ENV_MODELS_CODE, type EnvModelTableEntry, type EnvModelsDecision } from "@sema-agent/settings-schema";
+/**
+ * 一份目录候选**从哪条配置腿来**(以及本地腿上,配置根的 env 模型表决定在**同一拍**读作什么)。必填、没有缺省腿:安全轴上「忘了说是哪条腿」
+ * 不许静默落成某一种语义(与 `ApplyLeg` 同一条纪律)。铸点:`LocalConfigProvider.fetchEffective`(`local` 臂,带 `root` 与那一读的决定)、
+ * `RemoteConfigProvider.fetchEffective` 与盘上 LKG 读回(`remote` 臂 —— LKG 只在中心腿启用)。
+ */
+export type CatalogSource = {
+    readonly kind: "local";
+    readonly root: string;
+    readonly envModels: EnvModelsDecision;
+} | {
+    readonly kind: "remote";
+};
+/** 中心腿的那一份(冻结;中心腿不守卫,没有可带的事实)。 */
+export declare const REMOTE_CATALOG_SOURCE: CatalogSource;
+/** 判官的拒决(码与句出自同一次判决)。 */
+export interface EnvTableReplacementRefusal {
+    readonly code: typeof CATALOG_REPLACES_ENV_MODELS_CODE;
+    readonly reason: string;
+}
+/** 判官的输入(纯数据)。 */
+export interface EnvTableReplacementInput {
+    /** 引擎自己铸的那张 env 表的条目(槽序;空 = env 表没声明)。 */
+    readonly envTable: readonly EnvModelTableEntry[];
+    /** 严格名册布防(`isRosterGateArmed`):env 表是占位、从不被派发 ⇒ 对本闸等于没声明。 */
+    readonly envTableIsPlaceholder: boolean;
+    readonly source: CatalogSource;
+}
+/**
+ * **唯一判官**(见文件头的律;② 由调用方的位置保证)。通过 ⇒ `undefined`。两只闭集都穷举:腿加一臂 / 决定加一词不补 ⇒ 编译红。
+ */
+export declare function judgeEnvTableReplacement(input: EnvTableReplacementInput): EnvTableReplacementRefusal | undefined;
+/** 配置根上决定文件的路径(文件名取契约的文档名,不手抄)。 */
+export declare function envModelsDocumentPath(root: string): string;
+//# sourceMappingURL=env-model-table-gate.d.ts.map