@sema-agent/server 7.131.0 → 7.133.0

package/dist/entry-problems.d.ts

@@ -0,0 +1,34 @@
+/** `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 的词:`~/` 形路径规则而本部署解不出执行环境的家目录。
+ */
+export declare const SERVER_ENTRY_PROBLEM_REASONS: readonly ["not_in_roster", "home_unresolvable"];
+export type ServerEntryProblemReason = (typeof SERVER_ENTRY_PROBLEM_REASONS)[number];
+/** 「读得出、却不在名册」的告知词({@link SERVER_ENTRY_PROBLEM_REASONS} 的第一员):`warnings` 里它之外的词都是引擎的条目读法读成空的原因词。 */
+export declare const NOT_IN_ROSTER: ServerEntryProblemReason;
+/** 一条问题(wire 形)。 */
+export interface EntryProblem {
+    readonly code: string;
+    readonly field: string;
+    readonly entry: string;
+    readonly reason: string;
+}
+/** 铸一条问题:`entry` 收**原串**,这里过脱敏(调用方没有「忘了脱敏」的可能)。 */
+export declare function entryProblem(code: string, field: string, rawEntry: string, reason: string): EntryProblem;
+/** 拒体上的机读位(原样进 `HttpError.extra` / `refusalBody` 的 `facts`:顶层 `field` + 对象形 `detail`)。 */
+export interface EntryProblemsFacts {
+    readonly field: string;
+    readonly detail: {
+        readonly problems: readonly EntryProblem[];
+        readonly total: number;
+    };
+}
+/**
+ * 一遍判下来的全部问题 ⇒ 拒体的机读位。**不能空**:没有问题就没有拒(调用方只在命中时调),空表是调用点的错,响亮抛。
+ * 顶层 `field` = 第一条问题的坐标(句子点名的那一张清单)。
+ */
+export declare function entryProblemsFacts(found: readonly EntryProblem[]): EntryProblemsFacts;
+//# sourceMappingURL=entry-problems.d.ts.map

package/dist/entry-problems.js

@@ -0,0 +1,14 @@
+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 NOT_IN_ROSTER = "not_in_roster";
+export function entryProblem(code, field, rawEntry, reason) {
+    return { code, field, entry: redactListEntry(rawEntry), reason };
+}
+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 } };
+}
+//# sourceMappingURL=entry-problems.js.map

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

@@ -10,6 +10,12 @@
  *      带外凭据(e2b / docker / k8s 车道本来就是多租户 fleet 的主形),与 LSP 那条「本机子进程」的形不同;多租户下起服说一句。
  *  · `BAKE_ENV_ALLOW`(S-684 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
  *    不进 {@link describeAllowlistPostures} 的姿态句)。它与服务侧四只旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
+ *  · `channel` = 这张名单**交给谁、在谁的减法之上**(闭集两词,解析器按它定「不许点哪些名」):
+ *    - `host-put-back`(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)—— 剥后放回形:宿主子进程的 env 先经唯一组合(引擎扣掉本服务自有凭据 + 形状剥),
+ *      名单点到的键再从本进程环境**原样**取回叠上去。点到本服务自有凭据名 = 把引擎刚扣下的那枚交回去 ⇒ 起服拒,判官 = 引擎同一只
+ *      (`inheritEnvPolicyProblem`,读起服声明;与引擎拒嵌入方白名单同句)。
+ *    - `sandbox-grant`(三只沙箱名单)—— 沙箱 env 的唯一来源(沙箱不从本进程继承任何东西),部署方显式交出的带外凭据(S-715 照转发);
+ *      本列不在「自有凭据」律的射程里,只拒点名名单型旋钮(原文按凭据类)。
  * 表是 `Record<旋钮, …>`:闭集加一只旋钮而不补行 = 编译红;行形随读它的进程定(服务进程 ⇒ 必须写姿态列)。
  *
  * 🔴 **姿态列只在这里写一次**([ref];7.101.0 合并复审 O9):凡要对人说「多租户下哪只旋钮忽略、哪只照转发」的句子,一律取
@@ -28,14 +34,18 @@ export type EnvNameAllowlistPosture = {
     readonly kind: "ignored";
     readonly why: string;
 };
-/** 服务侧旋钮一行:拒句示例 + 多租户姿态。 */
+/** 名单交给谁、在谁的减法之上(闭集;规则见表头注 `channel` 一条)。 */
+export type EnvNameAllowlistChannel = "host-put-back" | "sandbox-grant";
+/** 服务侧旋钮一行:拒句示例 + 交付形 + 多租户姿态。 */
 export interface ServerEnvNameAllowlistKnobRow {
     readonly example: string;
+    readonly channel: EnvNameAllowlistChannel;
     readonly multiTenant: EnvNameAllowlistPosture;
 }
-/** runner 旋钮一行:只有拒句示例(没有姿态可言)。 */
+/** runner 旋钮一行:拒句示例 + 交付形(没有姿态可言)。 */
 export interface RunnerEnvNameAllowlistKnobRow {
     readonly example: string;
+    readonly channel: EnvNameAllowlistChannel;
 }
 export type EnvNameAllowlistKnobTable = {
     readonly [K in EnvNameAllowlistKnob]: K extends ServerEnvNameAllowlistKnob ? ServerEnvNameAllowlistKnobRow : RunnerEnvNameAllowlistKnobRow;

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

@@ -1,12 +1,13 @@
 export const ENV_NAME_ALLOWLIST_KNOBS = {
     LSP_ENV_ALLOW: {
         example: "LSP_ENV_ALLOW=NPM_TOKEN,CARGO_REGISTRIES_MY_REG_TOKEN",
+        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" },
     },
-    E2B_SANDBOX_ENV: { example: "E2B_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", multiTenant: { kind: "honored" } },
-    DOCKER_SANDBOX_ENV: { example: "DOCKER_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", multiTenant: { kind: "honored" } },
-    K8S_SANDBOX_ENV: { example: "K8S_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", multiTenant: { kind: "honored" } },
-    BAKE_ENV_ALLOW: { example: "BAKE_ENV_ALLOW=REGISTRY_PASSWORD,NPM_TOKEN" },
+    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" } },
+    BAKE_ENV_ALLOW: { example: "BAKE_ENV_ALLOW=REGISTRY_PASSWORD,NPM_TOKEN", channel: "host-put-back" },
 };
 export const ENV_NAME_ALLOWLIST_KNOB_NAMES = new Set(Object.keys(ENV_NAME_ALLOWLIST_KNOBS));
 const POSTURE_PHRASE = {

package/dist/exec-bounds.d.ts

@@ -12,8 +12,10 @@
  * 是它报的那一界。
  *
  * 与 core 远端契约(`ExecStreamOptions.readTimeoutMs`:「缺省也 SHOULD 有活性界,一条命令不得等到环境死」)的对齐:
- * 说了墙钟的命令被墙钟兜住,不会无限等;两界都没说的命令,在有活性界的车道(k8s / e2b)上仍由它兜底。切断码沿用 core 的 `timeout`(core 远端码表
- * 把墙钟与活性两种超界都归这一词);两者靠句子区分 —— 独立的活性码属于 core 的码表。
+ * 说了墙钟的命令被墙钟兜住,不会无限等;两界都没说的命令,在有活性界的车道(k8s / e2b)上仍由它兜底。**切断码按触发的那一界**(core 7.52.0 #1795:
+ * 两套执行码闭集各有一词):墙钟 ⇒ `timeout`;静默界(调用方的 `readTimeoutMs` 或车道活性界)⇒ `liveness_no_output`,带窗口秒数 `noOutputSec`(车道的界 /
+ * 调用方说的静默界,从不是请求的预算)—— 两者解释自己用的是两个数,消费方(core 的 Bash 工具:「no output for N s」对「timed out after N s」)按码分。
+ * 静默切断的码、句、秒数只在 {@link buildLivenessCut} 一处铸,六车道同读。
  *
  * 不在本律里的界(adapter 自己的上限,不是调用方说的话,不关活性界):k8s 文件读写的数据上限 `dataTimeoutMs`、e2b 交给
  * 供应商的沙箱寿命上限。adapter 自己的整段数据搬运(k8s 快照 tar 上 / 下)天生静默,它们**自己说**一个墙钟(数据上限),
@@ -64,6 +66,16 @@ export declare function firstBoundOf(bounds: CommandBounds): {
     readonly ms: number;
     readonly cut: "wall" | LivenessBound;
 } | undefined;
-/** 活性切断的句子 —— 六条车道(host / e2b / k8s / ssh / adb / local-docker)唯一铸点(车道兜底的界点名旋钮与出路;调用方自己说的界点名那一参数)。 */
+/**
+ * 🔴 **一次静默切断 —— 唯一铸点**(六条车道 host / e2b / k8s / ssh / adb / local-docker 同读;纯数据,车道用它构造自己那一型的错误):
+ * 码恒为 `liveness_no_output`(core 7.52.0 #1795;墙钟切断照旧 `timeout`,不经本函数),句子 = {@link livenessCutMessage},`noOutputSec` = 静默窗口的整秒数
+ * (core `ExecutionError` 第五构造参;core 读它时向下取整、不足 1 秒不说 —— 本函数同读:不足 1 秒的窗口不带这一位)。远端流式错误(`RemoteExecutionError`)没有这一位的座,只带码与句。
+ */
+export declare function buildLivenessCut(bound: LivenessBound): {
+    readonly code: "liveness_no_output";
+    readonly message: string;
+    readonly noOutputSec?: number;
+};
+/** 活性切断的句子 —— {@link buildLivenessCut} 的句子半(车道兜底的界点名旋钮与出路;调用方自己说的界点名那一参数)。车道不直调它:码与句一处铸。 */
 export declare function livenessCutMessage(bound: LivenessBound): string;
 //# sourceMappingURL=exec-bounds.d.ts.map

package/dist/exec-bounds.js

@@ -26,6 +26,10 @@ function spoken(ms) {
         return `${ms} ms`;
     return ms % 1000 === 0 ? `${ms / 1000} s` : `${(ms / 1000).toFixed(1)} s`;
 }
+export function buildLivenessCut(bound) {
+    const sec = Math.floor(bound.ms / 1000);
+    return { code: "liveness_no_output", message: livenessCutMessage(bound), ...(sec >= 1 ? { noOutputSec: sec } : {}) };
+}
 export function livenessCutMessage(bound) {
     switch (bound.setBy) {
         case "lane":

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

@@ -58,8 +58,8 @@ export interface ExecutionLaneCaps {
      *  `lane === undefined || lane === "host"` 的同义形,分叉过就是记忆边界判错盘)。读本位的真装配点:
      *  `boot/deferred-sandbox-path-env.ts` 的 `isSandboxPathAdjudicationLane`(resolve-spec 写门 / parked 赎回腿 /
      *  执行环境装配三处的唯一属主)、`memory-scope.ts` 的 `memoryEngineRemoteLanePosture`、
-     *  `boot/memory-boundary.ts` 的 `buildMemoryBoundaryLaneFacts`(stores)、`capabilities/memory-notice.ts` 的
-     *  `buildNoticeLaneFacts`(resolve-spec)。⚠️ `in-process` 在本位上是 YES(hooks/进程内读确实在本机盘上),
+     *  `boot/memory-boundary.ts` 的 `buildMemoryBoundaryLaneFacts`(stores)。(「本会话没有持久记忆」的披露归引擎判、引擎渲染 ——
+     *  目录条目 `core/memory.no-persistent-store`,本仓只交 spec 上的事实,不再读本位做判别。)⚠️ `in-process` 在本位上是 YES(hooks/进程内读确实在本机盘上),
      *  但它**没有手** —— 问「手在不在本机盘上」要读 {@link handsOnWorkerFilePlane},不是只读本位。 */
     readonly hostFilePlane: LaneCapability;
     /** core 的 `isRemoteExecutionEnv` 对本车道的判决(鸭子类型,**含 host**)= core 拿没拿到执行环境 = 手带挂没挂。
@@ -134,7 +134,7 @@ export declare function executionLaneRow(lane: RemoteExecProvider): ExecutionLan
 /**
  * 一条车道**必需**的 env 键名 = 正本表行的 `requiredEnv ∪ requiredSecretEnv`(次序:非密坐标在前、密钥在后 —— 与 7.113.0 本仓手写表逐字同)。
  * 读者:`config.ts` 的 [ref] 拒启门(点了名却缺件 ⇒ 点名缺哪几键)、部署面门(`test/deploy-lanes-contract.test.ts`:`lanes.json` 每行登记
- * 本车道必需键、根 / review compose 透传全部车道必需键之并)、`scripts/gen-lanes-json.mjs`(从同一张正本生成 `lanes.json` 的必需键列)。
+ * 本车道必需键)、`scripts/gen-deploy-lanes.ts`(从同一张正本生成 `lanes.json` 的必需键列,以及根 / review compose 与 sema-up 栈 compose 里的必需键透传)。
  * device 没有必需 env(设备是运行期连进来的;它的 boot 前提是跨键的,在跨域不变量区拒启)。
  */
 export declare function laneRequiredEnv(lane: RemoteExecProvider): readonly string[];
@@ -185,7 +185,7 @@ export declare function executionLaneOf(provider: string | undefined): Execution
  * 实现会让无手部署**继续**挂 SendUserFile,与意图相反;本函数按意图实现(收车档 che-MA 写明)。
  *
  * 三个消费点问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
- *  ① `task-cwd.ts` 的 `toolsRunOnThisHost` —— wire `executionLane.toolsOnThisHost` + 出厂技能 `baseDir`;
+ *  ① `task-cwd.ts` 的 `toolsRunOnThisHost` —— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
  *  ② `boot/coordinators.ts` 的 SendUserFile 本机腿(经 ①;[ref] ③「无手不挂」);
  *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生。
  */
@@ -202,6 +202,33 @@ export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
  * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
  */
 export declare function laneBindsReads(lane: ExecutionLane): boolean;
+/**
+ * 「这条车道的执行环境**自己读得出家目录**」—— 没声明 `REMOTE_EXEC_HOME_DIR` 时,车道建环境那一拍问一次执行环境的 `$HOME` 填 `ExecutionEnv.homeDir` 的座
+ * (取值律与座的唯一属主 = `lane-home-probe.ts` 的 `LaneHomeSeat`)。
+ *  · `k8s` / `local-docker` / `ssh` / `adb` —— 家目录是镜像 / 目标机登录用户 / 设备 shell 的属性,执行环境开起来之后一条命令就读得出,真;
+ *  · `device` —— 设备协议(hello / 指令集)没有家目录读数:读它要么走协议新增一格(协议对端在别仓),要么往员工自己的机器上多跑一条未经策略门的命令,都不是本函数能替它定的,假;
+ *  · `host` / `in-process` / `e2b` —— 家目录是车道自己的事实(`executionLaneHomeDir` 在 boot 期就有答案),无物可测,假。
+ * 起服的「家目录答不出」那一行只留给 **家目录答不出 ∧ 车道又读不了** 的车道({@link buildUndeclaredHomeNote});读得了的车道缺席时由环境自己响(`LaneHomeSeat`)。
+ * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
+ */
+export declare function laneMeasuresHome(lane: ExecutionLane): boolean;
+/** 车道行声明的读面缺省(`READ_FACE` 缺席时,这条车道自己的那一份)。 */
+export type LaneReadFaceDefault = "open" | "roots";
+/**
+ * S-1492(clay 裁 [ref])—— **车道行显式声明读面缺省 `readFaceDefault`**:`READ_FACE` 没人表态时,这条车道自己的执行体该不该读面放开。
+ *  · `open` —— 隔离型车道(`e2b` / `k8s` / `local-docker`:每任务一只沙箱,OS 级隔离边界,`tenantSeparationBasis === "isolation"`):沙箱内部就是模型的整个世界,
+ *    读面缺省放开(`auto` 连续干活不再每碰一个根外路径就出卡;写面 / deny 表 / 审批模式不受影响)。
+ *  · `roots` —— 其余车道(`host` / `in-process` / `ssh` / `adb` / `device`):车道本身不给读面任何放开的理由 —— 手落在一台真机 / 共享目标 / 员工设备上。
+ *    **`roots` 不是「钉死 roots」**:它的意思是「本车道不替运维声明缺省」,缺省回到既有的 posture 派生(单用户 turnkey ⇒ `open`〔来源 `posture`〕;多租户 ⇒ 引擎默认 `roots`),
+ *    这些车道上的读面一个字节不变。优先序见 `posture-source.ts`(`env` > `center` > `lane` > `posture` > `engine-default`)。
+ *
+ * 🔴 这是**部署信任决定**不是技术默认:`open` 读面在沙箱里等于「沙箱能看见的都可读」—— 共享卷 / 镜像内凭据 / bind mount 进沙箱的宿主文件,在 `roots` 面上本有强制问
+ * (`bypass` 也清不掉),`open` 面零问。所以声明是**显式属性**(可审计,本函数的每个臂都要有人写),告诫句 {@link LANE_OPEN_READ_FACE_CAUTION} 随它走。
+ * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。与能力表 `isolation` 位的关系由对账测试钉死(`open` ⟺ `laneIsolated`)。
+ */
+export declare function laneReadFaceDefault(lane: ExecutionLane): LaneReadFaceDefault;
+/** 声明 `open` 的那一句**挂载告诫**(运维面指路句与车道文档同读这一句):把宿主目录 / 共享卷挂进隔离沙箱的部署,在 `open` 面上宿主文件对模型零问可读。 */
+export declare const LANE_OPEN_READ_FACE_CAUTION = "a deployment that mounts host paths or shared volumes into the sandbox (hostPath, bind mount) exposes those host files to reads on an open face \u2014 pin READ_FACE=roots or add read-deny rows (READ_DENY_PATTERNS) for them";
 /**
  * S-281 —— 「这条车道的手在不在 OS 级隔离边界里」。**全仓唯一**的布尔判别式(读表 `isolation` 位,见该位头注的读者清单)。
  * 穷举 switch、无 default 臂:`isolation` 的型只有两档,加档 = 编译红。
@@ -211,6 +238,13 @@ export declare function laneBindsReads(lane: ExecutionLane): boolean;
  * 不是 false。boot 行只在装出了执行环境工厂时才打,够不着那一格。
  */
 export declare function laneIsolated(lane: ExecutionLane): boolean;
+/**
+ * core 拿没拿到执行环境 = 这条车道**有没有手**(能力表 `coreRemoteExecutionEnv` 位)的唯一布尔口。读者四处:路由的「有没有执行环境」(`boot/resolve-spec.ts`)、
+ * wire `executionLane.isolated` 的在场判据(`capabilities/execution-lane.ts`)、记忆边界审计的车道位(`boot/memory-boundary.ts`)、场景详情的附件供给集
+ * (`boot/stage-07-capability-layer.ts` 把它填进 `ScenarioDeps.handsLane`:「这一 run 有没有工作区」的车道半场)—— 同读这一只,没有各写一份 `=== "supported"`。
+ * 穷举 switch、无 default 臂:该位的型三档(supported / unsupported / single-user-only)都要表态,加档 = 编译红。
+ */
+export declare function laneWiresExecutionEnv(lane: ExecutionLane): boolean;
 /**
  * S-281 —— 这条车道是不是**单机形缺省**落点(`REMOTE_EXEC` 未设 / 空串 ∧ `CONFIG_PROVIDER=local`,没人点名)。
  * 判据 = 装配出的车道值自己带的记号 `singleMachineDefault`(唯一写者 = `config.ts` 三元链的隐式 host 尾臂;显式 `REMOTE_EXEC=host`
@@ -274,11 +308,14 @@ export interface LaneHomeDeployment {
  * (`task-settings.ts` 的 `rejectUnmatchableSettingsNames`)在 home 未知时整表拒 `~/` 形 ——
  * **于是远端部署根本写不出 `~/` 规则**,恒 422。
  *
- * ## 本函数 = 那个值的**单一属主**
- * 两个消费面读同一份,不许各算各的(两处不同 = 一条规则在 422 门上被拒、却在引擎里编得出来,或反之):
- *  ① 每只 adapter 的 `homeDir` 座(`boot/execution-env.ts` 把本函数的答案递进 adapter 配置);
- *  ② 规则基 `PathRuleBases.home`(`boot/resolve-spec.ts` / `boot/parked-revive-gate.ts` 的
- *     `pathAdjudication.taskHome`)。
+ * ## 本函数 = **boot 期就答得出的** home 的单一属主
+ * 三个消费面读同一份,不许各算各的(两处不同 = 一条规则在 422 门上被拒、却在引擎里编得出来,或反之):
+ *  ① 每只 adapter 的 `homeDir` 座的**声明那一半**(`boot/execution-env.ts` 把本函数的答案递进 adapter 配置;
+ *     k8s / local-docker / ssh / adb 四条车道的座 = 本函数答案 ∨ 车道建环境时实测,取值律在 `lane-home-probe.ts` 的 `LaneHomeSeat`);
+ *  ② 规则基 `PathRuleBases.home`(`boot/resolve-spec.ts` / `boot/parked-revive-gate.ts` 的 `pathAdjudication.taskHome`);
+ *  ③ 422 前置门与能力披露(`task-settings.ts` / `deployment-governance.ts`)。
+ * ②③ 在下单那一刻就要答,那一刻执行环境还没开 —— 它们只读本函数,**读不到实测值**:没声明的 k8s / local-docker / ssh / adb 部署上,座有实测值而 ②③ 仍按「缺席」办
+ * (`~/` 形规则下单拒 —— 偏严的方向,不会出现「门放行而引擎编不出」)。
  *
  * ## 一条规则,不是七条特判
  * **运维显式声明恒赢**(`REMOTE_EXEC_HOME_DIR`,部署级旋钮,不挂任何客户端表态);没有声明时,
@@ -292,9 +329,18 @@ export interface LaneHomeDeployment {
  *  · `adb` —— Android 没有 POSIX 意义上的登录 home;
  *  · `device` —— 员工自己的机器,运行期才连进来。
  * 这五条一律**缺席**(诚实:不猜一个目录去守)。缺席的后果是 `~/` 规则在下单时被 422 响亮拒,
- * 与 core 的 `missingBase:"home"` 同向 —— 这正是负控要的那一格。
+ * 与 core 的 `missingBase:"home"` 同向 —— 这正是负控要的那一格。其中 `k8s` / `local-docker` / `ssh` / `adb` 的**引擎手里那一只座**另有实测的来源
+ * (建环境时问 `$HOME`,{@link laneMeasuresHome});本函数不替它回答 —— boot 期确实不知道。
  *
  * 认不出的车道 ⇒ `undefined`(调用方 fail-closed)。生产链上不可达:`loadConfig` 的 [ref] 拒启门先咬。
  */
 export declare function executionLaneHomeDir(deployment: LaneHomeDeployment): string | undefined;
+/**
+ * 「这条部署的执行车道**有手**、家目录答不出、**而车道又没有读数办法**」时起服那一行的 `note`(纯字符串 ⇒ `build*`);否则 `undefined`(不出这一行)。
+ * 判据只读 {@link executionLaneHomeDir}(boot 期的家目录)、能力表 `coreRemoteExecutionEnv` 位(有没有手)与 {@link laneMeasuresHome}(读不读得出):不另写车道清单。
+ * 读得出的车道(k8s / local-docker / ssh / adb)没声明时由环境建起来那一拍实测,实测缺席才由那只环境响同一只事件码(`LaneHomeSeat`)—— 起服不替它们先说。
+ * 代价如实:引擎 7.52.0 起家锚拒读行放不下 ⇒ 每一次泄内容的递归读在全 shell 面强制问人(allow / 模式 / bypass 都放不掉)、只读面拒;`~/` 形规则在下单时
+ * 就被 422 拒。出路只有一条:声明执行环境的家目录(`$HOME` 读出来的那个绝对路径)。这句话陈述的是事实,不是告警 —— 要它消失就声明家目录。
+ */
+export declare function buildUndeclaredHomeNote(deployment: LaneHomeDeployment): string | undefined;
 //# sourceMappingURL=execution-lane-caps.d.ts.map

package/dist/execution-lane-caps.js

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES } from "@sema-agent/settings-schema/execution-lanes";
+import { DECLARE_HOME_REMEDY, buildHomeAbsentNote } from "./lane-home-probe.js";
 const NO = "unsupported";
 const YES = "supported";
 const SU = "single-user-only";
@@ -216,6 +217,35 @@ export function laneBindsReads(lane) {
             return false;
     }
 }
+export function laneMeasuresHome(lane) {
+    switch (lane) {
+        case "k8s":
+        case "local-docker":
+        case "ssh":
+        case "adb":
+            return true;
+        case "device":
+        case "host":
+        case "in-process":
+        case "e2b":
+            return false;
+    }
+}
+export function laneReadFaceDefault(lane) {
+    switch (lane) {
+        case "e2b":
+        case "k8s":
+        case "local-docker":
+            return "open";
+        case "host":
+        case "in-process":
+        case "ssh":
+        case "adb":
+        case "device":
+            return "roots";
+    }
+}
+export const LANE_OPEN_READ_FACE_CAUTION = "a deployment that mounts host paths or shared volumes into the sandbox (hostPath, bind mount) exposes those host files to reads on an open face — pin READ_FACE=roots or add read-deny rows (READ_DENY_PATTERNS) for them";
 export function laneIsolated(lane) {
     const isolation = executionLaneCaps(lane).isolation;
     switch (isolation) {
@@ -225,6 +255,16 @@ export function laneIsolated(lane) {
             return false;
     }
 }
+export function laneWiresExecutionEnv(lane) {
+    const wired = executionLaneCaps(lane).coreRemoteExecutionEnv;
+    switch (wired) {
+        case "supported":
+            return true;
+        case "unsupported":
+        case "single-user-only":
+            return false;
+    }
+}
 export function isSingleMachineDefaultLane(remoteExec) {
     return remoteExec?.provider === "host" && remoteExec.singleMachineDefault === true;
 }
@@ -261,4 +301,14 @@ export function executionLaneHomeDir(deployment) {
             return undefined;
     }
 }
+export function buildUndeclaredHomeNote(deployment) {
+    if (executionLaneHomeDir(deployment) !== undefined)
+        return undefined;
+    const lane = executionLaneOf(deployment.remoteExec?.provider);
+    if (lane === undefined || executionLaneCaps(lane).coreRemoteExecutionEnv !== "supported")
+        return undefined;
+    if (laneMeasuresHome(lane))
+        return undefined;
+    return buildHomeAbsentNote(lane, "REMOTE_EXEC_HOME_DIR is unset, and this lane cannot read its execution environment's home", DECLARE_HOME_REMEDY);
+}
 //# sourceMappingURL=execution-lane-caps.js.map

package/dist/field-conflict.d.ts

@@ -0,0 +1,43 @@
+/** 冲突的类(闭集)。同一个约束的几个拒点同一个词;新增一类见文件头。 */
+export declare const FIELD_CONFLICT_KINDS: readonly ["cascade_verify", "image_profile", "resume_anchor", "system_prompt_fold", "file_history_restore", "skills_disabled", "existing_session", "scratchpad_root", "ask_answer", "policy_person_ask", "plan_edit", "plan_mode_after", "bound_call_door", "remember_decision"];
+/** 冲突的类(闭集词)。 */
+export type FieldConflictKind = (typeof FIELD_CONFLICT_KINDS)[number];
+/**
+ * 每一类允许点名的请求体坐标(铸点的 `fields` 按所属类的行检查)。键序无意义;值是该类可出现的坐标的联合。
+ * 动态下标的坐标用模板字面量型(`agents[1].skills`)。
+ */
+export interface FieldConflictCoordinates {
+    readonly cascade_verify: "verify" | "cascade" | "sandboxImageProfile" | "resumeAt" | "suggestNextPrompts";
+    readonly image_profile: "capabilitiesNeeded" | "sandboxImageProfile";
+    readonly resume_anchor: "resumeAtMode" | "resumeAt";
+    readonly system_prompt_fold: "appendSystemPrompt" | "settings.outputStyle";
+    readonly file_history_restore: "fileHistory" | "restoreFiles" | "rewindFilesTo" | "rewindFiles";
+    readonly skills_disabled: "disableSkills" | "skills" | `agents[${number}].skills`;
+    readonly existing_session: "requireExistingSession" | "sessionId";
+    readonly scratchpad_root: "cwd" | "scratchpadDir";
+    readonly ask_answer: "decision" | "answer";
+    readonly policy_person_ask: "decision" | "decidedBy";
+    readonly plan_edit: "decision" | "editedPlan";
+    readonly plan_mode_after: "decision" | "permissionModeAfter";
+    readonly bound_call_door: "boundCallId";
+    readonly remember_decision: "remember" | "decision";
+}
+/** 折叠上限那一类另带的度量位:合起来的量与帽。 */
+export interface FieldConflictMeasure {
+    readonly count: number;
+    readonly cap: number;
+}
+/** 拒体上的 `detail`。 */
+export type FieldConflictDetail<K extends FieldConflictKind = FieldConflictKind> = {
+    readonly kind: K;
+    readonly fields: readonly FieldConflictCoordinates[K][];
+} & Partial<FieldConflictMeasure>;
+/** 一处冲突的机读位(原样进拒体:`sendError` 的 extra / `HttpError.extra` / 手拼体的展开;型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用)。 */
+export type FieldConflictFacts<K extends FieldConflictKind = FieldConflictKind> = {
+    readonly detail: FieldConflictDetail<K>;
+};
+/**
+ * 铸一处冲突的机读位。`fields` 至少一个坐标、主语在前;`measure` 只有折叠上限那一类给。
+ */
+export declare function fieldConflictFacts<K extends FieldConflictKind>(kind: K, fields: readonly [FieldConflictCoordinates[K], ...FieldConflictCoordinates[K][]], measure?: FieldConflictMeasure): FieldConflictFacts<K>;
+//# sourceMappingURL=field-conflict.d.ts.map

package/dist/field-conflict.js

@@ -0,0 +1,20 @@
+export const FIELD_CONFLICT_KINDS = [
+    "cascade_verify",
+    "image_profile",
+    "resume_anchor",
+    "system_prompt_fold",
+    "file_history_restore",
+    "skills_disabled",
+    "existing_session",
+    "scratchpad_root",
+    "ask_answer",
+    "policy_person_ask",
+    "plan_edit",
+    "plan_mode_after",
+    "bound_call_door",
+    "remember_decision",
+];
+export function fieldConflictFacts(kind, fields, measure) {
+    return { detail: { kind, fields: [...fields], ...(measure === undefined ? {} : { count: measure.count, cap: measure.cap }) } };
+}
+//# sourceMappingURL=field-conflict.js.map

package/dist/fleet/fleet-bus.d.ts

@@ -306,12 +306,12 @@ export type FleetFrame = {
  *  4. 🔴 **纯 observe,不改变运行** —— 它走 fleet 流(常开推送道),**不是** `additionalContext`
  *     (那个通道本身会让这一轮不结束,见 hook-runner 折叠处那段旁注)。
  *
- * ⚠️ 可见性**与 `bg_notification` 同为 fail-CLOSED**(本帧**两族 kind 同规**):带 `ownerSessionId`
+ * ⚠️ 可见性**与 `bg_notification` 同为 fail-CLOSED**(本帧**每一族 kind 同规**):带 `ownerSessionId`
  * 的帧只投给能证明是自己的订阅方(`undefined` ⇒ 对 scoped 订阅方**丢弃**)。理由同源:一条关于别人
  * 会话的通知落到这个壳上,会让用户以为是自己这轮出了问题。
  *
- * ⚠️ `kind` 是**闭集**:第二族(`hook_non_blocking_failure`,[ref])见下。加族必须同时在
- * {@link hookNoticeWire} 表态(穷举 switch ⇒ 漏表态=编译红)。
+ * ⚠️ `kind` 是**闭集**:第二族(`hook_non_blocking_failure`,[ref])、第三族(`hook_managed_unrun`,托管车道)、第四族(`hook_verdict_untrusted`,判词不可信)见下。
+ * 加族必须同时在 {@link hookNoticeWire} 与发布口的 `boundedHookNotice` 表态(两处都是穷举 switch ⇒ 漏表态=编译红)。
  */
 export interface HookDecisionUnavailable {
     kind: "hook_decision_unavailable";
@@ -357,9 +357,12 @@ export interface HookNonBlockingFailure {
      *    - `asyncRewake` 的 exit 2 是**契约动作**(唤醒模型),不是故障,不进本族;
      *  · `timeout` —— 条目超时被击杀(无退出码);
      *  · `spawn_failed` —— 起不来 / http 连不上 / LLM 载体失败(无退出码);
-     *  · `bad_json` —— exit 0 但 stdout 看着是 JSON 却读不成决策对象(裁决静默丢失的那一形)。
+     *  · `bad_json` —— exit 0 但 stdout 看着是 JSON 却读不成决策对象(裁决静默丢失的那一形);
+     *  · `matcher_over_budget` —— 这条 hook 所在组的 `matcher`(或条目自己的 `if` 条件)在这次事件的这个名字上求值没在预算内结束(灾难回溯;S-1017)。
+     *    **不是 hook 脚本坏了,是它的选中条件不可求值**:server 按「选中」处理(守卫不被跳过,条目照跑),此帧说的是「这只 matcher 在这个名字上跑不完」。
+     *    **一组一帧**(`if` 一条目一帧),`hookName` / `entryType` 指认组的第一个条目,`detail` 点名 matcher、名字、额度与组里的条目数;无 `exitCode` / `stderr`。
      */
-    reason: "exit_nonzero" | "timeout" | "spawn_failed" | "bad_json";
+    reason: "exit_nonzero" | "timeout" | "spawn_failed" | "bad_json" | "matcher_over_budget";
     /** hook 身份(CC `OG`/`AEe` 锚:`statusMessage` 优先,否则 command / url / prompt),已脱敏+有界。
      *  ⚠️ http 条目取 URL 时**剥掉 query 与 fragment**([ref] codex R1-F1:端点凭据最常见的挂法是
      *  `?token=…`,而通用脱敏器只认 `user:pass@` 形)。要更友好的名字,作者有 `statusMessage`。 */
@@ -375,8 +378,79 @@ export interface HookNonBlockingFailure {
     /** 补充说明(已脱敏)。 */
     detail?: string;
 }
+/**
+ * **一条托管 hook 没跑成**的观测帧(第三族;[ref] 托管车道)。
+ *
+ * ── 它解决什么 ────────────────────────────────────────────────────────────────────────────────
+ * 请求的 hook 组带来源(`source`);托管组(`managedPolicy` / `managedPlugin:<name>`)是组织策略的守卫。执行器把托管条目放在独立车道里、
+ * 在非托管改写之后的最终输入上跑;一条**同步**托管条目若没能给出合法裁决(exit 0 且无判词 / 闭集判词)或合法否决(exit 2 / `decision:"block"` /
+ * `continue:false`),就是「没跑成」—— `PreToolUse` 上结论在没有否决时折 `ask`(人在环;不采信非托管的放行;任何一相的否决仍是最后一票),其余事件上结论不变,但**这一帧必发**:
+ * 托管守卫没看住这一次,不能只进服务端日志。与上面两族同为纯 observe、同走 fleet 流、同为 fail-CLOSED 可见性。
+ *
+ * ⚠️ 一条未跑成的托管条目一帧(不收敛那一形指认重判那一遍里改写的条目;墙钟耗尽那一形只指认撞上的那一条)。`async` / `asyncRewake` 条目不在判据里(本就不阻断)。
+ */
+export interface HookManagedUnrun {
+    kind: "hook_managed_unrun";
+    /** 哪个 hook 事件。`PreToolUse` 上这一条置位托管车道:没有否决时这次调用折 `ask`(本帧不断言这次调用怎么收场);其余事件结论不变。 */
+    event: string;
+    /**
+     * 为什么没跑成(闭集;每个词对应执行器里一条既有的跳过 / 故障臂):
+     *  · `matcher_invalid` —— 组的 matcher 编不过(该组不跑);
+     *  · `llm_carrier_unavailable` / `llm_cap` —— prompt / agent 条目没有模型载体 / 超出每事件的 LLM 条目数;
+     *  · `powershell_unsupported` —— `shell:"powershell"` 条目(本服务不跑);
+     *  · `if_unevaluable` —— 条目的 `if` 条件评不出;
+     *  · `budget_exhausted` —— 托管车道的事件墙钟耗尽:撞上的那一条记一帧,同一次执行里其后的条目不再起、不逐条记(PreToolUse 逐组执行 ⇒ 至多每组一帧);
+     *  · `spawn_failed` / `timeout` —— 起不来 / 超时被收;
+     *  · `exit_nonzero` —— 退出码非 0 非 2;`bad_json` —— 看着是 JSON 却读不成(含 http 条目 2xx 回了非 JSON 体、Stop × prompt 的判词读不出);`decision_out_of_set` —— `permissionDecision` 不在 allow / deny / ask 里;
+     *  · `evidence_unavailable` —— Stop × prompt 条目因会话证据面不足(或运维关了 transcript)被滤掉没跑;
+     *  · `rewrite_unsettled` —— 一个托管相(插件相 / 策略相)改写了输入、按新输入把那一相重判一遍后仍交回不同的值(不收敛;「改写」按值判,恒等回显不算)。
+     */
+    reason: "matcher_invalid" | "llm_carrier_unavailable" | "llm_cap" | "powershell_unsupported" | "if_unevaluable" | "budget_exhausted" | "spawn_failed" | "timeout" | "exit_nonzero" | "bad_json" | "decision_out_of_set" | "evidence_unavailable" | "rewrite_unsettled";
+    /** 那一组的来源词(`managedPolicy` 或 `managedPlugin:<name>`;名只留痕)。 */
+    source: string;
+    /** hook 身份(同 `hook_non_blocking_failure`:`statusMessage` 优先,否则 command / url〔剥 query〕/ prompt),已脱敏 + 有界。 */
+    hookName: string;
+    entryType: "command" | "http" | "prompt" | "agent";
+    /** 工具事件才有。 */
+    toolName?: string;
+    /** 补充说明(已脱敏)。 */
+    detail?: string;
+}
+/**
+ * **一条 hook 的判词不可信**的观测帧(第四族;两车道同形、同一只铸点 `noteVerdictUntrusted`)。
+ *
+ * ── 它解决什么 ────────────────────────────────────────────────────────────────────────────────
+ * 一条律(R5):条目没拿到完整载荷,或是被超预算的 matcher **按选中**拉进来的 ⇒ 它的否决算数(deny / exit 2 / `decision:"block"` / `continue:false` / ask),
+ * 它的放行与 `updatedInput` 不作数。这条律在两车道上都成立,所以只有一种帧:成因(`reason`)、车道(`lane`)与身份都是机读位,壳不解析句子。
+ * 每车道一条出帧条件:托管车道 = 条目拿着不可信成因跑完即发,不看它自己判什么(托管车道随之置位:`PreToolUse` 在没有否决时折 `ask`);
+ * 非托管车道 = 它给了放行或真改写(恒等回显不算)而被丢时发。今天只在有放行词的 `PreToolUse` 上成立。
+ * **本帧不断言这次调用怎么收场**:托管条目自己否决 ⇒ 这次是 deny、帧照发;同组另有可信放行 ⇒ 非托管这一帧照发、这次照放行 —— 结局看调用自己的结果。
+ * 与上面三族同为纯 observe、同走 fleet 流、同为 fail-CLOSED 可见性。
+ */
+export interface HookVerdictUntrusted {
+    kind: "hook_verdict_untrusted";
+    /** 哪个 hook 事件(今天恒 `PreToolUse`)。 */
+    event: string;
+    /**
+     * 判词为什么不可信(闭集):
+     *  · `input_truncated` —— 条目没拿到完整载荷:`tool_input` 超上限被换成截断标记,或 prompt / agent 条目的整份载荷文本按同一上限被截尾;
+     *  · `matcher_over_budget` —— 组的 matcher(或条目 `if` 的名部)求值超预算、条目被**按选中**跑了(本义选不选它不知道;同一次另有 `hook_non_blocking_failure{matcher_over_budget}` 说「选中条件不可求值」)。
+     */
+    reason: "input_truncated" | "matcher_over_budget";
+    /** 条目所在的车道(由来源闭集的那一张表读出:`managedPolicy` / `managedPlugin:*` ⇒ `managed`,其余与缺席 ⇒ `unmanaged`)。车道的后果见上:读这一位,不从 `source` 重推。 */
+    lane: "managed" | "unmanaged";
+    /** hook 身份(同 `hook_non_blocking_failure`),已脱敏 + 有界。 */
+    hookName: string;
+    entryType: "command" | "http" | "prompt" | "agent";
+    /** 工具事件才有。 */
+    toolName?: string;
+    /** 那一组声明的来源词(两车道都给;缺席 = 组没声明,只可能是非托管)。名只留痕,不作判据。 */
+    source?: string;
+    /** 补充说明(已脱敏;人读,机读只看 `reason` / `lane`)。 */
+    detail?: string;
+}
 /** 生产者视角的观测面(hook-runner 铸的形):归属位由 boot 层在发布时补。 */
-export type HookNoticeObservation = HookDecisionUnavailable | HookNonBlockingFailure;
+export type HookNoticeObservation = HookDecisionUnavailable | HookNonBlockingFailure | HookManagedUnrun | HookVerdictUntrusted;
 /** 租户/会话归属位 —— **只用于过滤,上 wire 前剥**(见 `hookNoticeWire`)。 */
 export interface HookNoticeOwnership {
     /** 租户可见性(发布前带,上 wire 前剥)。 */

package/dist/fleet/fleet-bus.js

@@ -57,6 +57,46 @@ export function hookNoticeWire(n) {
                 ...(n.stderr !== undefined ? { stderr: n.stderr } : {}),
                 ...(n.detail !== undefined ? { detail: n.detail } : {}),
             };
+        case "hook_managed_unrun":
+            return {
+                kind: n.kind,
+                event: n.event,
+                reason: n.reason,
+                source: n.source,
+                hookName: n.hookName,
+                entryType: n.entryType,
+                ...(n.toolName !== undefined ? { toolName: n.toolName } : {}),
+                ...(n.detail !== undefined ? { detail: n.detail } : {}),
+            };
+        case "hook_verdict_untrusted":
+            return {
+                kind: n.kind,
+                event: n.event,
+                reason: n.reason,
+                lane: n.lane,
+                hookName: n.hookName,
+                entryType: n.entryType,
+                ...(n.toolName !== undefined ? { toolName: n.toolName } : {}),
+                ...(n.source !== undefined ? { source: n.source } : {}),
+                ...(n.detail !== undefined ? { detail: n.detail } : {}),
+            };
+    }
+}
+function boundedHookNotice(notice) {
+    const detail = notice.detail !== undefined ? { detail: boundedNoticeText(notice.detail) } : {};
+    switch (notice.kind) {
+        case "hook_decision_unavailable":
+            return { ...notice, ...detail };
+        case "hook_non_blocking_failure":
+            return { ...notice, hookName: boundedNoticeText(notice.hookName), ...(notice.stderr !== undefined ? { stderr: boundedNoticeText(notice.stderr) } : {}), ...detail };
+        case "hook_managed_unrun":
+            return { ...notice, hookName: boundedNoticeText(notice.hookName), source: boundedNoticeText(notice.source), ...detail };
+        case "hook_verdict_untrusted":
+            return { ...notice, hookName: boundedNoticeText(notice.hookName), ...(notice.source !== undefined ? { source: boundedNoticeText(notice.source) } : {}), ...detail };
+        default: {
+            const unhandled = notice;
+            throw new Error(`boundedHookNotice: unhandled hook notice kind ${JSON.stringify(unhandled)}`);
+        }
     }
 }
 export class FleetEventBus {
@@ -84,15 +124,7 @@ export class FleetEventBus {
         this.emit({ type: "task", row: merged, ts: this.now() });
     }
     publishHookNotice(notice) {
-        const bounded = notice.kind === "hook_non_blocking_failure"
-            ? {
-                ...notice,
-                hookName: boundedNoticeText(notice.hookName),
-                ...(notice.stderr !== undefined ? { stderr: boundedNoticeText(notice.stderr) } : {}),
-                ...(notice.detail !== undefined ? { detail: boundedNoticeText(notice.detail) } : {}),
-            }
-            : { ...notice, ...(notice.detail !== undefined ? { detail: boundedNoticeText(notice.detail) } : {}) };
-        this.emit({ type: "hook_notice", notice: bounded, ts: this.now() });
+        this.emit({ type: "hook_notice", notice: boundedHookNotice(notice), ts: this.now() });
     }
     removeTask(id, opts) {
         const existing = this.tasks.get(id);