@sema-agent/server 7.151.0 → 7.152.0

package/dist/entry-problems.d.ts

@@ -1,14 +1,51 @@
+/**
+ * **条目问题的机读位** —— 请求体里的工具名清单 / 规则表有坏条目时,拒体(提交口 400 · 设置规则 422 · 续跑重放 409)与受理应答(`warnings`)说「哪几条、为什么」的**唯一一只形**,一处铸。
+ *
+ * 形(拒体机读位的版式律:事实在拒体根上,`problems[]` 每项的领域结构原样):
+ *   拒体   `{ error, errorCode, field, problems: EntryProblem[], total }`
+ *   应答   `{ …, warnings: EntryProblem[] }`(受理了、没拒,只告;只在有话说时在场)
+ *   一条问题 `{ code, field, entry, reason }`:
+ *    · `code`   = 这一条所在的那张清单**被拒时**拒体会带的码(技能清单 `request.field_invalid`;子代定义的 `denyTools` / `allowTools` `config.agent.unknown_tool`;根 run 的
+ *                 `excludeTools` / `allowTools` `config.tool_face_control`;设置规则桶 `request.unprocessable`)—— 一条问题就是「一只迷你拒绝」;
+ *    · `field`  = 这一条所在清单的**体内坐标**(`agents[0].denyTools`、`excludeTools`、`settings.permissions.deny`;不带条目下标);
+ *    · `entry`  = 条目的脱敏原值({@link redactListEntry}:不加引号、不转义,认出的凭据换记号);
+ *    · `reason` = 为什么这一条什么也不是,闭词:引擎条目读法的原因词原样(`near_miss` / `tool_name` / `grammar` / `content_unsupported` / `wildcard_all` / `namespace_wildcard`),
+ *                 规则编译器那一面的判词(引擎名字判官的 `retired` / `unmintable_segment` / `unprefixed_namespace`、引擎规则文法的 `invalid.*` · `unsupported.*` 码原样),
+ *                 契约包层准入的判词(`below_trust_floor`),与本仓自己的三词({@link SERVER_ENTRY_PROBLEM_REASONS})。铸点的实参型是这几张表的并({@link EntryProblemReason}):
+ *                 写一个哪张表都没有的词 = tsc 红(本仓自己的词只能从闭集取)。
+ *  · 拒体的 `error` 句子**不变**:码与句子仍是「先撞上的那一张清单」的(第一条问题的码与坐标 = 体的 `errorCode` 与顶层 `field`),机读位另把**这一遍判下来的全部问题**一次列全 ——
+ *    单条问题的体 = 列表长 1,不是另一种形。
+ *  · `total` = 这一遍判下来的问题总数;`problems` 至多 {@link MAX_ENTRY_PROBLEMS} 条(按扫描序截,每张清单自己的条数帽另在先:超帽的清单整只拒、不逐条读,不进本列表)。
+ *    `total > problems.length` ⇒ 被截过。拒体恒有 `total`,缺席的「被截与否」不靠数条数猜。
+ *
+ * 为什么机读位只有这一个铸点:壳要按条提示、不解析句子(句子给人读,`error` 文案冻结但不是协议);一个面一个自己的键表就是 [ref] / [ref] 之后又一种形。
+ */
+import type { AllowEntryInertReason, PermissionRuleIssue } from "@sema-agent/core";
+import type { LayerAdmissionVerdict } from "@sema-agent/settings-schema";
+import type { UnmatchableRuleName } from "./namespaced-rule-name.js";
 /** `problems` 的条数上限(= 一张清单的条数帽 `MAX_ALLOW_LAYER_ENTRIES` 的数;数在这里写死一次,`rule-entry-list.ts` 的帽改了不应拖着机读位走 —— 两者是两个界)。 */
 export declare const MAX_ENTRY_PROBLEMS = 1000;
 /**
  * 本仓自己铸的 `reason` 词(闭集;其余 `reason` 是引擎的词原样 —— 见文件头):
  *  · `not_in_roster` —— 受理应答 `warnings` 的词:放行侧选择器清单里的这个名字不在名册(引擎目录 ∪ 本仓自铸工具 ∪ 本请求挂的调用方工具)、也不是协议命名空间名(懒挂载),引擎照旧受理、之后只告运维;
- *  · `home_unresolvable` —— 设置规则 422 的词:`~/` 形路径规则而本部署解不出执行环境的家目录。
+ *  · `home_unresolvable` —— 设置规则 422 的词:`~/` 形路径规则而本部署解不出执行环境的家目录;
+ *  · `cc_rule_form` —— 名表消费者(按**整串工具名**比对的那几张表:`settings.permissions.neverAuto`,以及运维 / 中心的审批名单)里的带括号条目:这张表只比整名,
+ *    `Bash(ls)` 永远匹配不到任何活工具。判据是本仓这几张表的比对方式,不是引擎的读法(引擎的 allow 层对同一条另有判词,读的是另一张表)⇒ 本仓的词。
  */
-export declare const SERVER_ENTRY_PROBLEM_REASONS: readonly ["not_in_roster", "home_unresolvable"];
+export declare const SERVER_ENTRY_PROBLEM_REASONS: readonly ["not_in_roster", "home_unresolvable", "cc_rule_form"];
 export type ServerEntryProblemReason = (typeof SERVER_ENTRY_PROBLEM_REASONS)[number];
 /** 「读得出、却不在名册」的告知词({@link SERVER_ENTRY_PROBLEM_REASONS} 的第一员):`warnings` 里它之外的词都是引擎的条目读法读成空的原因词。 */
 export declare const NOT_IN_ROSTER: ServerEntryProblemReason;
+/** 「执行环境的家目录 / 配置根读不出」的拒词(设置规则 422;两个铸点同读这一只)。 */
+export declare const HOME_UNRESOLVABLE: ServerEntryProblemReason;
+/** 「名表消费者里的带括号条目」的拒词(`config.ts` 的名表判据是唯一铸点)。 */
+export declare const CC_RULE_FORM: ServerEntryProblemReason;
+/**
+ * 一条问题的 `reason` 可以是哪些词 —— 铸点实参的型(wire 上的 `reason` 仍按开集读:引擎的词表随引擎版本增减):
+ * 本仓自铸的三词 ∪ 引擎条目读法的原因词 ∪ 引擎名字判官的判词 ∪ 引擎规则文法的码 ∪ 契约包层准入的 `below_trust_floor`。
+ * 哪张表都没有的词在铸点 tsc 红 —— 「自铸了闭集外的词」不可能静默上 wire。
+ */
+export type EntryProblemReason = ServerEntryProblemReason | AllowEntryInertReason | UnmatchableRuleName["kind"] | PermissionRuleIssue["code"] | Extract<LayerAdmissionVerdict, "below_trust_floor">;
 /** 一条问题(wire 形)。 */
 export interface EntryProblem {
     readonly code: string;
@@ -17,7 +54,7 @@ export interface EntryProblem {
     readonly reason: string;
 }
 /** 铸一条问题:`entry` 收**原串**,这里过脱敏(调用方没有「忘了脱敏」的可能)。 */
-export declare function entryProblem(code: string, field: string, rawEntry: string, reason: string): EntryProblem;
+export declare function entryProblem(code: string, field: string, rawEntry: string, reason: EntryProblemReason): EntryProblem;
 /** 拒体上的机读位(原样摊在拒体根上:`HttpError.extra` / `refusalBody` 的 `facts`)。型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用。 */
 export type EntryProblemsFacts = {
     readonly field: string;

package/dist/entry-problems.js

@@ -1,7 +1,9 @@
 import { redactListEntry } from "./list-entry-display.js";
 export const MAX_ENTRY_PROBLEMS = 1_000;
-export const SERVER_ENTRY_PROBLEM_REASONS = ["not_in_roster", "home_unresolvable"];
+export const SERVER_ENTRY_PROBLEM_REASONS = ["not_in_roster", "home_unresolvable", "cc_rule_form"];
 export const NOT_IN_ROSTER = "not_in_roster";
+export const HOME_UNRESOLVABLE = "home_unresolvable";
+export const CC_RULE_FORM = "cc_rule_form";
 export function entryProblem(code, field, rawEntry, reason) {
     return { code, field, entry: redactListEntry(rawEntry), reason };
 }

package/dist/execution-env-refusal.d.ts

@@ -2,7 +2,8 @@
  * 本仓自铸的**执行环境拒码**闭集(`env.*` 族)的唯一属主(纯叶:零值依赖)。
  *
  * 一族一句:**这只执行环境没开,而且再问也是同一个答** —— 部署状态(或会话数据)与这条 run 冲突,原样重试不改判,出路在部署。两处产出、同一族:
- *  · host 车道的工厂在铸环境之前拒(读数在构造时就到手:`lane-home-probe.ts` 的 `laneHomeRefusal`),引擎在准备期原样再抛;
+ *  · 工厂在铸环境之前拒(host 车道:读数在构造时就到手,`lane-home-probe.ts` 的 `laneHomeRefusal`;k8s 车道:每条 run 铸环境前读一次集群 API 凭据,
+ *    `boot/execution-env.ts` 的 `createK8sRunEnvFactory`),都经 {@link executionEnvRefusalError} 铸带码的错,引擎在准备期原样再抛、run 以它失败;
  *  · 远端车道在建连时答的**立定拒**(这只环境此后每一次建连都答同一个拒,适配器记住它):码由 `plugins/remote-env-connect-seat.ts` 的拒因表从事实词拼出
  *    —— 那张表是远端车道拼本族码的唯一入口,立定 ⇔ 码在引擎可重试表之外 ⇔ 记住。
  * 同步提交腿按零工作拒落档(`runs.ts` 的 `EXECUTION_ENV_REFUSAL_HTTP_STATUS`,按本闭集键控:加一员而档没跟 ⇒ tsc 红)。
@@ -12,12 +13,17 @@
  *    `WORKSPACE_SNAPSHOT_BUCKET` 指向已有的桶,或 `WORKSPACE_PERSIST=off`。
  *  · `env.occupant_missing` —— k8s 车道读这条 run 的会话住客:会话行在、却不带住客令牌(存储数据缺陷,重发不改判):给行补令牌或删会话,或关掉要它的旋钮。
  *  · `env.sandbox_refused` —— 隔离车道(k8s / e2b / local-docker)替这条 run 建的沙箱被立定地拒:集群在准入时拒了 pod、成员凭据中继建不起来、
- *    快照归档在桶里却取不回、工作区的填充(会话附件 / 项目包种子)放不进且换一台机器也是同一个答。是哪一件、怎么改,句子里说。
+ *    快照归档在桶里却取不回、工作区的填充(会话附件 / 项目包种子)放不进且换一台机器也是同一个答、k8s 车道的集群 API 凭据起服之后读不到或被集群 401 拒
+ *    (`k8s-api-credentials.ts`:凭据起服时就缺是起服拒 `config.k8s_api_credentials_missing`,到不了 run)。是哪一件、怎么改,句子里说。
  *  · `env.host_key_rejected` —— ssh 车道:目标机出示的主机密钥过不了部署钉的判(`SSH_HOST_FINGERPRINT` / `SSH_KNOWN_HOSTS`:指纹不符、条目换了钥、被吊销、没有条目)。
  *    改钉或查明对面为什么换了钥;同一配置同一主机每次同答。
  */
 export declare const EXECUTION_ENV_REFUSAL_CODES: readonly ["env.home_unconfirmed", "env.snapshot_bucket_missing", "env.occupant_missing", "env.sandbox_refused", "env.host_key_rejected"];
 export type ExecutionEnvRefusalCode = (typeof EXECUTION_ENV_REFUSAL_CODES)[number];
+/** 本族的带码错(唯一铸点):句 = 拒句原文,`code` = 闭集里的一员;工厂原样抛出,引擎在准备期再抛,run 的失败终局原样承运码与句。 */
+export declare function executionEnvRefusalError<C extends ExecutionEnvRefusalCode>(code: C, message: string): Error & {
+    readonly code: C;
+};
 /** 这个码是不是本族的一员(按闭集,不按前缀:引擎自己的 `env.lifetime_expired` 同前缀而不是本族)。 */
 export declare function isExecutionEnvRefusalCode(code: unknown): code is ExecutionEnvRefusalCode;
 //# sourceMappingURL=execution-env-refusal.d.ts.map

package/dist/execution-env-refusal.js

@@ -1,4 +1,7 @@
 export const EXECUTION_ENV_REFUSAL_CODES = ["env.home_unconfirmed", "env.snapshot_bucket_missing", "env.occupant_missing", "env.sandbox_refused", "env.host_key_rejected"];
+export function executionEnvRefusalError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
 export function isExecutionEnvRefusalCode(code) {
     return typeof code === "string" && EXECUTION_ENV_REFUSAL_CODES.includes(code);
 }

package/dist/fleet/engine-signal.d.ts

@@ -20,22 +20,17 @@
  *     注入了读数也不读;所以「`/health` 不报 `leaseState` 而准入照按租约拒」这一形构造不出来。
  *     **身份不是引擎态**:`instanceId`(本进程起步自铸的那一只,`boot/stage-03` 的 uuidv7)是体的身份,只在两出口体的**顶层**说一次,
  *     铸点不读它、契约形里不重复它。
- *  5. **两形一读(展开 / 收缩)**:两出口今天各发两形 —— 嵌套键 {@link ENGINE_SIGNAL_KEY}(契约 `EngineSignal` 整只,{@link buildEngineSignal}),
- *     与 8.0 扁平方言(布尔 `draining` + `drainingSince`、`/health` 就绪时不带 `ready`、`restart`、成员三键、`/health` 的世代账)。两形读的是
- *     **同一次**铸点读数里的**同一个字段**,投影全在本模块({@link buildEngineSignal} / {@link heartbeatReadinessKeys} / {@link healthDrainingKeys} /
- *     {@link fleetMembershipKeys} / {@link healthConfigLedgerKeys}),出口文件不拼引擎态的键。排空在两形上读的都是排空**事实**(`EngineDraining`,
- *     三键齐才在),不是就绪原因 —— 所以「`engineSignal.draining` 在场 ⇔ 扁平 `draining` 为真、`drainingSince` = `engineSignal.draining.since`」
- *     是构造出来的,不靠「唯一入口整组写四键」这条运行时不变量(那条不变量只管就绪原因与事实一致)。
- *     心跳体 = 契约 `InstanceAnnouncement` + 嵌套键这一只:契约包 10.x 的心跳形还没有它的座位,10.x 中心按默认 strip 解析丢掉它、照收心跳;
- *     世代账扁平两键契约心跳形没有座位,只上 `/health`(嵌套形里有,两出口都带)。非 fleet 部署的扁平键与 7.122.0 逐字同。
- *     收缩:扁平布尔对(`draining` / `drainingSince`)settings-schema 12.0.0 从契约形删、本引擎 7.124.0+ 删发(届时删它们的投影);嵌套键名在
- *     契约包自有这只常量的那一版提货时改读它。
+ *  5. **一形**:引擎态只在体上的一只键 `engineSignal`(契约包 `ENGINE_SIGNAL_KEY`,本仓不另拼)下说,值 = 契约 `EngineSignal` 整只({@link buildEngineSignal})。
+ *     心跳体 = 契约 `InstanceAnnouncement`(身份 + `modelRefusals`)+ 这一只键 —— 8.0 扁平方言(平铺 `ready` / 布尔 `draining` / `restart` / 成员三键)
+ *     随契约包 26.0.0 从心跳形删除,本引擎同版停发;`/health` 的平铺排空对(布尔 `draining` + `drainingSince`)同版停发。`/health` 上其余与信号同名的顶层键
+ *     (`restart` / 成员三键 / 世代账)是本仓自己的诊断面 wire(契约 `InstanceHealth` 从未给它们座位,读方是 sdk 的 `/health` 读型),投影仍全在本模块
+ *     ({@link fleetMembershipKeys} / {@link healthConfigLedgerKeys}),出口文件不拼引擎态的键。
  *  6. **租约四态的词表属主是契约包**(`LeaseState`):本模块的读数型 {@link ServingLeaseView} 按它逐词对齐(下面的编译期断言两向钉),
  *     契约加一个词 ⇒ 本仓编译红,不会悄悄多出一个本仓读不出的态。
  *
- * 模块形:纯函数(契约包只 import 型;值 import 只有两只纯叶 `http/readiness.ts` 与 `fleet/drain-entry.ts`)—— `http/` 与 `fleet-client.ts` 都读它,不许长出回环。
+ * 模块形:纯函数(契约包只取型与键名常量 `ENGINE_SIGNAL_KEY`;本仓值 import 只有两只纯叶 `http/readiness.ts` 与 `fleet/drain-entry.ts`)—— `http/` 与 `fleet-client.ts` 都读它,不许长出回环。
  */
-import type { EngineDraining, EngineSignal, InstanceAnnouncement, LeaseState, RestartSignal } from "@sema-agent/settings-schema/fleet";
+import { ENGINE_SIGNAL_KEY, type EngineDraining, type EngineSignal, type LeaseState, type RestartSignal } from "@sema-agent/settings-schema/fleet";
 import { type ReadinessInputs, type ReadinessVerdict } from "../http/readiness.js";
 /**
  * 租约此刻的读数(租约客户端交出;纯数据)。态的词表 = 契约 `LeaseState`(四词的语义在契约注里:`none` 不生效 / `granted` 持有 /
@@ -52,8 +47,8 @@ export type ServingLeaseView = {
 } | {
     readonly state: Extract<LeaseState, "denied">;
 };
-/** 心跳体上的 fleet 成员三键 —— 类型取自契约心跳形(拼法与值域只有契约一个写者)。 */
-export type FleetMembershipKeys = Pick<InstanceAnnouncement, "generation" | "leaseState" | "leaseUntil">;
+/** `/health` 上的 fleet 成员三键 —— 类型取自契约 `EngineSignal` 的同名键(拼法与值域只有契约一个写者)。 */
+export type FleetMembershipKeys = Pick<EngineSignal, "generation" | "leaseState" | "leaseUntil">;
 /** 非 fleet 成员 / 没装租约客户端时的读数(唯一拼法)。成员的推定围栏只住在租约客户端里,不进这只缺省值。 */
 export declare const LEASE_NONE: ServingLeaseView;
 /**
@@ -148,12 +143,7 @@ export interface EngineSignalFacts {
 }
 /** **唯一**铸点(活判,每次调用现读输入)。 */
 export declare function mintEngineSignal(deps: EngineSignalInputs): EngineSignalFacts;
-/**
- * 两出口体上嵌套引擎信号的键名(规则 5;两出口同一只拼法)。契约包 10.x 没有这只常量(它的心跳形也没有这一座位);契约包自有它的那一版
- * 提货时,本常量删、改读契约包的。
- */
-export declare const ENGINE_SIGNAL_KEY = "engineSignal";
-/** 体上的嵌套引擎信号:键 {@link ENGINE_SIGNAL_KEY},值 = 契约 `EngineSignal`。 */
+/** 体上的嵌套引擎信号:键 = 契约包的 `ENGINE_SIGNAL_KEY`(两出口同一只拼法,本仓不另拼),值 = 契约 `EngineSignal`。 */
 export type EngineSignalCarrier = {
     readonly [ENGINE_SIGNAL_KEY]: EngineSignal;
 };
@@ -163,18 +153,11 @@ export type EngineSignalCarrier = {
  */
 export declare function buildEngineSignal(s: EngineSignalFacts): EngineSignal;
 /**
- * fleet 成员身份三键的**唯一**投影(两出口同调,同值同序):`generation` / `leaseState` / `leaseUntil`。
- * 在场律:非 fleet 成员(无 `generation`)⇒ 空对象(两出口逐字节同 7.120.0);成员 ⇒ `generation` + `leaseState` 恒在,
+ * fleet 成员身份三键的**唯一**投影(嵌套信号与 `/health` 顶层同调,同值同序):`generation` / `leaseState` / `leaseUntil`。
+ * 在场律:非 fleet 成员(无 `generation`)⇒ 空对象;成员 ⇒ `generation` + `leaseState` 恒在,
  * `leaseUntil` 只在 `granted`。
  */
 export declare function fleetMembershipKeys(s: EngineSignalFacts): FleetMembershipKeys;
-/** 心跳的 8.0 扁平方言 `ready` / `draining`(恒带,`false` 也带):`ready` = 就绪判,`draining` = 排空事实在场(规则 5,与嵌套形读同一个字段)。 */
-export declare function heartbeatReadinessKeys(s: EngineSignalFacts): Pick<InstanceAnnouncement, "ready" | "draining">;
-/** `/health` 的 8.0 扁平排空对:只在排空中带 —— `draining: true` + `drainingSince` = 排空事实的 `since`(规则 5,与嵌套形读同一个字段)。 */
-export declare function healthDrainingKeys(s: EngineSignalFacts): {
-    readonly draining?: true;
-    readonly drainingSince?: number;
-};
 /**
  * `/health` 的世代账扁平键(未接线 ⇒ 全缺席):target / applied 两版本(与嵌套形同一次读数)+ 两只收货序数(进程内单调,「见过多少代 / 停在哪一代」
  * 的推进判据)+ `configApplyStaleMs`(两者持续不等的时长,收敛即缺席)。只上 `/health`(契约心跳形没有这些座位)。

package/dist/fleet/engine-signal.js

@@ -1,3 +1,4 @@
+import { ENGINE_SIGNAL_KEY } from "@sema-agent/settings-schema/fleet";
 import { readinessOf } from "../http/readiness.js";
 import { drainingFactOf } from "./drain-entry.js";
 export const LEASE_NONE = Object.freeze({ state: "none" });
@@ -37,7 +38,6 @@ export function mintEngineSignal(deps) {
         ...(configApply !== undefined ? { configApply } : {}),
     };
 }
-export const ENGINE_SIGNAL_KEY = "engineSignal";
 export function buildEngineSignal(s) {
     return {
         ready: s.verdict.ready,
@@ -64,12 +64,6 @@ export function fleetMembershipKeys(s) {
         }
     }
 }
-export function heartbeatReadinessKeys(s) {
-    return { ready: s.verdict.ready, draining: s.draining !== undefined };
-}
-export function healthDrainingKeys(s) {
-    return s.draining === undefined ? {} : { draining: true, drainingSince: s.draining.since };
-}
 export function healthConfigLedgerKeys(s) {
     const g = s.configApply;
     if (g === undefined)

package/dist/fleet-client.js

@@ -1,5 +1,5 @@
-import { InstanceAnnouncement, UsageReport, DEFAULT_HEARTBEAT_MS, readCapabilityReading } from "@sema-agent/settings-schema/fleet";
-import { ENGINE_SIGNAL_KEY, buildEngineSignal, fleetMembershipKeys, heartbeatReadinessKeys } from "./fleet/engine-signal.js";
+import { ENGINE_SIGNAL_KEY, InstanceAnnouncement, UsageReport, DEFAULT_HEARTBEAT_MS, readCapabilityReading } from "@sema-agent/settings-schema/fleet";
+import { buildEngineSignal } from "./fleet/engine-signal.js";
 import { centerFetch, centerLaneConfigured } from "./web-admin-client/center-request.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { createIdentityBins, pinAccountingIdentity } from "./center-credential.js";
@@ -153,11 +153,8 @@ export function startFleetClient(opts) {
                 worker: opts.center.worker,
                 address,
                 version: opts.version,
-                ...heartbeatReadinessKeys(signal),
                 heartbeatMs,
-                ...(signal.restart !== undefined ? { restart: signal.restart } : {}),
                 ...(modelRefusals !== undefined ? { modelRefusals } : {}),
-                ...fleetMembershipKeys(signal),
                 [ENGINE_SIGNAL_KEY]: engineSignal,
             };
             sending = true;

package/dist/gate-settlement.d.ts

@@ -12,8 +12,7 @@
  * 调用方对一条引擎续跑腿的分类({@link GateCommitment})只说「这条腿到边界时能证什么」,**从不单独铸位** —— 位要有边界作证。
  * 不铸的出口(都在调用点成文):`checkpoint.resume_aborted` 取消(拿不到 resolve 的返回值 ⇒ 证不出)、抛出臂的取消(受理之后也可能走到 ⇒
  * **刻意不带**证据,fail-closed)、4xx、交给宿主 / 新铸一跑 / 同一决定重投的回执(`delivered`,门由别人结清或仍待决)、停驻子代认领到的
- * token 不是选中的那一张(⇒ `409 decide.gate_moved`,不复活)。证据只随**同一次决定**的回放走:停驻赎回席的反向重试回放摘掉它
- * ({@link withoutSettlementEvidence})。
+ * token 不是选中的那一张(⇒ `409 decide.gate_moved`,不复活)。
  *
  * ## 读法(三句,契约 §4a「结清证据」同句)
  *  · 位在场 ⇒ 门已以此决定结清过(历史证据;与 `errorCode:"cancelled"` 或 `retriable:true` 并存时同样成立 —— 它不证明卡的**当前**状态、
@@ -57,12 +56,6 @@ export interface GateSettlementEvidence {
 export declare const NO_SETTLEMENT_EVIDENCE: GateSettlementEvidence;
 /** **唯一铸点**:一次边界跨越 → 体上的证据片段。 */
 export declare function buildSettlementEvidence(crossing: SettlementCrossing): GateSettlementEvidence;
-/**
- * 一张已带证据的回执被拿去答**另一个**决定(停驻赎回席的反向重试:回放首次受理的那一向、不改判)⇒ 证据两键都摘掉 ——
- * 证据说的是当初被结清的那次决定,这一次请求的决定从没被结清。同向重试是同一次请求的回放,体原样(证据随它)。
- * 只摘、不铸:本模块之外没有第二个写这两键的地方。
- */
-export declare function withoutSettlementEvidence<B extends Record<string, unknown>>(body: B): Omit<B, keyof GateSettlementEvidence>;
 /** **唯一读法**:这张回决应答说「门已以此决定结清过」吗(`200` 且体上的位为真)。两个读者同调这一只。 */
 export declare function decisionCommittedOf(out: {
     readonly status: number;

package/dist/gate-settlement.js

@@ -30,10 +30,6 @@ export function buildSettlementEvidence(crossing) {
         }
     }
 }
-export function withoutSettlementEvidence(body) {
-    const { decisionCommitted: _committed, checkpointId: _identity, ...rest } = body;
-    return rest;
-}
 export function decisionCommittedOf(out) {
     return out.status === 200 && out.body.decisionCommitted === true;
 }

package/dist/history-anchor.js

@@ -2,7 +2,7 @@ import { HttpError } from "./security.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { protocolEntry, readVisibleRun } from "./http/owner-access.js";
 const NO_ANCHOR = "no rewind anchor is recorded under that handle";
-const PROMPT_WITHOUT_ANCHOR = `${NO_ANCHOR}: it names a prompt of this session that recorded none (a prompt that carried attachments records none when its attachment frames were interrupted or their count did not match)`;
+const PROMPT_WITHOUT_ANCHOR = `${NO_ANCHOR}: it names a prompt of this session that recorded none`;
 export function anchorReaderOf(req, w, caller) {
     return protocolEntry(req, w, "run.anchor", caller);
 }

package/dist/hitl-delivery.d.ts

@@ -16,10 +16,9 @@
 import type { QuestionFrame } from "./question.js";
 import type { ElicitationFrame } from "./elicitation.js";
 import type { ApprovalCardLegFrame, ApprovalRevokeFrame } from "./approval-card.js";
-import type { ToolApprovalFrame } from "./tool-approval.js";
 import type { LedgerEventType } from "./trace/ledger-events.js";
-/** 三族的人在环帧(开 / 收 / 撤)。九个帧型全在账本闭集里(下面那条编译期断言)。 */
-export type HitlFrame = QuestionFrame | ElicitationFrame | ApprovalCardLegFrame | ApprovalRevokeFrame | ToolApprovalFrame;
+/** 三族的人在环帧(开 / 收 / 撤)。七个帧型全在账本闭集里(下面那条编译期断言)。 */
+export type HitlFrame = QuestionFrame | ElicitationFrame | ApprovalCardLegFrame | ApprovalRevokeFrame;
 /**
  * 一次投递在各只 sink 上的接下与否 —— **只有这一次投递涉及的 sink 才有键**(不在场 / 不在 `onto` 里的没有键)。
  * 也是 {@link HitlTransport.deliver} 的 `onto` 入参形:值为 `true` 的 sink 才写。

package/dist/hitl-delivery.js

@@ -17,8 +17,6 @@ function frameKey(frame) {
             return `elicitation=${frame.elicitationId}`;
         case "approval_request":
         case "approval_complete":
-        case "tool_approval":
-        case "tool_approval_complete":
             return `approval=${frame.approvalId}`;
         case "approval_revoke":
             return `batch=${frame.batchId}`;

package/dist/hooks/hook-llm.js

@@ -1,5 +1,6 @@
 import { admitRouteRequest, applyReasoningToRequest, AUTO_MODE_CLASSIFIER_LOW_REASONING_BUDGET_TOKENS, BrainError, joinRequestUrl, lowestReasoningSeat, mergeReasoningHeaders, resolveRouteCredential, routeKeyOf } from "@sema-agent/core";
-import { matchCatalogModel, refusedCatalogEntry, servedModelTableLeg } from "../model-select.js";
+import { modelRefusalLegOf, matchCatalogModel, refusedCatalogEntry, servedModelTableLeg } from "../model-select.js";
+import { configSourceKind } from "../config-provider.js";
 import { echoModelRef, modelUnavailableMessage } from "../model-entry-refusal.js";
 import { resolveOpenaiRouteEndpoint } from "../model-route-endpoint.js";
 import { anthropicLaneCredentialOf } from "../model-route-gap.js";
@@ -47,6 +48,7 @@ function routeCredentialHeader(credential) {
 }
 export function createHookLlm(deps) {
     const { config, metrics } = deps;
+    const webAdminIsConfigSource = configSourceKind(config) === "remote";
     const anthropicRouteBaseUrl = () => anthropicRouteRoot(config.anthropic ?? {});
     const shapeFrom = (m, providerModelId = m.id) => {
         const catalogRef = m.name;
@@ -55,7 +57,7 @@ export function createHookLlm(deps) {
             case "anthropic":
                 return { ok: true, catalogRef, providerModelId, baseUrl: m.baseUrl || anthropicRouteBaseUrl(), api: "anthropic-messages", model: m };
             case "gateway": {
-                const endpoint = resolveOpenaiRouteEndpoint(catalogRef, m, config.gatewayBaseUrl, servedModelTableLeg(config));
+                const endpoint = resolveOpenaiRouteEndpoint(catalogRef, m, config.gatewayBaseUrl, modelRefusalLegOf(servedModelTableLeg(config), webAdminIsConfigSource));
                 return endpoint.ok ? { ok: true, catalogRef, providerModelId, baseUrl: endpoint.baseUrl, api: "openai-completions", model: m } : unresolvedPick(endpoint.refusal);
             }
         }

package/dist/hooks/hook-runner.d.ts

@@ -37,7 +37,7 @@ export declare const MAX_HOOK_OUTPUT_BYTES: number;
  * 且 4096 的单条帽保证**前两条**钩子的话仍整段进得去(截断是配置广度的代价,不是常态)。
  */
 export declare const MAX_HOOK_CONTEXT_TOTAL_CHARS = 10000;
-/** 契约里**引擎属主**的 `settings.hooks` 事件(契约包的九员字面量元组;壳属主的事件引擎不跑,owner-single)。 */
+/** 契约里**引擎属主**的 `settings.hooks` 事件(契约包的十员字面量元组;壳属主的事件引擎不跑,owner-single)。 */
 export type EngineOwnedHookEvent = (typeof ENGINE_OWNED_HOOK_EVENTS)[number];
 /**
  * 律二 · **事件对位只有一张表,一事件一站**:引擎属主的每个 `settings.hooks` 事件 → 它挂的那一个 `classic.*` 站(同名站)。
@@ -56,6 +56,7 @@ export declare const SETTINGS_HOOK_STATIONS: {
     readonly StopFailure: "classic.StopFailure";
     readonly PreCompact: "classic.PreCompact";
     readonly PostCompact: "classic.PostCompact";
+    readonly PermissionDenied: "classic.PermissionDenied";
 };
 /**
  * **一条车道一张注册**:每张的名字 —— wire 可见(`wiring_manifest.mods[].name`、`allowRuleShadowed[].entries`、问因项 `askReasons[].registration`),
@@ -170,7 +171,7 @@ export type ParseHooksConfigResult = {
  *    升级前被拦的 Bash 升级后放行(安全轴上的回退)。所以这条规则住在 fresh 专用的判据里,与 `taskSettingsKeyIssue` 同姿势
  *    (「fresh 400 / resume 宽容」双层:会砖存量的规则只咬 fresh)。resume 照旧整只采纳,别名那一组继续永不命中(与 7.111.0 逐字同),其余照跑。
  *  · **哪些事件** = 契约 `HOOK_EVENT_MATCHER_FIELD[event] === "tool_name"` ∧ 引擎属主 `HOOK_EVENT_OWNER[event] === "engine"`
- *    (今天恰是上面三个;`PermissionRequest` / `PermissionDenied` 也匹配 `tool_name` 但属壳,壳自己跑,不是本 runner 的读法)。**不手抄事件表**([ref])。
+ *    (今天 = 上面三个 + `PermissionDenied`(settings-schema 26.0.0 起引擎属主,名 = 同一次调用在门上的 wire 名,派生自动带上);`PermissionRequest` 也匹配 `tool_name` 但属壳,壳自己跑,不是本 runner 的读法)。**不手抄事件表**([ref])。
  *  · **哪些名字算别名** = core 静态目录(`describeToolCatalog()`)里某条 `face.aliases` 的成员,且它自己不是另一条目的 wire 名({@link engineToolAliases})。
  *    **只读这一只真源**([ref])。本仓自身不声明带别名的工具;嵌入方经 `resolveSpec` 席挂的别名与 MCP 工具名在受理面看不见(名册是每任务装配的),**不在射程**。
  *  · **正名同在则不拒**:`正名|别名` / `List.*` 会命中正名,不是「静默不命中」,且正是 7.107.0 CHANGELOG 给的「滚动期两名都写」补偿形。

package/dist/hooks/hook-runner.js

@@ -56,6 +56,7 @@ export const SETTINGS_HOOK_STATIONS = {
     StopFailure: "classic.StopFailure",
     PreCompact: "classic.PreCompact",
     PostCompact: "classic.PostCompact",
+    PermissionDenied: "classic.PermissionDenied",
 };
 function chainsBelowTaskOn(patterns, station) {
     return patterns.some((p) => p === station || (p.endsWith(".*") && station.startsWith(p.slice(0, -1))));
@@ -1664,7 +1665,8 @@ function createLaneRegistration(lane, config, ctx, budgetMs) {
     const stopFailureEntries = lit("StopFailure");
     const preCompactEntries = lit("PreCompact");
     const postCompactEntries = lit("PostCompact");
-    if (!pre && !post && !postFailure && !postBatch && !promptSubmit && !stopEntries && !stopFailureEntries && !preCompactEntries && !postCompactEntries) {
+    const permissionDeniedEntries = lit("PermissionDenied");
+    if (!pre && !post && !postFailure && !postBatch && !promptSubmit && !stopEntries && !stopFailureEntries && !preCompactEntries && !postCompactEntries && !permissionDeniedEntries) {
         return undefined;
     }
     const onceSpent = new Set();
@@ -2178,6 +2180,19 @@ function createLaneRegistration(lane, config, ctx, budgetMs) {
             await runObserveOnlyEvent("PostCompact", postCompactEntries, cctx.trigger, payload, ctx, once, halt);
         });
     }
+    if (permissionDeniedEntries) {
+        translators.PermissionDenied = (dctx, halt) => settleOnce(onceSpent, async (once) => {
+            const payload = {
+                ...basePayload(ctx, dctx.permissionMode),
+                hook_event_name: "PermissionDenied",
+                tool_name: dctx.toolName,
+                tool_input: dctx.input,
+                tool_use_id: dctx.toolCallId,
+                reason: clipDataText(dctx.reason, MAX_HOOK_FEEDBACK_CHARS),
+            };
+            await runObserveOnlyEvent("PermissionDenied", permissionDeniedEntries, dctx.toolName, payload, ctx, once, halt);
+        });
+    }
     const events = Object.keys(translators);
     return {
         name: SETTINGS_HOOKS_REGISTRATIONS[lane],

package/dist/host-decision.d.ts

@@ -71,8 +71,8 @@ export type HostDecision = Extract<ResumeOutcome, {
  * ══ 决定体的出处位 `decidedBy`:一只闭集、一只读法、一只映射 ═══════════════════════════════════════════════
  *
  * 规则一句话:**一个审批决定用一只键说是谁做的** —— `decidedBy ∈ {"person","policy"}`,缺席 = `"person"`;读它的只有
- * {@link readDecider}(三条工具审批决定口共读:live `POST /v1/tool-approvals/:id/respond`、耐久 ask 账
- * `POST /v1/tasks/:id/asks/:askId/decision`、耐久 `POST /v1/approvals/:sessionId/decide`),把它交给引擎的只有
+ * {@link readDecider}(两条工具审批决定口共读:决断口
+ * `POST /v1/tasks/:taskId/asks/:askId/decision`、耐久 `POST /v1/approvals/:sessionId/decide`),把它交给引擎的只有
  * {@link liveHostSource}(同步座 `AskOutcome.settledBy`)与 {@link hostDecisionFacts}(停驻座 `hostDecision.decidedBy`)。
  *  · 词与决定动词**正交**:策略可以放行也可以拒(core 7.39.0 起引擎铸 `policy_allowed` / `policy_refused`)。唯一的例外是
  *    引擎自己的那一条 —— 一张要人的卡(`requiresRealApproval`)不归策略答,见 {@link heldAskOf}(判官是 core 的 `policyCannotAnswer`)。
@@ -103,14 +103,14 @@ export declare const DECIDED_BY_NOT_IN_PROOF = "decidedBy is not supported on a
 /** 一张要人的卡上策略的放行(两条决定口同一句;判官 core `policyCannotAnswer`,问形见 {@link heldAskOf})。 */
 export declare const POLICY_CANNOT_ALLOW_PERSON_ASK = "decidedBy \"policy\" cannot allow this ask \u2014 it demands a person's approval (risk.requiresRealApproval), and a policy's answer is not a person's; answer it as a person, or refuse it as the policy";
 /**
- * 退役键 `settledBy`(7.93.3–7.117.x 的「只配 deny」那一位)的拒句。三条决定口共用这一句,出句的铸点是 {@link retiredDecisionKeyFacts}(各口不直接引用本常量)。
- * live `/respond` 的解析不是键闭集的(未知键一律忽略),而这只键不是随便一个未知键:它是调用方在**明确陈述**「这是策略答的」—— 忽略它就是把缺席律(person)
- * 套在一个说了话的体上(旧壳的策略拒记成人拒;一张要人的卡上旧形的放行被读成人的放行,绕过「要人的卡不归策略答」那一判)。所以那条口
- * 在裁决之前响亮拒它,与同一只 parser 里 `scope` 的拒同一条先例;耐久两口本来就在键闭集 / strict 体上拒它,句子改由同一铸点出。
+ * 退役键 `settledBy`(7.93.3–7.117.x 的「只配 deny」那一位)的拒句。决定口共用这一句,出句的铸点是 {@link retiredDecisionKeyFacts}(各口不直接引用本常量)。
+ * 这只键不是随便一个未知键:它是调用方在**明确陈述**「这是策略答的」—— 忽略它就是把缺席律(person)套在一个说了话的体上(旧壳的策略拒记成人拒;
+ * 一张要人的卡上旧形的放行被读成人的放行,绕过「要人的卡不归策略答」那一判)。各口在键闭集 / strict 体上拒它,句子由同一铸点出
+ * (7.151.x 及以前的 live 应答口体不是键闭集的、在裁决之前专门拒它;那条口 7.152.0 起已删)。
  */
 export declare const SETTLED_BY_RETIRED = "settledBy is retired \u2014 send decidedBy: \"person\" | \"policy\" (who made this decision; absent = \"person\"); ignoring it would record a policy's answer as a person's";
 /**
- * 退役键 `settledBy` 的**拒绝事实** —— 三条工具审批决定口(live `POST /v1/tool-approvals/:id/respond`、耐久 ask 账
+ * 退役键 `settledBy` 的**拒绝事实** —— 两条工具审批决定口(决断口
  * `POST /v1/tasks/:taskId/asks/:askId/decision`、`POST /v1/approvals/:sessionId/decide`)对它的拒,**句**与**机读位**同出自这一处:
  *  · `error` = {@link SETTLED_BY_RETIRED}(三口同一句,没有哪一口自说一句 —— 此前耐久 ask 账说 strict 体的通用句、`/decide` 说键闭集句);
  *  · `extra` = `{ field: "settledBy" }`,直接作 `sendError` 的 `extra` / 并进 400 体。`field` 是 400 体上既有的那一把键(`request.field_invalid` 的
@@ -152,7 +152,7 @@ export type DeciderReading = {
  * 决定体决定者两格(`decidedBy` + `decidedVia`)的**唯一读法**。次序即契约:
  *  ① `decidedBy` 缺席 ⇒ `"person"`(缺席律:一条不说话的决定就是一个人按的 —— 与修前逐字同形);
  *  ② 直连门在场且 `decidedBy` 在场 ⇒ `not_in_proof`(不论值:它不在签名载荷里,能改线上字节的一方可以把人翻成策略;
- *     第二参给字面 `false` 的调用点 = 那条口没有决策证明,live `/respond` 即此);
+ *     各调用点交部署的 `directDoorActive`;7.151.x 及以前的 live 应答口没有决策证明、给字面 `false`,那条口 7.152.0 起已删);
  *  ③ `decidedBy` 闭集外(`"sla_timeout"`、结算词、别的串、非串、`null`)⇒ `outside_closed_set`({@link DECIDED_BY_OUTSIDE_CLOSED_SET});
  *  ④ `decidedVia` 在场(`undefined` 之外一律算在场,`null` 也是 —— 与 `decidedBy` 同一条在场口径)而它不在 core `DECIDED_VIA` 里,或旁边的决定者
  *     没有座位(人;含 ① 落成的缺席 person ⇒ 直连门上只带 `decidedVia` 也走这一臂,直连门从不受理它)⇒ `outside_closed_set`({@link DECIDED_VIA_OUTSIDE_SEAT});
@@ -176,11 +176,11 @@ export declare function readDecider(body: {
 export declare function liveHostSource(decider: ApprovalDecider): HostSource | undefined;
 /**
  * 引擎自己的那一条例外:**一张要人的卡不归策略答** —— 判官是 core 的 `policyCannotAnswer(question, decidedBy)`([ref] 包根导出;引擎的续跑入口、
- * 执行带与同步座读同一条)。本仓**只在自己的副作用先于引擎落地的两条口**上于裁决之前问它(live `/respond`:会话放行 / 常驻规则 / 一条按 approve
- * 回放的 DECIDED 行;耐久 ask 账:一条宣称 approve 的 DECIDED 行),并且只问**放行**那一向(与引擎续跑入口同:拒永远答得了)。耐久 `/decide` 不判:
+ * 执行带与同步座读同一条)。本仓**只在自己的副作用先于引擎落地的那一条口**上于裁决之前问它(决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`:
+ * 会话放行 / 常驻规则 / 一条宣称 approve 的 DECIDED 行;7.151.x 及以前的 live 应答口也问,那条口 7.152.0 起已删),并且只问**放行**那一向(与引擎续跑入口同:拒永远答得了)。耐久 `/decide` 不判:
  * 引擎在 CAS 之前就拒(`checkpoint.invalid_outcome`,卡留 pending),本口的副作用全在引擎受理之后 —— 在那里再问一次就是第二个判官。
  *
- * 交给判官的「问」= {@link heldAskOf}:本仓两条口持有的都不是引擎的原物(活卡条目记的是铸条目那一次从 `AskRequest` 读定的那一位;耐久 ask 账行上是
+ * 交给判官的「问」= {@link heldAskOf}:决断口两形持有的都不是引擎的原物(活卡条目记的是铸条目那一次从 `AskRequest` 读定的那一位;ask 账行上是
  * 卡面 `risk.requiresRealApproval`,读不出按要人读),以引擎的问形(core `HeldQuestion` 的 `ask` 决定臂)交过去 —— 「谁答不了」只在引擎那一处判。
  */
 export declare function heldAskOf(demandsAPerson: boolean): Extract<PermissionResult, {

package/dist/http/active-run-conflict.d.ts

@@ -15,6 +15,7 @@
  */
 import { type GovernancePosture } from "../runtime-governance.js";
 import type { ShellGateDoctrine } from "@sema-agent/core";
+import { type ParkedRunStatus } from "../plugins/store-contracts.js";
 import type { RunStore } from "../plugins/store-backend.js";
 import { type PendingRowBinding } from "../plugins/checkpoint-store-face.js";
 /** 与 runs.ts/tasks.ts 三个 409 位共享的旧文案(byte-frozen:api-error-text-freeze 门认这句)。 */
@@ -71,11 +72,43 @@ export interface PendingGateMaterial {
      *  报的是同一行。残余如实记:这一位仍不是**跨 run** 的去重键 —— activeTaskId 换了,门自然也换。 */
     checkpointId?: string;
 }
+/**
+ * 持有者的状态词:run 状态表判为在跑或停驻的词(在跑 `running` ∪ 停驻词 —— 停驻词从表派生,今天 `suspended` / `needs_review`)。
+ * 收场词(完成 / 失败 / 阻断)不在其中:持有者行已收场而认领还在(收尾窗 / 崩溃残留),状态键不写。
+ */
+export type OccupantRunStatus = "running" | ParkedRunStatus;
+/**
+ * **会话占用两键**(wire):`activeTaskId` = 这只会话的单活认领此刻的持有者(认领已放 ⇒ `null`,键恒在);`activeTaskStatus` = 那条 run 行存着的状态,
+ * 在跑 / 停驻才写键({@link OccupantRunStatus})。唯一铸法 = {@link occupantOf};出现面:409 `conflict.session_active_run` 各体(提交 / 续跑 / 删除 / run 外回退)
+ * 与 SSE 冲突 done 帧、会话头探针 `GET /v1/sessions/:id/head` 的 200 体 —— 同一时刻两边的两键逐字相等。
+ */
+export type SessionOccupant = {
+    readonly activeTaskId: string | null;
+    readonly activeTaskStatus?: OccupantRunStatus;
+};
+/**
+ * 🔴 **占用两键的唯一投影**:认领持有者(任一处读到的那一格 —— 写口认领冲突里观察到的、删除围栏判到的、按会话读的认领)→ {@link SessionOccupant}。
+ * 状态 = 持有者那一行(不带属主的一格事实,经属主存取器 `runFactsOf` 读),在跑 / 停驻才写键。没有 run 店 ⇒ 只有持有者。
+ * 读店故障原样抛 —— 失败方向归调用方:提交面的 409 体降级成只带持有者({@link buildActiveRunConflict} 的留痕臂),读面响亮(500,不答一个看似诚实的少键体)。
+ */
+export declare function occupantOf(runStore: Pick<RunStore, "getRun"> | undefined, holder: string | null | undefined): Promise<SessionOccupant>;
+/**
+ * 拒体上的占用两键(409 的失败方向:拒体本身绝不被材料挡住):{@link occupantOf},持有者行读不出 ⇒ 只剩持有者 + F 类留痕(与提交面材料同一只 tag)。
+ * 读者:提交 / 续跑面的铸式({@link buildActiveRunConflict})、删除口与 run 外回退口的 409。
+ */
+export declare function refusalOccupantOf(runStore: Pick<RunStore, "getRun"> | undefined, holder: string | null | undefined): Promise<SessionOccupant>;
+/**
+ * 按会话读的那一读:run 店的单活认领(`getActiveTaskId`,跨副本 = 共享店里的那一格)→ {@link occupantOf}。读者:会话头探针(读面:任一读故障响亮)。
+ * 读的是存着的认领,不落死亡判决:心跳过期而还没被收割 / 观察的持有者照它行上存着的状态答(与「其余按认领判的门不判存活」同一条;
+ * 写口的认领冲突判官先判死它、所以提交不会因它 409)。
+ */
+export declare function readSessionOccupant(runStore: Pick<RunStore, "getActiveTaskId" | "getRun">, sessionId: string): Promise<SessionOccupant>;
 export interface ActiveRunConflictBody {
     error: string;
     errorCode: "conflict.session_active_run";
+    /** 占用两键({@link SessionOccupant},唯一投影 {@link occupantOf})。 */
     activeTaskId: string | null;
-    activeTaskStatus?: string;
+    activeTaskStatus?: OccupantRunStatus;
     /** [ref] S1([ref]):running 形专属的**活性证据**——本副本 ledger sink 最后一次 durable append 距今
      *  的毫秒数(「turn 真在推进」的判别材料;与行 updatedAt 的进程心跳语义刻意分离)。**同副本
      *  best-effort**:缺席 = 无法证明(跨副本/重启后),不是「不活」——诚实缺席,绝不铸 0。消费端
@@ -100,7 +133,7 @@ export interface ActiveRunConflictDoneResult {
     errorCode: "conflict.session_active_run";
     errorMessage: string;
     activeTaskId: string | null;
-    activeTaskStatus?: string;
+    activeTaskStatus?: OccupantRunStatus;
     /** [ref] S1:与 409 body 同键同语义(见 {@link ActiveRunConflictBody.msSinceLastActivity})。 */
     msSinceLastActivity?: number;
     pendingGate?: PendingGateMaterial;