@sema-agent/server 7.147.0 → 7.149.0

package/dist/deployment-shape.d.ts

@@ -6,8 +6,9 @@
  * `DEPLOYMENT_SHAPE_PREDICATES.<行>.holds(config)`,不 import 散落函数;表外不许再长出一只自读部署形事实的布尔判据
  * (反向门 `test/deployment-shape-gate.test.ts` 按语法树判,判据逐字写在那份门的头注里)。
  *
- * ## 两根轴,每根轴一个读口(原始配置键只在这两个函数里被读)
+ * ## 三根轴,每根轴一个读口(原始配置键只在这三个函数里被读)
  *  · `principal` —— 运维的 `REQUIRE_PRINCIPAL` 声明({@link readPrincipalAxis})。
+ *  · `identity` —— 这台部署在**配置**上接了哪几个已验身份来源(唯一读法 `configuredIdentitySources`,`identity-source.ts`)+ 有没有声明只读 trace 凭据({@link readIdentityAxis})。
  *  · `lane` —— `REMOTE_EXEC` 的归一车道词(`executionLaneOf`,认不出 ⇒ `undefined`,行必须 fail-closed)+ 那条车道的能力表行 +
  *    这份部署上执行环境的能力块(唯一作者 `capabilitiesFor`;k8s 的快照店是它的输入)+ 车道子旋钮(k8s 运行时类)({@link readLaneAxis})。
  *
@@ -16,15 +17,16 @@
  * `holds` 的入参型 = 所声明轴读入形的交叉({@link DeploymentShapeInput}),所以调用方递完整 `ServiceConfig` 或只递那几键的窄形都行。
  *
  * ## 什么进表、什么不进
- * 进表的是**形规则**:只由部署形事实决定的布尔(去重后 14 行;同一条规则的多个消费者读同一行,不各成一行)。
+ * 进表的是**形规则**:只由部署形事实决定的布尔(去重后 15 行;同一条规则的多个消费者读同一行,不各成一行)。
  * 把一行与**非形事实**(锁键、合规档位、审批意图、请求身份、请求体)合取的能力判据是**消费者**,住在它自己的模块
  * (`mcpInjectionHonored` = 锁 ∧ 合规 ∧ `!multiTenant`;`taskHooksHonored`;身份门 …),读行、不读原始键。
  * 车道表(`execution-lane-caps.ts`)按车道词键控的布尔列(`laneIsolated` 等)是车道轴自己的事实表,不是「部署」的谓词;行读它们。
  *
- * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts`(它本身是叶),零运行期环(引擎只 type-import)。
+ * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts` 与 `identity-source.ts`(两者本身是叶),零运行期环(引擎只 type-import)。
  */
 import type { ExecutionEnvCapabilities } from "@sema-agent/core";
 import { type ExecutionLane, type ExecutionLaneCaps } from "./execution-lane-caps.js";
+import { type IdentitySource, type IdentitySourceConfig } from "./identity-source.js";
 /** `principal` 轴读的配置键(`ServiceConfig` 结构上满足)。 */
 export interface PrincipalAxisInput {
     readonly requirePrincipal?: boolean | undefined;
@@ -34,6 +36,17 @@ export interface PrincipalAxisFacts {
     /** 运维声明了 `REQUIRE_PRINCIPAL=true`。 */
     readonly declared: boolean;
 }
+/** `identity` 轴读的配置键(`ServiceConfig` 结构上满足):身份来源的配置面 + 只读 trace 凭据。 */
+export interface IdentityAxisInput extends IdentitySourceConfig {
+    readonly traceToken?: string | undefined;
+}
+/** `identity` 轴的事实。 */
+export interface IdentityAxisFacts {
+    /** 配置接了线的已验身份来源(`configuredIdentitySources`,序同 `IDENTITY_SOURCES`)。鉴权桥那一格 = 配置里有 issuer(显式或中心回退)—— 验签器由起服第 9 段按同一个读数建。 */
+    readonly sources: readonly IdentitySource[];
+    /** 声明了只读 trace 凭据(不是身份来源:它不验任何主体,但这台部署因此有一道凭据门)。 */
+    readonly traceTokenDeclared: boolean;
+}
 /** `lane` 轴读的配置键:**已合成**的 `remoteExec` 里本表用得到的那几键(`ServiceConfig` 的判别联合每一臂结构上都满足;车道必在 ——
  *  没有声明的部署在执行车道合成步拒启)。`provider` 收开放串:手搓的部署形 / 外部输入上认不出的词 ⇒ 行在 `lane` 那一格 fail-closed。 */
 export interface LaneAxisInput {
@@ -60,6 +73,10 @@ interface AxisShapes {
         readonly input: PrincipalAxisInput;
         readonly facts: PrincipalAxisFacts;
     };
+    readonly identity: {
+        readonly input: IdentityAxisInput;
+        readonly facts: IdentityAxisFacts;
+    };
     readonly lane: {
         readonly input: LaneAxisInput;
         readonly facts: LaneAxisFacts;
@@ -86,29 +103,47 @@ export interface DeploymentShapePredicate<A extends DeploymentShapeAxis> {
 export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
     /** 身份门的问法。读者:请求面的身份 / 属主门(`http/principal-gate.ts`、`http/request-guards.ts`、`security.ts`)。 */
     principalRequired: DeploymentShapePredicate<"principal">;
+    /**
+     * 「这台部署有没有身份边界」的问法 —— 有 = 请求里有东西替主体作保或拦在门外:声明了 `REQUIRE_PRINCIPAL`,或配置接了任一已验身份来源
+     * (service 凭据 / 鉴权桥 issuer,含中心回退 / 直连门),或声明了只读 trace 凭据。没有 = dev-open:主体头是谁都能自报的(不是认证;报了它的请求仍为那位主体)。
+     * 只读配置(验签器在起服第 9 段按同一个配置读数建 ⇒「验签器在场」≡「配置里有桥」),所以先于验签器的起服段(第 3 段的一次性迁移)与请求面读到同一个答案。
+     * 读者:请求面的 dev-open 判据(`http/principal-gate.ts` 的 `devOpenDeployment`,`actsForDeployment` 的一臂:不报主体的调用方在属主存取器的 fleet 一格与 `/metrics` 族上代部署本人)、
+     * 一次性迁移 M48 的输入(`plugins/store-backend.ts`:有边界 ⇒ 不改写哨兵属主)。
+     */
+    identityBoundary: DeploymentShapePredicate<"principal" | "identity">;
     /**
      * 租户轴的问法。今天与 {@link DEPLOYMENT_SHAPE_PREDICATES.principalRequired} 读**同一个声明**([ref] ①:托管 / 多租 ⇔ `REQUIRE_PRINCIPAL=true`,
      * 签发方配置是身份验签轴、不算租户证据)—— 两个问题、一根轴、一个读口;「鉴权必需」与「多租形」拆成两个声明时只改这一行的判官。
      */
     multiTenant: DeploymentShapePredicate<"principal">;
     /** 读能力表 `callerCwd` 位(host = 单主才开;device = 路径落在发起者自己的设备上,归属由根会话行执行格上的设备绑定验过,不要求单主)。 */
-    callerCwd: DeploymentShapePredicate<"lane" | "principal">;
-    /** 调用方给的宿主绝对路径(附加目录 / 项目上下文 / 本机 SendUserFile / 指令文件探针)只在「手就在本 worker 的盘上 ∧ 单主」时指向调用方自己的东西。 */
-    callerOwnsWorkerDisk: DeploymentShapePredicate<"lane" | "principal">;
+    callerCwd: DeploymentShapePredicate<"principal" | "lane">;
+    /** 调用方给的宿主绝对路径(附加目录 / 项目上下文 / 本机 SendUserFile / 指令文件探针)只在「手就在本 worker 的盘上 ∧ 单主」时指向调用方自己的东西;
+     *  本机语言服务器(`createLspManager`:本机子进程、在 worker 盘上找根)同问这一句,读这一行 × `LSP_HOST_ENABLED`。
+     *  local 店的声明(`local-store-declaration.ts` 的 `localStoreDeclarationOf`)同问这一句:店的数据根就在这块盘上,盘是调用方自己的且易失 ⇒ 部署不替他声明它活过替换。 */
+    callerOwnsWorkerDisk: DeploymentShapePredicate<"principal" | "lane">;
     /** wire `executionLane.toolsOnThisHost` 与出厂 / 中心技能的 `baseDir`:只问文件系统同一性,与租户无关(出厂内容每个租户拿到同一份)。 */
     toolsOnThisHost: DeploymentShapePredicate<"lane">;
     /** 无手形(声明 `none`;判据读执行环境块 `io`,不点名车道词)且单主:进程级消费者(hooks 命令、项目上下文本机读、卡批规则 root)看到的就是引擎自己的进程 cwd / env。 */
-    noHandsSingleUser: DeploymentShapePredicate<"lane" | "principal">;
+    noHandsSingleUser: DeploymentShapePredicate<"principal" | "lane">;
     /** 任务层替部署声明宿主姿态(bypassPermissions 开写面 / host shell 继承整份环境)的射程:device 车道上跨租户宿主穿越结构性不存在(clay 裁定③)。 */
-    taskHostPostureDeclarations: DeploymentShapePredicate<"lane" | "principal">;
+    taskHostPostureDeclarations: DeploymentShapePredicate<"principal" | "lane">;
     /** 写门走代理裁决(执行环境块 `hostLocalPaths` 为假:路径不是本 worker 盘上的文件);认不出的词 ⇒ 走代理(代理 slot 空 ⇒ 写门 fail-closed)。 */
     sandboxPathAdjudication: DeploymentShapePredicate<"lane">;
     /** 读能力表 `sandboxSendUserFile` 位(e2b / k8s 每任务一只沙箱 ⇒ 任何租户;ssh 共享一台真机 ⇒ 只单主)。 */
-    sandboxSendUserFile: DeploymentShapePredicate<"lane" | "principal">;
+    sandboxSendUserFile: DeploymentShapePredicate<"principal" | "lane">;
     /** 读能力表 `remoteScratchpad` 位(`/tmp/scratchpad/<sessionId>` 远端约定)。 */
     remoteScratchpad: DeploymentShapePredicate<"lane">;
+    /**
+     * 读能力表 `backgroundShell` 位 —— 「这条车道的执行环境能不能开后台 shell(`run_in_background` / `BashOutput` / `KillShell`),含把运行中的前台命令领养成后台任务」的**唯一**答者:
+     * e2b / k8s 每任务一只沙箱 ⇒ 任何租户;host(命令落在 worker 宿主上的同一张进程表)⇒ 只单主;其余车道(含 none)没有后台 shell;认不出的车道 ⇒ 否。
+     * 读者(同读这一行,没有第二份判别式):三只声明后台 shell 的适配器的 `backgroundCapabilities`(`supported` 与 `supportsDetach` 是同一个答案)、
+     * host 适配器的装配点(`boot/execution-env.ts` / `run-local.ts` 把行的答案交给适配器的 `backgroundShell`)、能力事实 `autoBackgroundOnTimeout`(`/health.autoBackgroundOnTimeout`)。
+     * 全局关停开关 `HOST_BG_ENABLED` 不在行里 —— 它是旋钮不是部署形,host 适配器与事实在行之上各合取一次。
+     */
+    backgroundShell: DeploymentShapePredicate<"principal" | "lane">;
     /** 读能力表 `tenantSeparation` 位(值来自 settings-schema 车道词表正本);唯一读者 = 跨域不变量 `multi-tenant-shared-lane`。 */
-    laneSeparatesTenants: DeploymentShapePredicate<"lane" | "principal">;
+    laneSeparatesTenants: DeploymentShapePredicate<"principal" | "lane">;
     /**
      * [ref] —— **VM 级**隔离强度(独立内核:e2b 的 Firecracker microVM;k8s 只在 Kata / gVisor 运行时类上)。与执行环境块 `isolation` 键
      * (OS 级边界,容器即算;wire `executionLane.isolated` 的属主 `laneIsolated`)是两个问题,所以不叫「isolated」。读者:A 值路由。
@@ -131,7 +166,7 @@ export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
      *  · `none`:没有执行环境(能力事实先判无手车道,这里照样表态)。
      * 读者:能力事实 `sessionRewindFiles`(能力位与该口的 501 同读这一行)。
      */
-    rewindableWorkspace: DeploymentShapePredicate<"lane" | "principal">;
+    rewindableWorkspace: DeploymentShapePredicate<"principal" | "lane">;
 }>;
 export {};
 //# sourceMappingURL=deployment-shape.d.ts.map

package/dist/deployment-shape.js

@@ -1,7 +1,11 @@
 import { capabilitiesFor, executionLaneCaps, executionLaneOf, handsOnWorkerFilePlane, laneWiresExecutionEnv } from "./execution-lane-caps.js";
+import { configuredIdentitySources } from "./identity-source.js";
 function readPrincipalAxis(deployment) {
     return { declared: deployment.requirePrincipal === true };
 }
+function readIdentityAxis(deployment) {
+    return { sources: configuredIdentitySources(deployment), traceTokenDeclared: Boolean(deployment.traceToken) };
+}
 function readLaneAxis(deployment) {
     const declaration = deployment.remoteExec;
     const lane = executionLaneOf(declaration.provider);
@@ -16,6 +20,8 @@ function readAxis(axis, deployment) {
     switch (axis) {
         case "principal":
             return readPrincipalAxis(deployment);
+        case "identity":
+            return readIdentityAxis(deployment);
         case "lane":
             return readLaneAxis(deployment);
     }
@@ -47,6 +53,7 @@ function capabilityHolds(cap, principal) {
 const VM_ISOLATION_RUNTIME_CLASSES = new Set(["kata", "kata-qemu", "kata-clh", "kata-fc", "gvisor", "runsc"]);
 export const DEPLOYMENT_SHAPE_PREDICATES = Object.freeze({
     principalRequired: createPredicate(["principal"], "身份轴:运维声明了 REQUIRE_PRINCIPAL=true —— 每个调用方都必须带一个验过的主体。", ({ principal }) => principal.declared),
+    identityBoundary: createPredicate(["principal", "identity"], "身份轴:这台部署有身份边界 —— 声明了 REQUIRE_PRINCIPAL,或配置接了任一已验身份来源(service 凭据 / 鉴权桥 / 直连门),或声明了只读 trace 凭据。", ({ principal, identity }) => principal.declared || identity.sources.length > 0 || identity.traceTokenDeclared),
     multiTenant: createPredicate(["principal"], "租户轴:这台部署服务不止一个主人(托管 / 多租;C-R100 ① 由 REQUIRE_PRINCIPAL=true 声明)。", ({ principal }) => principal.declared),
     callerCwd: createPredicate(["lane", "principal"], "车道 × 租户 / 设备归属:调用方送来的 cwd(与 settings.env)被尊重 —— host 车道且单主,或 device 车道。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.callerCwd, principal)),
     callerOwnsWorkerDisk: createPredicate(["lane", "principal"], "车道 × 租户:手就在本 worker 的盘上且部署只有一个主人 —— 这块盘上的路径就是调用方自己的。", ({ lane, principal }) => lane.lane !== undefined && handsOnWorkerFilePlane(lane.lane) && !principal.declared),
@@ -56,6 +63,7 @@ export const DEPLOYMENT_SHAPE_PREDICATES = Object.freeze({
     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"),
+    backgroundShell: createPredicate(["lane", "principal"], "车道 × 租户:本车道的执行环境可以开后台 shell(含领养运行中的前台命令)—— e2b / k8s 任何租户,host 只单主,其余车道没有。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.backgroundShell, principal)),
     laneSeparatesTenants: createPredicate(["lane", "principal"], "车道 × 租户:这条车道在这台部署上不让两个租户的命令落在同一个共享目标上(单主部署恒成立;认不出的车道不成立)。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.tenantSeparation, principal)),
     vmIsolatedHands: createPredicate(["lane"], "车道 / 隔离强度:手跑在 VM 级边界里(独立内核);runc / 共享内核 / 真机 / 认不出 ⇒ 否。", ({ lane }) => {
         if (lane.lane === "e2b")

package/dist/egress-redirect.d.ts

@@ -1,12 +1,30 @@
 /**
- * 本服务**自己**发往配置端点的出站请求(hook 直连模型腿 `hooks/hook-llm.ts`、记忆 embedder `plugins/memory-embedder.ts`)的
- * 重定向律 —— 与 core 7.51.0([ref])一方 brain 的请求同一条:请求以 `redirect: "manual"` 发出,端点回重定向 ⇒ 拒;
- * 不跟、不重试、拒句不点名目标。
+ * 本服务**自己**发出的每一个出站 HTTP 请求的重定向律 —— 与 core 7.51.0([ref])一方 brain 的请求同一条:
+ * 请求以 `redirect: "manual"` 发出,对端回重定向 ⇒ 拒;不跟、不重试,拒句不点名目标。
  *
  * 为什么:请求只去被判过的那个根。传输层(undici)跟随 POST 307 / 308 时把请求体(用户内容 / 记忆正文)原样送到
- * `Location`,跨 origin 只剥 `authorization` —— anthropic 形的 `x-api-key` 随行(`test/hook-llm.test.ts` 的 G1 格在
- * 7.128.x 上实测送达重定向目标)。判据与拒句与 core 的 brain 请求门同形(`opaqueredirect` 或 3xx)。
+ * `Location`,跨 origin 只剥 `authorization` —— 自定义凭据头(`x-api-key` / `X-Subscription-Token` / OTLP 的 `headers` / S3 预签名的 query)
+ * 随行,同 origin 的跟随连 `authorization` 一起带走(`test/hook-llm.test.ts` 的 G1 格在 7.128.x 上实测送达重定向目标)。
+ *
+ * **一只出口**:{@link createEgressFetch} 是本仓里全局 `fetch` 的**唯一**值引用(`test/egress-redirect-surfaces.test.ts` 的语法树门:
+ * 全树零第二处全局 `fetch`、`redirect` 选项只写这里一处、`createEgressFetch(` 调用点闭集登记 —— 新加出站面必登)。
+ * 每个出站面各自造一只带「出路」句的出口,请求只经它发出;注入的 `fetchImpl`(测试座 / 嵌入方)同样被它包住 ——
+ * 注入不是绕过判据的门。判据 {@link egressRedirectRefusal} 不导出:没有「自己设 `redirect: manual` 再自己判」的第二种写法。
+ *
+ * 响亮:对端回重定向 ⇒ 抛 {@link EgressRedirectRefusedError}(带对端回的码),拒句前面由各面的失败臂冠上自己的面名。
+ * 各面既有的失败臂(日志 / 失败码 / 终态)照旧收它 —— 没有哪一面把它吞成「没拿到结果」而不留话。
+ */
+/** 对端回了重定向、本服务按律不跟:`status` 是对端回的码(0 = `opaqueredirect`)。`message` = 拒句,不回显 `Location` / 凭据 / 请求体。 */
+export declare class EgressRedirectRefusedError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/**
+ * 造一只出站 `fetch`:`redirect: "manual"` 强制(调用方传的 `redirect` 不作数),回重定向 ⇒ 抛 {@link EgressRedirectRefusedError}。
+ *
+ *  · `fix` = 出路一句(「把最终地址写进哪一席」),由各面按自己打的那一席给;拼进拒句。
+ *  · `fetchImpl` 缺席 ⇒ 调用时现取全局 `fetch`(不在造出口时捕获:测试对全局 `fetch` 的替换在造出口之后也生效);在场 ⇒ 用它,同样被判。
+ *  · 其余答复(2xx / 4xx / 5xx / 304)原样交回,各面自己的失败臂照旧。
  */
-/** 端点回的是重定向 ⇒ 拒句(调用方在前面冠上自己的面名);否则 `undefined`。命中时丢弃响应体(不读、不留连接)。 */
-export declare function egressRedirectRefusal(res: Response, fix: string): string | undefined;
+export declare function createEgressFetch(fix: string, fetchImpl?: typeof fetch): typeof fetch;
 //# sourceMappingURL=egress-redirect.d.ts.map

package/dist/egress-redirect.js

@@ -1,7 +1,25 @@
-export function egressRedirectRefusal(res, fix) {
-    if (res.type !== "opaqueredirect" && !(res.status >= 300 && res.status < 400))
+export class EgressRedirectRefusedError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "EgressRedirectRefusedError";
+        this.status = status;
+    }
+}
+const NOT_MODIFIED = 304;
+function egressRedirectRefusal(res, fix) {
+    if (res.type !== "opaqueredirect" && !(res.status >= 300 && res.status < 400 && res.status !== NOT_MODIFIED))
         return undefined;
     void res.body?.cancel().catch(() => undefined);
     return `endpoint answered with a redirect${res.status > 0 ? ` (HTTP ${res.status})` : ""}; it was not followed and no credential was sent anywhere else — ${fix}`;
 }
+export function createEgressFetch(fix, fetchImpl) {
+    return async (input, init) => {
+        const res = await (fetchImpl ?? fetch)(input, { ...init, redirect: "manual" });
+        const refusal = egressRedirectRefusal(res, fix);
+        if (refusal !== undefined)
+            throw new EgressRedirectRefusedError(res.status, refusal);
+        return res;
+    };
+}
 //# sourceMappingURL=egress-redirect.js.map

package/dist/elicitation.d.ts

@@ -1,4 +1,5 @@
 import { type McpElicitRequest, type McpElicitResponse } from "@sema-agent/core";
+import { type HitlTransport } from "./hitl-delivery.js";
 /** A live elicitation frame delivered to whoever is tailing this run's stream. `type` IS the SSE event name
  *  (mirrors the named-event convention: the payload also carries `type` so a proxy that strips event names still
  *  works). The shell renders the `elicitation` frame as a dialog and dismisses on `elicitation_complete`. */
@@ -27,13 +28,13 @@ export interface ElicitationFrame {
     /** "elicitation" only: `serverNowMs + expiresInMs` — the absolute deadline on the server's clock. */
     expiresAtMs?: number;
 }
-/** The per-run context `onElicit` recovers via ALS. `emit` delivers a frame to the run's live stream;
- *  `abortSignal` (the run's own cancel signal) lets a run-abort promptly cancel an elicitation parked awaiting a
- *  human, since the MCP per-request signal may not be chained to the run abort. */
+/** The per-run context `onElicit` recovers via ALS. `transport` = the leg's ONE HITL transport (shared with the question and
+ *  approval contexts of the same leg); `abortSignal` (the run's own cancel signal) lets a run-abort promptly cancel an
+ *  elicitation parked awaiting a human, since the MCP per-request signal may not be chained to the run abort. */
 export interface ElicitationRunContext {
     taskId: string;
     owner: string | null;
-    emit: (frame: ElicitationFrame) => void | Promise<void>;
+    transport: HitlTransport<ElicitationFrame>;
     abortSignal?: AbortSignal;
 }
 export interface ElicitationThrottle {
@@ -81,7 +82,7 @@ export declare class ElicitationCoordinator {
     elicit: (req: McpElicitRequest, signal?: AbortSignal) => Promise<McpElicitResponse>;
     /** `POST /v1/elicitations/:id/respond` — resolve a parked elicitation with the shell's answer. Owner-gated with a
      *  404 (no existence oracle): a non-owner AND an unknown id (answered / expired / wrong replica) both get 404.
-     *  Returns the HTTP {status, body}; the HTTP layer owns auth (gatedPrincipal + REQUIRE_PRINCIPAL) before calling. */
+     *  Returns the HTTP {status, body}; the HTTP layer owns auth (gatedSubject + REQUIRE_PRINCIPAL) before calling. */
     respond(id: string, principal: string | undefined, body: unknown): {
         status: number;
         body: unknown;

package/dist/elicitation.js

@@ -3,6 +3,8 @@ import { uuidv7, delimitUntrusted } from "@sema-agent/core";
 import { redactSecrets, redactDeep } from "./trace/redact.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { refusalBody } from "./http/refusal-body.js";
+import { keyAdmits, ownerCellOf, recoveredSubject } from "./owner-faces.js";
+import { createHitlOpenRace } from "./hitl-delivery.js";
 const MAX_ELICIT_MESSAGE_CHARS = 4096;
 const MAX_ELICIT_SCHEMA_BYTES = 8192;
 const RELEASE_ACTION = { refused: "decline", unanswered: "cancel" };
@@ -114,34 +116,33 @@ export class ElicitationCoordinator {
         signal?.addEventListener("abort", onAbort, { once: true });
         ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
         this.pending.set(id, { settle, owner: ctx.owner, taskId: ctx.taskId });
-        const emitted = (async () => {
-            const now = this.now();
-            return ctx.emit({ type: "elicitation", elicitationId: id, mcpServerName: req.server, message, ...(requestedSchema !== undefined ? { requestedSchema } : {}), mode: "form", serverNowMs: now, expiresInMs: this.throttle.ttlMs, expiresAtMs: now + this.throttle.ttlMs });
-        })().then(() => "ok", () => "failed");
-        const delivery = await Promise.race([emitted, answerP.then(() => "stalled")]);
-        if (delivery === "ok") {
+        const now = this.now();
+        const race = createHitlOpenRace({
+            targets: [{ transport: ctx.transport, frame: { type: "elicitation", elicitationId: id, mcpServerName: req.server, message, ...(requestedSchema !== undefined ? { requestedSchema } : {}), mode: "form", serverNowMs: now, expiresInMs: this.throttle.ttlMs, expiresAtMs: now + this.throttle.ttlMs } }],
+            settled: answerP,
+        });
+        const charge = () => {
             rc.total += 1;
             rc.lastByServer.set(req.server, t);
+        };
+        const phase = await race.phase;
+        if (phase === "delivered") {
+            charge();
         }
-        else if (delivery === "failed") {
+        else if (phase === "undelivered") {
             recordFailOpen("server.elicitation.open-frame-undelivered", `elicitation=${id} server=${req.server}`);
             settle({ action: RELEASE_ACTION.unanswered });
         }
-        const answer = await answerP;
-        void emitted
-            .then((result) => {
-            if (result === "failed") {
-                if (delivery === "stalled")
+        else {
+            void race.landing.then((late) => {
+                if (late === "delivered")
+                    charge();
+                else
                     recordFailOpen("server.elicitation.open-frame-undelivered", `elicitation=${id} server=${req.server}`);
-                return undefined;
-            }
-            if (delivery === "stalled") {
-                rc.total += 1;
-                rc.lastByServer.set(req.server, t);
-            }
-            return ctx.emit({ type: "elicitation_complete", elicitationId: id, mcpServerName: req.server, action: answer.action, serverNowMs: this.now() });
-        })
-            .catch(() => recordFailOpen("server.elicitation.complete-breadcrumb-dropped", `elicitation=${id}`));
+            });
+        }
+        const answer = await answerP;
+        race.close({ type: "elicitation_complete", elicitationId: id, mcpServerName: req.server, action: answer.action, serverNowMs: this.now() });
         return answer;
     };
     respond(id, principal, body) {
@@ -149,7 +150,7 @@ export class ElicitationCoordinator {
         if (!parsed.ok)
             return { status: 400, body: refusalBody({ errorCode: "request.body_shape", message: parsed.error }) };
         const entry = this.pending.get(id);
-        if (!entry || (entry.owner !== null && entry.owner !== principal)) {
+        if (!entry || !keyAdmits("ask.answer", { subject: recoveredSubject(principal), operator: false }, ownerCellOf(entry.owner))) {
             return { status: 404, body: refusalBody({ errorCode: "elicitation.not_pending", message: "no pending elicitation for this id (answered, expired, or not on this replica)" }) };
         }
         entry.settle(parsed.value);

package/dist/engine-identity.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 🔴 **引擎交界的身份**(唯一一处;叶子):一只主体的三格(`owner-brands.ts` 的 `partsOf`)怎么落进引擎 `TaskSpec` 的身份格。
+ *
+ * 二元形:`principal` = **人**(引擎的成文契约「终端用户 / MCP RBAC / 治理键」:用量窗扣账、出站 MCP / A2A 身份、事件归因、检查点的 `principal` 格都按人,
+ * 与本仓的人面汇点同轴);`isolationScope` = **带场景的主体**(只在请求带了场景时有;引擎按它分登记域 / offload 租界 / 后台登记 / peer 目录 / 工作流 scope,
+ * 引擎的读法是「隔离格缺席 ⇒ 读 `principal`」)。没带场景的请求只有 `principal`,与今天逐字节同。检查点的分区走本仓自己供的 `scope` 格。
+ *
+ * 今天的引擎还没有隔离格:{@link taskSpecIdentityOf} 是**唯一的落点**,今天只写 `principal`;隔离格到货后改那一行(钉在 `test/scenario-subject.test.ts`)。
+ * 落点之前引擎自己按 `spec.principal` 分的那几面按人分(同一个人的各场景在那几面互见)—— 本仓镜像这几面的读口(工作流读面、后台登记簿的停止标记、
+ * leader 子任务的 spec)同读 {@link taskSpecIdentityOf},读到的就是引擎写下的那一个值,不各写一份。
+ */
+import type { Person, Subject, SubjectParts } from "./owner-brands.js";
+/** 引擎交界的身份(本仓的类型;二元)。 */
+export interface EngineIdentity {
+    readonly principal: Person | undefined;
+    /** 带场景的主体;没带场景 ⇒ 缺席(引擎读 `principal`)。 */
+    readonly isolationScope?: Subject;
+}
+/** 一只主体(没有 ⇒ 匿名)在引擎交界上的身份。 */
+export declare function specIdentityOf(parts: SubjectParts | undefined): EngineIdentity;
+/**
+ * 落进 `TaskSpec` 的身份格(**唯一落点**)。今天的引擎没有隔离格 ⇒ 只写 `principal`,`isolationScope` 在这里不落(引擎按人分它自己的那几面);
+ * 引擎的隔离格到货 ⇒ 这里加一格,别处不动。
+ */
+export declare function taskSpecIdentityOf(parts: SubjectParts | undefined): {
+    readonly principal?: string;
+};
+//# sourceMappingURL=engine-identity.d.ts.map

package/dist/engine-identity.js

@@ -0,0 +1,10 @@
+export function specIdentityOf(parts) {
+    if (parts === undefined)
+        return { principal: undefined };
+    return parts.scenario === undefined ? { principal: parts.person } : { principal: parts.person, isolationScope: parts.subject };
+}
+export function taskSpecIdentityOf(parts) {
+    const { principal } = specIdentityOf(parts);
+    return principal === undefined ? {} : { principal };
+}
+//# sourceMappingURL=engine-identity.js.map

package/dist/entry-problems.d.ts

@@ -18,14 +18,12 @@ export interface EntryProblem {
 }
 /** 铸一条问题:`entry` 收**原串**,这里过脱敏(调用方没有「忘了脱敏」的可能)。 */
 export declare function entryProblem(code: string, field: string, rawEntry: string, reason: string): EntryProblem;
-/** 拒体上的机读位(原样进 `HttpError.extra` / `refusalBody` 的 `facts`:顶层 `field` + 对象形 `detail`)。 */
-export interface EntryProblemsFacts {
+/** 拒体上的机读位(原样摊在拒体根上:`HttpError.extra` / `refusalBody` 的 `facts`)。型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用。 */
+export type EntryProblemsFacts = {
     readonly field: string;
-    readonly detail: {
-        readonly problems: readonly EntryProblem[];
-        readonly total: number;
-    };
-}
+    readonly problems: readonly EntryProblem[];
+    readonly total: number;
+};
 /**
  * 一遍判下来的全部问题 ⇒ 拒体的机读位。**不能空**:没有问题就没有拒(调用方只在命中时调),空表是调用点的错,响亮抛。
  * 顶层 `field` = 第一条问题的坐标(句子点名的那一张清单)。

package/dist/entry-problems.js

@@ -9,6 +9,6 @@ export function entryProblemsFacts(found) {
     const first = found[0];
     if (first === undefined)
         throw new Error("entryProblemsFacts: a refusal needs at least one problem");
-    return { field: first.field, detail: { problems: found.length > MAX_ENTRY_PROBLEMS ? found.slice(0, MAX_ENTRY_PROBLEMS) : found, total: found.length } };
+    return { field: first.field, problems: found.length > MAX_ENTRY_PROBLEMS ? found.slice(0, MAX_ENTRY_PROBLEMS) : found, total: found.length };
 }
 //# sourceMappingURL=entry-problems.js.map

package/dist/env-facts.js

@@ -1,3 +1,4 @@
+import { writeLogText } from "./observability/logger.js";
 import { isAbsolute, join, resolve, sep } from "node:path";
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { ensureDir } from "@sema-agent/core";
@@ -147,7 +148,7 @@ export async function purgeScratchpadDir(localDataRoot, sessionId) {
         await rm(dir, { recursive: true, force: true });
     }
     catch (err) {
-        console.warn(`scratchpad_purge_failed dir=${dir}: ${err instanceof Error ? err.message : String(err)}`);
+        writeLogText("stderr", `scratchpad_purge_failed dir=${dir}: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 export async function sweepStaleScratchpads(localDataRoot, opts) {

package/dist/env-name-allowlist-knobs.d.ts

@@ -6,14 +6,15 @@
  *  · `example` 进拒句;
  *  · `multiTenant` = `REQUIRE_PRINCIPAL=true` 下名单作不作数 —— **只有服务进程读的旋钮有这一列**(姿态是服务进程的概念):
  *    - `LSP_ENV_ALLOW` ⇒ ignored:host 腿语言服务器在多租户姿态下本来就不起,名单无处作数,设了要说出来([ref])。
+ *    - `HOOK_ENV_ALLOW` ⇒ ignored:请求的 `settings.hooks` 在多租户姿态下整只不跑(`task-settings.ts` `taskHooksHonored`,同一只部署形谓词),名单无处作数。
  *    - 三只沙箱名单(e2b / local-docker / k8s 各一只) ⇒ honored:[ref] 照录修前语义(任何姿态下都转发),[ref] 主会话裁定维持 —— 沙箱 env 是部署方为隔离沙箱显式配的
  *      带外凭据(e2b / docker / k8s 车道本来就是多租户 fleet 的主形),与 LSP 那条「本机子进程」的形不同;多租户下起服说一句。
  *  · `BAKE_ENV_ALLOW`([ref] 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
- *    不进 {@link describeAllowlistPostures} 的姿态句)。它与服务侧四只旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
- *  · `channel` = 这张名单**交给谁、在谁的减法之上**(闭集两词)。它只定拒句里「交到哪里」那半句与出路的主语,**不定拒不拒**:「不许点哪些名」对五只一律
+ *    不进 {@link describeAllowlistPostures} 的姿态句)。它与服务侧五只旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
+ *  · `channel` = 这张名单**交给谁、在谁的减法之上**(闭集两词)。它只定拒句里「交到哪里」那半句与出路的主语,**不定拒不拒**:「不许点哪些名」对六只一律
  *    = 名单型旋钮名 ∪ 本服务自有凭据名(引擎此刻的声明:起服解析时判一次,声明增长时由换代声明对活配置里每只服务侧名单此刻交出去的名重判一次;判官 = 引擎
  *    `inheritEnvPolicyProblem`,与引擎拒嵌入方白名单同句),规则全文在解析器头注 ②。
- *    - `host-put-back`(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)—— 剥后放回形:宿主子进程的 env 先经唯一组合(引擎扣掉本服务自有凭据 + 形状剥),
+ *    - `host-put-back`(`LSP_ENV_ALLOW` / `HOOK_ENV_ALLOW` / `BAKE_ENV_ALLOW`)—— 剥后放回形:宿主子进程的 env 先经唯一组合(引擎扣掉本服务自有凭据 + 形状剥 / 严格名单),
  *      名单点到的键再从本进程环境**原样**取回叠上去;点到本服务自有凭据名 = 把引擎刚扣下的那枚交回那只子进程。
  *    - `sandbox-grant`(三只沙箱名单)—— 沙箱 env 的唯一来源(沙箱不从本进程继承任何东西),部署方显式交出的带外凭据([ref] 照转发);
  *      点到本服务自有凭据名 = 把它装进模型读得到的沙箱 env。沙箱要凭据 ⇒ 部署方给沙箱另铸一把(名与值都不同于本服务的任何凭据)。
@@ -25,7 +26,7 @@
  * 当场撒谎。为什么是纯叶:`config-catalog.ts` 被 `config.ts` 值引,表留在 `config.ts` 会成装载环。
  */
 /** 服务进程(`config.ts` `loadConfig`)读的名单型旋钮 —— 有多租户姿态。 */
-export type ServerEnvNameAllowlistKnob = "LSP_ENV_ALLOW" | "E2B_SANDBOX_ENV" | "DOCKER_SANDBOX_ENV" | "K8S_SANDBOX_ENV";
+export type ServerEnvNameAllowlistKnob = "LSP_ENV_ALLOW" | "HOOK_ENV_ALLOW" | "E2B_SANDBOX_ENV" | "DOCKER_SANDBOX_ENV" | "K8S_SANDBOX_ENV";
 /** bake-runner 进程(`bake-runner/main.ts` `loadEnv`)读的名单型旋钮 —— 构建宿主守护进程没有主体 / 租户,没有姿态。 */
 export type RunnerEnvNameAllowlistKnob = "BAKE_ENV_ALLOW";
 export type EnvNameAllowlistKnob = ServerEnvNameAllowlistKnob | RunnerEnvNameAllowlistKnob;
@@ -52,7 +53,7 @@ export type EnvNameAllowlistKnobTable = {
     readonly [K in EnvNameAllowlistKnob]: K extends ServerEnvNameAllowlistKnob ? ServerEnvNameAllowlistKnobRow : RunnerEnvNameAllowlistKnobRow;
 };
 export declare const ENV_NAME_ALLOWLIST_KNOBS: EnvNameAllowlistKnobTable;
-/** 名单型旋钮的全部名字(五只;表键派生)—— 两处用:解析器的「点名名单型旋钮 = 形错」、剥除的「名单原文按凭据类」臂。 */
+/** 名单型旋钮的全部名字(六只;表键派生)—— 两处用:解析器的「点名名单型旋钮 = 形错」、剥除的「名单原文按凭据类」臂。 */
 export declare const ENV_NAME_ALLOWLIST_KNOB_NAMES: ReadonlySet<string>;
 /**
  * 多租户姿态句 —— **由表派生**,不许在别处手写。形:`under REQUIRE_PRINCIPAL=true: <旋钮> is ignored; <旋钮> / <旋钮> are forwarded as configured`

package/dist/env-name-allowlist-knobs.js

@@ -4,6 +4,11 @@ export const ENV_NAME_ALLOWLIST_KNOBS = {
         channel: "host-put-back",
         multiTenant: { kind: "ignored", why: "the host-lane language server is not started in this posture, and the language-server env keeps the full secret strip" },
     },
+    HOOK_ENV_ALLOW: {
+        example: "HOOK_ENV_ALLOW=HOOK_TOKEN,WEBHOOK_SIGNING_KEY",
+        channel: "host-put-back",
+        multiTenant: { kind: "ignored", why: "request settings hooks are not run in this posture, so no hook environment reads the list" },
+    },
     E2B_SANDBOX_ENV: { example: "E2B_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", channel: "sandbox-grant", multiTenant: { kind: "honored" } },
     DOCKER_SANDBOX_ENV: { example: "DOCKER_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", channel: "sandbox-grant", multiTenant: { kind: "honored" } },
     K8S_SANDBOX_ENV: { example: "K8S_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", channel: "sandbox-grant", multiTenant: { kind: "honored" } },

package/dist/env-witness.d.ts

@@ -0,0 +1,7 @@
+/** 出口座登记「这条 run 的环境一旦留下持久物就告诉我」;交回注销口(只注销自己登记的那一只)。 */
+export declare function listenEnvWitness(runId: string, onWitness: () => void): () => void;
+/** 环境留下了按会话键的持久物(run id 缺席 = 子 run / 服务自起的 run,不属任何提交 ⇒ 无事)。 */
+export declare function witnessEnv(runId: string | undefined): void;
+/** 在听的座数(测试读:收场后归零 = 不积累)。 */
+export declare function envWitnessListeners(): number;
+//# sourceMappingURL=env-witness.d.ts.map

package/dist/env-witness.js

@@ -0,0 +1,16 @@
+const listening = new Map();
+export function listenEnvWitness(runId, onWitness) {
+    listening.set(runId, onWitness);
+    return () => {
+        if (listening.get(runId) === onWitness)
+            listening.delete(runId);
+    };
+}
+export function witnessEnv(runId) {
+    if (runId !== undefined)
+        listening.get(runId)?.();
+}
+export function envWitnessListeners() {
+    return listening.size;
+}
+//# sourceMappingURL=env-witness.js.map

package/dist/execution-lane-caps.d.ts

@@ -3,7 +3,7 @@ import { type ExecutionLane as DeclarableLane, type ExecutionLaneRow } from "@se
 import type { ServiceConfigFlat } from "./config-types.js";
 import { type LaneHomeConfig } from "./lane-home-probe.js";
 /** 一位能力的三态。`single-user-only` = 车道支持,但只在单用户部署(`requirePrincipal !== true`)开 ——
- *  多租户下这一位必须关(host 家族的 cwd/scheduler/backgroundShell/LSP 都是这一档,理由同源:
+ *  多租户下这一位必须关(host 家族的 cwd/scheduler/backgroundShell 都是这一档,理由同源 —— 本机语言服务器同理由,答者是部署形行 `callerOwnsWorkerDisk`:
  *  一个租户的输入不许把 agent 指向 worker 宿主上另一个租户/运维的文件与进程)。 */
 export type LaneCapability = "supported" | "unsupported" | "single-user-only";
 /** 闭集:执行车道全集 = settings-schema 词表正本的可声明车道(**派生**,本仓零手抄;`REMOTE_EXEC` 能写下去的词就是这些)。
@@ -16,15 +16,12 @@ export type ExecutionLane = DeclarableLane;
 export interface ExecutionLaneCaps {
     /** 调用方送来的 `cwd` 是否被尊重。读者:部署形表行 `callerCwd`(本位即判据;改前对账 `task-cwd.ts` 的 `cwdHonored || deviceCwdHonored`)。 */
     readonly callerCwd: LaneCapability;
-    /** core 的后台 shell 面(`run_in_background`/`BashOutput`/`KillShell`)。判别式:各 adapter 的
-     *  `backgroundCapabilities.supported`(`plugins/remote-env-{host,e2b,k8s}.ts`);host 腿的闸在
-     *  `boot/execution-env.ts` 的 `hostCfg.backgroundShell`。 */
+    /** core 的后台 shell 面(`run_in_background`/`BashOutput`/`KillShell`),含把运行中的前台命令领养成后台任务(`supportsDetach`)。读者:部署形表行 `backgroundShell`(本位即判据);
+     *  三只适配器的 `backgroundCapabilities`(`supported` 与 `supportsDetach` 同一个答案)、host 适配器的装配点与事实 `autoBackgroundOnTimeout` 同读这一行,没有第二份判别式。 */
     readonly backgroundShell: LaneCapability;
     /** 自唤醒 scheduler(`CronCreate`/…)。判别式:`boot/execution-env.ts` host 臂的 `hostScheduler`
      *  与 `http/routes/capabilities.ts` 的 `scheduler` 位(两处同判据)。 */
     readonly scheduler: LaneCapability;
-    /** LSP。判别式:`boot/execution-env.ts` 的 `lspManager` 两臂(沙箱桥 e2b/k8s;host 本地 NodeLspManager)。 */
-    readonly lsp: LaneCapability;
     /** SendUserFile 的**沙箱直传腿**(host 的本机 fs 源是另一条腿,不是本位)。
      *  读者:部署形表行 `sandboxSendUserFile`(本位即判据;判定依据在 `capabilities/sandbox-file-send.ts` 头注)。 */
     readonly sandboxSendUserFile: LaneCapability;
@@ -58,8 +55,8 @@ export interface ExecutionLaneCaps {
  *    绑定验证),故不要求单用户。(部署形表行 `callerCwd` 直接读本位。)
  *  · `remoteScratchpad: supported` —— executor 平台闭集 = darwin|linux,`/tmp/scratchpad/<sessionId>`
  *    的惰性 mkdir 约定原样适用;不加词则 scratchpad envFact 对模型整块缺席。
- *  · scheduler / backgroundShell / lsp / sandboxSendUserFile / worktreeIsolation = v1 **诚实关闭**
- *    (不是遗漏:设备侧长驻进程、LSP sidecar、直传腿都是 follow-on,声明了就是谎)。
+ *  · scheduler / backgroundShell / sandboxSendUserFile / worktreeIsolation = v1 **诚实关闭**
+ *    (不是遗漏:设备侧长驻进程、直传腿都是 follow-on,声明了就是谎)。
  */
 export declare function executionLaneCaps(lane: ExecutionLane): ExecutionLaneCaps;
 /** 读地板旋钮的 env 名(拒起句与起服行点名它)。 */
@@ -186,22 +183,11 @@ export declare function deployedExecutionLanes(config: Pick<ServiceConfigFlat, "
  *
  * 读者问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
  *  ① 部署形表行 `toolsOnThisHost`(`deployment-shape.ts`)—— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
- *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针;
+ *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针、
+ *     本机语言服务器(`createLspManager`;这类车道的适配器必须绑得住读 `openBound`,对拍钉 `test/host-env-open-bound.test.ts`);
  *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生(它手里已有车道词,直接读本列)。
  */
 export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
-/**
- * core 7.50.0 —— 「这条车道的执行环境能不能把一次读**绑到判过的那只对象**上」(`FileSystem.openBound`:开着并持有,叶链接不跟,
- * 开后身份对拍)。LSP 会话的读口与路径附件只经它读;环境不实现 ⇒ 那两个读口在这条车道上一律拒。
- *
- * **一条律**:LSP 只在本谓词为真的车道挂(`boot/execution-env.ts` 的 LSP 管理器两臂都合取它;表的 `lsp` 位与之同向,
- * 对拍钉 `test/host-env-open-bound.test.ts`:本谓词 ⟺ 适配器类原型上有 `openBound`)。
- *  · `host` —— `RemoteHostExecutionEnv.openBound` 委托 core `NodeExecutionEnv` 的实现(唯一属主),真;
- *  · `none` —— 没有手(执行环境两座都不给),无物可绑;
- *  · 其余车道(沙箱 / 远端 shell / 设备)—— 读走 exec / sftp / 设备协议,本版不实现绑定读,假。实现之日翻这一格,LSP 沙箱桥随之回来。
- * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
- */
-export declare function laneBindsReads(lane: ExecutionLane): boolean;
 /**
  * 「这条车道的执行环境**自己读得出家目录**」—— 读得出 ⇒ 读数是真源:适配器持一只 `LaneHomeSeat`(取值律与座的唯一属主 = `lane-home-probe.ts`),
  * 部署给的主张({@link buildLaneHomeClaim})在每只环境开起来时被证,不一致 ⇒ 那只环境不开;没有主张 ⇒ 读数填 `ExecutionEnv.homeDir` 的座。
@@ -343,11 +329,27 @@ export declare function buildLaneHomeBootNote(deployment: LaneHomeDeployment): {
     readonly event: string;
     readonly note: string;
 } | undefined;
+/**
+ * 读拒表的字节地板不守时一条 run 的**两种结局**(闭集):`ran` = 部署没要求地板,run 照跑(引擎每 run 一条 `config.read_deny_floor_unkept` 通告);
+ * `refused` = 部署要求地板(`READ_DENY_FLOOR_REQUIRED=true`),run 在准备期拒(同码失败终局,同步提交 409)。判官只有引擎一只(`judgeReadFloorKept`),
+ * 结局由旋钮分开 —— 本仓只说话。
+ */
+export type ReadDenyFloorOutcome = "ran" | "refused";
+/**
+ * **读拒字节地板不守的那一句** —— 本仓说这件事的**唯一**组句器(纯字符串 ⇒ `build*`):点名执行环境(`REMOTE_EXEC=<车道>`,运维写的那一格)、
+ * 「不守读拒字节地板」与出路 `READ_DENY_FLOOR_REQUIRED`。读它的面(一个事实一句话,不另写第二句):
+ *  · `ran` —— run 事件流的 `engine_notice` 帧、运维 `engine_notice` 日志行与终局结果的 `readDenyFloor.message`(`read-deny-floor-notice.ts` 的呈现器);
+ *  · `refused` —— 失败终局的句子(同步提交 409 的 `error`、run 行 `error`、`done` 帧 `terminal.message`,`terminal.ts` 的两只出口属主)与起服那一行
+ *    `read_deny_floor_required_unkept` 的 `note`({@link buildReadDenyFloorUnkeptNote})。
+ * 句子不带行数(行数在通告的 `detail.rowCount`):同一条部署上同一种结局逐字同一句,运维能把起服行、409 与日志对上。
+ * 车道名以旋钮形 `REMOTE_EXEC=<词>` 出现 —— 那是调用方 / 运维写得出、查得到的名字,不是本仓对执行车道的自称。
+ */
+export declare function buildReadDenyFloorSentence(lane: string, outcome: ReadDenyFloorOutcome): string;
 /**
  * 「部署要求读拒表的字节地板(`READ_DENY_FLOOR_REQUIRED=true`),而本部署车道的执行环境块不守地板」时起服那一行的 `note`(纯字符串 ⇒ `build*`);否则 `undefined`。
  * 判据只读部署的要求与 {@link capabilitiesFor} 的 `keepsReadFloor`(认不出的车道答不出块 ⇒ 按不守说,不静默)。`none` 的桩块守地板 ⇒ 不出。
- * 句子点名车道与键:这条车道上每个读拒表有行的 run(出厂读拒档在岗时就有行)都在准备期拒,一个命令都不起 —— 起服先把后果与两条出路说出来,
- * 不让运维从第一条 409 才知道。
+ * 句子 = 这条车道上每条被拒的 run 的拒句({@link buildReadDenyFloorSentence} 的 `refused`,一字不差):起服先把后果与两条出路说出来,
+ * 运维不必从第一条 409 才知道,且起服行与 409 是同一句。
  */
 export declare function buildReadDenyFloorUnkeptNote(deployment: CapabilitiesDeployment & {
     readonly readDenyFloorRequired: boolean;