@sema-agent/server 7.134.0 → 7.136.0

package/dist/deployment-shape.d.ts

@@ -0,0 +1,127 @@
+/**
+ * [ref] —— **部署形谓词的唯一一张表**(消费点读表;吸收 [ref] / [ref] / [ref])。
+ *
+ * ## 规则
+ * 「这台部署是什么形」的每一个布尔判断只有一个答者:{@link DEPLOYMENT_SHAPE_PREDICATES} 的一行。消费点写
+ * `DEPLOYMENT_SHAPE_PREDICATES.<行>.holds(config)`,不 import 散落函数;表外不许再长出一只自读部署形事实的布尔判据
+ * (反向门 `test/deployment-shape-gate.test.ts` 按语法树判,判据逐字写在那份门的头注里)。
+ *
+ * ## 两根轴,每根轴一个读口(原始配置键只在这两个函数里被读)
+ *  · `principal` —— 运维的 `REQUIRE_PRINCIPAL` 声明({@link readPrincipalAxis})。
+ *  · `lane` —— `REMOTE_EXEC` 的归一车道词(`executionLaneOf`,认不出 ⇒ `undefined`,行必须 fail-closed)+ 那条车道的能力表行 +
+ *    车道子旋钮(k8s 运行时类 / 快照店、隐式 host 尾臂记号)({@link readLaneAxis})。
+ *
+ * ## 轴列不是注释,是型
+ * 每行的判官只收到它**声明**的那几根轴的事实({@link DeploymentShapeFacts}),读不到配置本身 —— 判官碰一根没声明的轴 = 编译红;
+ * `holds` 的入参型 = 所声明轴读入形的交叉({@link DeploymentShapeInput}),所以调用方递完整 `ServiceConfig` 或只递那几键的窄形都行。
+ *
+ * ## 什么进表、什么不进
+ * 进表的是**形规则**:只由部署形事实决定的布尔(去重后 14 行;同一条规则的多个消费者读同一行,不各成一行)。
+ * 把一行与**非形事实**(锁键、合规档位、审批意图、请求身份、请求体)合取的能力判据是**消费者**,住在它自己的模块
+ * (`mcpInjectionHonored` = 锁 ∧ 合规 ∧ `!multiTenant`;`taskHooksHonored`;身份门 …),读行、不读原始键。
+ * 车道表(`execution-lane-caps.ts`)按车道词键控的布尔列(`laneIsolated` 等)是车道轴自己的事实表,不是「部署」的谓词;行读它们。
+ *
+ * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts`(它本身是叶),零运行期环。
+ */
+import { type ExecutionLane, type ExecutionLaneCaps } from "./execution-lane-caps.js";
+/** `principal` 轴读的配置键(`ServiceConfig` 结构上满足)。 */
+export interface PrincipalAxisInput {
+    readonly requirePrincipal?: boolean | undefined;
+}
+/** `principal` 轴的事实。 */
+export interface PrincipalAxisFacts {
+    /** 运维声明了 `REQUIRE_PRINCIPAL=true`。 */
+    readonly declared: boolean;
+}
+/** `lane` 轴读的配置键:已装配的 `remoteExec` 里本表用得到的那几键(`ServiceConfig` 的判别联合每一臂结构上都满足)。 */
+export interface LaneAxisInput {
+    readonly remoteExec?: {
+        readonly provider?: string | undefined;
+        readonly runtimeClass?: string | undefined;
+        readonly s3Snapshot?: unknown;
+        readonly singleMachineDefault?: boolean | undefined;
+    } | undefined;
+}
+/** `lane` 轴的事实。 */
+export interface LaneAxisFacts {
+    /** 归一车道词;认不出 ⇒ `undefined`(生产链上不可达:`loadConfig` 的 [ref] 先拒启;行在这一格必须 fail-closed)。 */
+    readonly lane: ExecutionLane | undefined;
+    /** 那条车道的能力表行(认不出 ⇒ `undefined`)。 */
+    readonly caps: ExecutionLaneCaps | undefined;
+    /** k8s 的 `runtimeClass`(别的车道 `undefined`)。 */
+    readonly k8sRuntimeClass: string | undefined;
+    /** k8s 配了 S3 工作区快照店(别的车道 `false`)。 */
+    readonly k8sSnapshotStore: boolean;
+    /** host 车道值上带「单机形缺省」记号(唯一写者 = `config.ts` 三元链的隐式 host 尾臂;显式 `REMOTE_EXEC=host` 与文件覆写都不带)。 */
+    readonly singleMachineDefault: boolean;
+}
+/** 轴全集(闭集)→ 读入形与事实型。加一根轴 = 在这里加一键 + {@link readAxis} 的穷举 switch 加一臂(漏一处即编译红)。 */
+interface AxisShapes {
+    readonly principal: {
+        readonly input: PrincipalAxisInput;
+        readonly facts: PrincipalAxisFacts;
+    };
+    readonly lane: {
+        readonly input: LaneAxisInput;
+        readonly facts: LaneAxisFacts;
+    };
+}
+/** 部署形轴(闭集)。 */
+export type DeploymentShapeAxis = keyof AxisShapes;
+type UnionToIntersection<U> = (U extends unknown ? (u: U) => void : never) extends (i: infer I) => void ? I : never;
+/** 一行的入参型 = 它声明的各轴读入形的交叉。 */
+export type DeploymentShapeInput<A extends DeploymentShapeAxis> = UnionToIntersection<AxisShapes[A]["input"]>;
+/** 一行的判官看得见的事实 = 它声明的那几根轴(恰这几键)。 */
+export type DeploymentShapeFacts<A extends DeploymentShapeAxis> = {
+    readonly [K in A]: AxisShapes[K]["facts"];
+};
+/** 表的一行。 */
+export interface DeploymentShapePredicate<A extends DeploymentShapeAxis> {
+    /** 这一行读哪几根轴(= 判官入参的型;不是注释)。 */
+    readonly axes: readonly A[];
+    /** 这一行回答的那一句话(含它判的语义轴:租户 / 车道 / 设备归属 / 隔离强度 …)。 */
+    readonly question: string;
+    /** 在这台部署上成立吗。 */
+    holds(deployment: DeploymentShapeInput<A>): boolean;
+}
+export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
+    /** 身份门的问法。读者:请求面的身份 / 属主门(`http/principal-gate.ts`、`http/request-guards.ts`、`security.ts`)。 */
+    principalRequired: DeploymentShapePredicate<"principal">;
+    /**
+     * 租户轴的问法。今天与 {@link DEPLOYMENT_SHAPE_PREDICATES.principalRequired} 读**同一个声明**([ref] ①:托管 / 多租 ⇔ `REQUIRE_PRINCIPAL=true`,
+     * 签发方配置是身份验签轴、不算租户证据)—— 两个问题、一根轴、一个读口;「鉴权必需」与「多租形」拆成两个声明时只改这一行的判官。
+     */
+    multiTenant: DeploymentShapePredicate<"principal">;
+    /** 读能力表 `callerCwd` 位(host = 单主才开;device = 路径落在发起者自己的设备上,归属由 `device_session` 绑定验过,不要求单主)。 */
+    callerCwd: DeploymentShapePredicate<"principal" | "lane">;
+    /** 调用方给的宿主绝对路径(附加目录 / 项目上下文 / 本机 SendUserFile / 指令文件探针)只在「手就在本 worker 的盘上 ∧ 单主」时指向调用方自己的东西。 */
+    callerOwnsWorkerDisk: DeploymentShapePredicate<"principal" | "lane">;
+    /** wire `executionLane.toolsOnThisHost` 与出厂 / 中心技能的 `baseDir`:只问文件系统同一性,与租户无关(出厂内容每个租户拿到同一份)。 */
+    toolsOnThisHost: DeploymentShapePredicate<"lane">;
+    /** `REMOTE_EXEC` 未设的进程内形(没有手)且单主:进程级消费者(hooks 命令、项目上下文本机读、卡批规则 root)看到的就是引擎自己的进程 cwd / env。 */
+    inProcessSingleUser: DeploymentShapePredicate<"principal" | "lane">;
+    /** 任务层替部署声明宿主姿态(bypassPermissions 开写面 / host shell 继承整份环境)的射程:device 车道上跨租户宿主穿越结构性不存在(clay 裁定③)。 */
+    taskHostPostureDeclarations: DeploymentShapePredicate<"principal" | "lane">;
+    /** 写门走 [ref] 代理裁决(文件平面不在 worker 本机);认不出的词 ⇒ 走代理(代理 slot 空 ⇒ 写门 fail-closed)。 */
+    sandboxPathAdjudication: DeploymentShapePredicate<"lane">;
+    /** 读能力表 `sandboxSendUserFile` 位(e2b / k8s 每任务一只沙箱 ⇒ 任何租户;ssh 共享一台真机 ⇒ 只单主)。 */
+    sandboxSendUserFile: DeploymentShapePredicate<"principal" | "lane">;
+    /** 读能力表 `remoteScratchpad` 位(`/tmp/scratchpad/<sessionId>` 远端约定)。 */
+    remoteScratchpad: DeploymentShapePredicate<"lane">;
+    /** 读能力表 `tenantSeparation` 位(值来自 settings-schema 车道词表正本);唯一读者 = 跨域不变量 `multi-tenant-shared-lane`。 */
+    laneSeparatesTenants: DeploymentShapePredicate<"principal" | "lane">;
+    /**
+     * [ref] —— **VM 级**隔离强度(独立内核:e2b 的 Firecracker microVM;k8s 只在 Kata / gVisor 运行时类上)。与能力表 `isolation` 位
+     * (OS 级边界,容器即算;wire `executionLane.isolated` 的属主 `laneIsolated`)是两个问题,所以不叫「isolated」。读者:A 值路由。
+     */
+    vmIsolatedHands: DeploymentShapePredicate<"lane">;
+    /**
+     * [ref] —— 执行环境可挂起:能力表 `suspendable` 位(「结构上能不能」)∧ k8s 的前提旋钮(配了 S3 快照店)。真作者是各适配器对 core 的
+     * `capabilities.suspendable` 声明(对账:`test/execution-lane-caps.test.ts` 拿真适配器实例逐车道核)。读者:boot `remote_exec_enabled.suspendable`。
+     */
+    suspendableHands: DeploymentShapePredicate<"lane">;
+    /** 读者两处:`config.ts` 车道落点一行的 `source`(覆写之前)与 `boot/execution-env.ts` 的 `remote_exec_real_system.note`(覆写之后)—— 同一个记号、两个时刻。 */
+    singleMachineDefaultLane: DeploymentShapePredicate<"lane">;
+}>;
+export {};
+//# sourceMappingURL=deployment-shape.d.ts.map

package/dist/deployment-shape.js

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

package/dist/device-store.d.ts

@@ -50,7 +50,7 @@ export declare const DEVICE_RATE_LIMIT_CODE: "limit.rate_exceeded";
  * 排空/停机拒绝复用**既有**的通用码(`draining`,`docs/ASSISTANT-WIRE-CONTRACT.md` 附录 A 已收录,503)。
  *
  * 🔴 刻意不铸 `device.draining`([ref]/[ref]):§4.8 的 device 闭集**冻结**且无 draining 成员,而排空
- * 语义面全部署早有属主词 —— HTTP 计费提交拒臂(`http/readiness.ts` 的 `billableRefusalOf` 唯一铸点,S-739 前是 `sendError(res, 503, "draining", …)`;SDK spec 逐字引用
+ * 语义面全部署早有属主词 —— HTTP 计费提交拒臂(`http/readiness.ts` 的 `billableRefusalOf` 唯一铸点,[ref] 前是 `sendError(res, 503, "draining", …)`;SDK spec 逐字引用
  * 的冻结字面)、drain 期新 upgrade 拒(503)、WS hello 拒帧 / bye 帧的 `draining` 分支键。为同一语义再铸
  * `device.*` 同义码 = 消费端要认两套(上面 rate-limit 条的同一判据);且 `device.draining` 在 HTTP 层
  * 零发送点,写进附录 A 即幽灵行(`error-code-catalog-live` 的「文档多码」臂当场红)。

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

@@ -180,7 +180,7 @@ export interface DeviceWsHub {
     isDraining(): boolean;
     connectedDeviceIds(): string[];
     /**
-     * S-470(车C C-G2「吊销后活连接 5s 内断」)—— **立刻**对这台设备的活连接重跑一次世代围栏。
+     * [ref](车C C-G2「吊销后活连接 5s 内断」)—— **立刻**对这台设备的活连接重跑一次世代围栏。
      *
      * 🔴 为什么是「重跑围栏」而不是一条新的断连路径:吊销已经在**店内同事务**作废租约并把
      * `conn_generation` 推进一格(§4.6 步 2),所以本连接的下一次带世代谓词的写必然影响 0 行 ——

package/dist/egress-redirect.d.ts

@@ -1,6 +1,6 @@
 /**
  * 本服务**自己**发往配置端点的出站请求(hook 直连模型腿 `hooks/hook-llm.ts`、记忆 embedder `plugins/memory-embedder.ts`)的
- * 重定向律 —— 与 core 7.51.0(#1531)一方 brain 的请求同一条:请求以 `redirect: "manual"` 发出,端点回重定向 ⇒ 拒;
+ * 重定向律 —— 与 core 7.51.0([ref])一方 brain 的请求同一条:请求以 `redirect: "manual"` 发出,端点回重定向 ⇒ 拒;
  * 不跟、不重试、拒句不点名目标。
  *
  * 为什么:请求只去被判过的那个根。传输层(undici)跟随 POST 307 / 308 时把请求体(用户内容 / 记忆正文)原样送到

package/dist/elicitation.d.ts

@@ -20,7 +20,7 @@ export interface ElicitationFrame {
      *  coordinate instead, same posture as the stream-approval frames' `serverNowMs`. */
     serverNowMs?: number;
     /** "elicitation" only (additive; the same window pair `question` carries): the coordinator's OWN answer window —
-     *  at expiry the ask releases as `decline`. Minted from the SAME `ttlMs` the `setTimeout` below arms (one source), so
+     *  at expiry the ask is released as `cancel` (nobody answered; see RELEASE_ACTION). Minted from the SAME `ttlMs` the `setTimeout` below arms (one source), so
      *  a form replayed from the ledger can be judged still-waiting (no `elicitation_complete` with this id ∧
      *  `expiresAtMs` not reached) or lapsed even when the close row never landed (a lost write, a crashed replica). */
     expiresInMs?: number;
@@ -37,13 +37,13 @@ export interface ElicitationRunContext {
     abortSignal?: AbortSignal;
 }
 export interface ElicitationThrottle {
-    /** Max concurrent in-flight elicitations per run leg (parallel tool calls can each elicit). Breach ⇒ decline. */
+    /** Max concurrent in-flight elicitations per run leg (parallel tool calls can each elicit). Breach ⇒ refused (`decline`). */
     maxConcurrentPerRun: number;
-    /** Max total elicitations one run leg will surface to the human. Breach ⇒ decline (flood defense). */
+    /** Max total elicitations one run leg will surface to the human. Breach ⇒ refused (`decline`; flood defense). */
     maxTotalPerRun: number;
-    /** Min gap (ms) between two elicitations from the SAME server within a run. Within ⇒ decline (burst guard). */
+    /** Min gap (ms) between two elicitations from the SAME server within a run. Within ⇒ refused (`decline`; burst guard). */
     minIntervalMsPerServer: number;
-    /** An unanswered elicitation auto-declines after this (ms) — the human walked away; don't hold core forever. */
+    /** An unanswered elicitation is released as `cancel` after this (ms) — the human walked away; don't hold core forever. */
     ttlMs: number;
 }
 export declare const DEFAULT_ELICITATION_THROTTLE: ElicitationThrottle;
@@ -75,8 +75,9 @@ export declare class ElicitationCoordinator {
      *  the case where the leg ends/throws while an elicitation is parked but the leg's own loop has already drained. */
     runWithContext<T>(ctx: ElicitationRunContext, fn: () => Promise<T>): Promise<T>;
     /** `RunnerDeps.onElicit`. Core calls this when an opted-in server elicits the END USER mid-tool-call; the resolved
-     *  value is sent back to the server on the still-open connection. Fail-closed (`decline`/`cancel`) in every
-     *  uncertain case. Arrow property so it can be passed as `onElicit: coordinator.elicit` with `this` bound. */
+     *  value is sent back to the server on the still-open connection. Fail-closed (never `accept`) in every uncertain
+     *  case: a rule-based refusal is `decline`, a release nobody answered is `cancel` (RELEASE_ACTION).
+     *  Arrow property so it can be passed as `onElicit: coordinator.elicit` with `this` bound. */
     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.

package/dist/elicitation.js

@@ -5,6 +5,7 @@ import { recordFailOpen } from "./observability/fail-open.js";
 import { refusalBody } from "./http/refusal-body.js";
 const MAX_ELICIT_MESSAGE_CHARS = 4096;
 const MAX_ELICIT_SCHEMA_BYTES = 8192;
+const RELEASE_ACTION = { refused: "decline", unanswered: "cancel" };
 export const DEFAULT_ELICITATION_THROTTLE = {
     maxConcurrentPerRun: 2,
     maxTotalPerRun: 20,
@@ -65,7 +66,7 @@ export class ElicitationCoordinator {
             finally {
                 for (const [, p] of [...this.pending]) {
                     if (p.taskId === ctx.taskId)
-                        p.settle({ action: "cancel" });
+                        p.settle({ action: RELEASE_ACTION.unanswered });
                 }
                 this.counters.delete(ctx.taskId);
             }
@@ -74,18 +75,18 @@ export class ElicitationCoordinator {
     elicit = async (req, signal) => {
         const ctx = this.als.getStore();
         if (!ctx)
-            return { action: "decline" };
+            return { action: RELEASE_ACTION.refused };
         if (typeof req.url === "string" && req.url.length > 0)
-            return { action: "decline" };
+            return { action: RELEASE_ACTION.refused };
         if (signal?.aborted || ctx.abortSignal?.aborted)
-            return { action: "cancel" };
+            return { action: RELEASE_ACTION.unanswered };
         const rc = this.countersFor(ctx.taskId);
         const t = this.now();
         const last = rc.lastByServer.get(req.server);
         if (rc.inflight >= this.throttle.maxConcurrentPerRun ||
             rc.total >= this.throttle.maxTotalPerRun ||
             (last !== undefined && t - last < this.throttle.minIntervalMsPerServer)) {
-            return { action: "decline" };
+            return { action: RELEASE_ACTION.refused };
         }
         const id = uuidv7();
         rc.inflight += 1;
@@ -107,8 +108,8 @@ export class ElicitationCoordinator {
             rc.inflight = Math.max(0, rc.inflight - 1);
             resolveAnswer(r);
         };
-        const onAbort = () => settle({ action: "cancel" });
-        timer = setTimeout(() => settle({ action: "decline" }), this.throttle.ttlMs);
+        const onAbort = () => settle({ action: RELEASE_ACTION.unanswered });
+        timer = setTimeout(() => settle({ action: RELEASE_ACTION.unanswered }), this.throttle.ttlMs);
         timer.unref?.();
         signal?.addEventListener("abort", onAbort, { once: true });
         ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
@@ -124,7 +125,7 @@ export class ElicitationCoordinator {
         }
         else if (delivery === "failed") {
             recordFailOpen("server.elicitation.open-frame-undelivered", `elicitation=${id} server=${req.server}`);
-            settle({ action: "decline" });
+            settle({ action: RELEASE_ACTION.unanswered });
         }
         const answer = await answerP;
         void emitted

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

@@ -1,5 +1,5 @@
 /**
- * S-1306 —— **入口地板钳制**通告(`engine_notice` 码 `permission.entry_mode_clamped`)的唯一铸点(core 7.51.0 #1527 入册:受众 user、
+ * [ref] —— **入口地板钳制**通告(`engine_notice` 码 `permission.entry_mode_clamped`)的唯一铸点(core 7.51.0 [ref] 入册:受众 user、
  * 铸者 `NOTICE_MINTER` = `"server"`,引擎从不铸它)。
  *
  * ## 这件事为什么归本仓
@@ -23,7 +23,7 @@
  */
 import type { EngineNotice, EngineNoticeCode } from "@sema-agent/core";
 import type { EntryPermissionMode } from "./runtime-governance.js";
-/** 码常量型 = core 码册(#1527 入册:受众 user、铸者 `"server"`)。 */
+/** 码常量型 = core 码册([ref] 入册:受众 user、铸者 `"server"`)。 */
 export declare const ENTRY_MODE_CLAMPED: EngineNoticeCode;
 /** 一次受理门盖章的读数 → 至多一条通告(读法见文件头)。 */
 export declare function buildEntryModeClampNotice(entry: EntryPermissionMode, sessionId: string | undefined): EngineNotice | undefined;

package/dist/env-facts.d.ts

@@ -34,8 +34,8 @@ export interface SandboxEnvFacts {
 /**
  * 一条 scratchpad 路径能不能被**原样**宣告(core 的渲染上限 {@link MAX_PATH} 之内)—— scratchpad 的**铸造条件**之一。
  * 两个铸点(server 自算 {@link ensureScratchpadDir}、壳供 {@link screenShellScratchpadDir})读这同一只:渲染不下的路径
- * **根本不铸**(不建目录、不进写门豁免、不宣告 —— 宣告是根围栏那个洞的唯一写者,S-842,于是也不开洞)。
- * 🔴 S-842 codex r1 [medium]:删 [ref] 折叠之后,只在宣告那一步丢长路径会留下「建了、豁免了、却不宣告也不开洞」的目录;
+ * **根本不铸**(不建目录、不进写门豁免、不宣告 —— 宣告是根围栏那个洞的唯一写者,[ref],于是也不开洞)。
+ * 🔴 [ref] codex r1 [medium]:删 [ref] 折叠之后,只在宣告那一步丢长路径会留下「建了、豁免了、却不宣告也不开洞」的目录;
  * 规则挪到铸点,四件同有同无。(远程车道的 `/tmp/scratchpad/<sessionId>` 恒在上限内:sessionId ≤ 64,见 prepareSpec。)
  */
 export declare function scratchpadPathRenderable(path: string): boolean;
@@ -79,13 +79,13 @@ export declare function scratchpadDirFor(localDataRoot: string, sessionId: strin
  *  {@link purgeScratchpadDir}(session delete)+ {@link sweepStaleScratchpads}(mtime 周期扫),keyed by the
  *  same scratchpadDirFor convention;接线(E21 DELETE purge + 周期 sweep)在 main.ts 侧(D 组)。 */
 export declare function ensureScratchpadDir(localDataRoot: string, sessionId: string, 
-/** 渲染不下(铸造条件不成立)时的那一行 —— 调用方交日志口(S-842 codex r1:不铸必须说出来,否则「本会话没有 scratchpad」无从排查)。 */
+/** 渲染不下(铸造条件不成立)时的那一行 —— 调用方交日志口([ref] codex r1:不铸必须说出来,否则「本会话没有 scratchpad」无从排查)。 */
 warn: (msg: string, meta?: object) => void): Promise<string | undefined>;
 /** G3([ref] 壳侧承诺③/[ref]③,[ref]§四接单):**壳供** scratchpad 路径的验收门。
  *
  *  壳(cli)vendored getScratchpadDir 算出 per-session scratchpad 路径随 `TaskRequest.scratchpadDir` 发来;
  *  接受后它**优先于** server 自算(ensureScratchpadDir),喂 resolve-spec 的同一单点(envFacts 宣告 ——
- *  core 据它开根围栏的洞,S-842 起是那个洞的唯一写者 —— + fs-write gate exemptDirs)。「没到货引擎忽略 = 无害 additive」。
+ *  core 据它开根围栏的洞,[ref] 起是那个洞的唯一写者 —— + fs-write gate exemptDirs)。「没到货引擎忽略 = 无害 additive」。
  *
  *  信任边界:这是 exemptDirs **放宽**输入,验收 fail-closed(任何拒收形回落自算,不 fault 任务):
  *   - 多租户(requirePrincipal)一律拒——共享 worker 盘上租户自选豁免目录=超范围面;
@@ -109,9 +109,9 @@ export declare function acceptShellScratchpadDir(raw: unknown, opts: {
     warn: (msg: string, meta?: object) => void;
 }): Promise<string | undefined>;
 /**
- * {@link acceptShellScratchpadDir} 的**词法半场**(S-351 拆出):零 I/O、可在请求的任何一点问。
+ * {@link acceptShellScratchpadDir} 的**词法半场**([ref] 拆出):零 I/O、可在请求的任何一点问。
  *
- * 为什么拆:S-351 的前判要在**任何副作用之前**回答「这条请求会把哪个目录当写门豁免域」,而验收门的
+ * 为什么拆:[ref] 的前判要在**任何副作用之前**回答「这条请求会把哪个目录当写门豁免域」,而验收门的
  * 后半场是 `mkdir`(副作用 + I/O)。把判据抄一份到前判处 = 两份验收规则,而两份规则漂移的那天,前判
  * 会替一条**根本不会被接受**的壳供路径拒掉请求(或反过来放过一条会被接受的)。所以规则只有这一份,
  * 两个调用点各取所需:验收门 = 本函数 + mkdir;前判 = 本函数。
@@ -124,7 +124,7 @@ export declare function screenShellScratchpadDir(raw: unknown, opts: {
     warn: (msg: string, meta?: object) => void;
 }): string | undefined;
 /**
- * S-351(core 7.20.0 / [ref])—— **这条请求会不会把任务根放进写门的豁免域里**。
+ * [ref](core 7.20.0 / [ref])—— **这条请求会不会把任务根放进写门的豁免域里**。
  *
  * ## 病形(引擎侧的硬拒,不是判决期的宽严)
  * 写门的豁免域就是 scratchpad(`exemptDirs: [scratchpadDir]`,`task-settings.ts` 的
@@ -142,7 +142,7 @@ export declare function screenShellScratchpadDir(raw: unknown, opts: {
  * canonical 就是承诺一件此刻做不到的事(软链形的真身要到裁决时刻才问 fs,那是写门自己的第二道)。
  *
  * ## 射程(每一条都是「不这样写就会误拒」)
- *  · **只在 cwd 真会被尊重时判**:`cwdHonored` 为假的部署(多租户 / 非 host 车道)把 cwd 直接忽略,
+ *  · **只在 cwd 落在本 worker 盘上时判**:部署形表行 `callerOwnsWorkerDisk` 为假的部署(多租户 / 手不在本 worker 盘上的车道)不把 cwd 落到这块盘上,
  *    它永远不会变成门的根 —— 在那里拒等于凭空多一条 400;
  *  · **豁免域取这条会话可能挂上的每一只**(不是「这一次挂哪只」):server 自算那条恒是候选(有 session
  *    就算得出),壳供 `body.scratchpadDir` **过了词法验收**才追加为候选(过不了的那条永远挂不上,拿它拒
@@ -158,7 +158,8 @@ export declare function scratchpadCoveringTaskRoot(args: {
     localDataRoot: string;
     sessionId: string | undefined;
     requirePrincipal: boolean;
-    cwdHonored: boolean;
+    /** 部署形表行 `callerOwnsWorkerDisk`(调用方递表的答案,本模块不判部署形)。 */
+    callerOwnsWorkerDisk: boolean;
 }): {
     cwd: {
         asSpelled: string;

package/dist/env-facts.js

@@ -119,7 +119,7 @@ export function screenShellScratchpadDir(raw, opts) {
     return canonical;
 }
 export function scratchpadCoveringTaskRoot(args) {
-    if (!args.cwdHonored || !isAbsoluteHostPath(args.cwd))
+    if (!args.callerOwnsWorkerDisk || !isAbsoluteHostPath(args.cwd))
         return undefined;
     const candidates = [];
     const shell = screenShellScratchpadDir(args.shellScratchpadDir, { requirePrincipal: args.requirePrincipal, hostSemanticsLane: true, warn: () => { } });

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

@@ -1,20 +1,20 @@
 /**
- * S-699 / S-713 —— **名单型 env 旋钮**的闭集表(纯叶:零值依赖,任何层都可值引而不成装载环)。
+ * [ref] / [ref] —— **名单型 env 旋钮**的闭集表(纯叶:零值依赖,任何层都可值引而不成装载环)。
  *
  * 解析规则(未设 / 形错拒启 / 姿态 / 生效名单)的全文在 `config.ts` `parseEnvNameAllowlist` 的头注;本表只装**各旋钮自己的**事实,
  * 不是解析规则:
  *  · `example` 进拒句;
  *  · `multiTenant` = `REQUIRE_PRINCIPAL=true` 下名单作不作数 —— **只有服务进程读的旋钮有这一列**(姿态是服务进程的概念):
- *    - `LSP_ENV_ALLOW` ⇒ ignored:host 腿语言服务器在多租户姿态下本来就不起,名单无处作数,设了要说出来(S-699)。
- *    - 三只沙箱名单(e2b / local-docker / k8s 各一只) ⇒ honored:S-713 照录修前语义(任何姿态下都转发),S-715 主会话裁定维持 —— 沙箱 env 是部署方为隔离沙箱显式配的
+ *    - `LSP_ENV_ALLOW` ⇒ ignored:host 腿语言服务器在多租户姿态下本来就不起,名单无处作数,设了要说出来([ref])。
+ *    - 三只沙箱名单(e2b / local-docker / k8s 各一只) ⇒ honored:[ref] 照录修前语义(任何姿态下都转发),[ref] 主会话裁定维持 —— 沙箱 env 是部署方为隔离沙箱显式配的
  *      带外凭据(e2b / docker / k8s 车道本来就是多租户 fleet 的主形),与 LSP 那条「本机子进程」的形不同;多租户下起服说一句。
- *  · `BAKE_ENV_ALLOW`(S-684 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
+ *  · `BAKE_ENV_ALLOW`([ref] 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
  *    不进 {@link describeAllowlistPostures} 的姿态句)。它与服务侧四只旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
  *  · `channel` = 这张名单**交给谁、在谁的减法之上**(闭集两词,解析器按它定「不许点哪些名」):
  *    - `host-put-back`(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)—— 剥后放回形:宿主子进程的 env 先经唯一组合(引擎扣掉本服务自有凭据 + 形状剥),
  *      名单点到的键再从本进程环境**原样**取回叠上去。点到本服务自有凭据名 = 把引擎刚扣下的那枚交回去 ⇒ 起服拒,判官 = 引擎同一只
  *      (`inheritEnvPolicyProblem`,读起服声明;与引擎拒嵌入方白名单同句)。
- *    - `sandbox-grant`(三只沙箱名单)—— 沙箱 env 的唯一来源(沙箱不从本进程继承任何东西),部署方显式交出的带外凭据(S-715 照转发);
+ *    - `sandbox-grant`(三只沙箱名单)—— 沙箱 env 的唯一来源(沙箱不从本进程继承任何东西),部署方显式交出的带外凭据([ref] 照转发);
  *      本列不在「自有凭据」律的射程里,只拒点名名单型旋钮(原文按凭据类)。
  * 表是 `Record<旋钮, …>`:闭集加一只旋钮而不补行 = 编译红;行形随读它的进程定(服务进程 ⇒ 必须写姿态列)。
  *

package/dist/exec-bounds.d.ts

@@ -12,7 +12,7 @@
  * 是它报的那一界。
  *
  * 与 core 远端契约(`ExecStreamOptions.readTimeoutMs`:「缺省也 SHOULD 有活性界,一条命令不得等到环境死」)的对齐:
- * 说了墙钟的命令被墙钟兜住,不会无限等;两界都没说的命令,在有活性界的车道(k8s / e2b)上仍由它兜底。**切断码按触发的那一界**(core 7.52.0 #1795:
+ * 说了墙钟的命令被墙钟兜住,不会无限等;两界都没说的命令,在有活性界的车道(k8s / e2b)上仍由它兜底。**切断码按触发的那一界**(core 7.52.0 [ref]:
  * 两套执行码闭集各有一词):墙钟 ⇒ `timeout`;静默界(调用方的 `readTimeoutMs` 或车道活性界)⇒ `liveness_no_output`,带窗口秒数 `noOutputSec`(车道的界 /
  * 调用方说的静默界,从不是请求的预算)—— 两者解释自己用的是两个数,消费方(core 的 Bash 工具:「no output for N s」对「timed out after N s」)按码分。
  * 静默切断的码、句、秒数只在 {@link buildLivenessCut} 一处铸,六车道同读。
@@ -68,7 +68,7 @@ export declare function firstBoundOf(bounds: CommandBounds): {
 } | undefined;
 /**
  * 🔴 **一次静默切断 —— 唯一铸点**(六条车道 host / e2b / k8s / ssh / adb / local-docker 同读;纯数据,车道用它构造自己那一型的错误):
- * 码恒为 `liveness_no_output`(core 7.52.0 #1795;墙钟切断照旧 `timeout`,不经本函数),句子 = {@link livenessCutMessage},`noOutputSec` = 静默窗口的整秒数
+ * 码恒为 `liveness_no_output`(core 7.52.0 [ref];墙钟切断照旧 `timeout`,不经本函数),句子 = {@link livenessCutMessage},`noOutputSec` = 静默窗口的整秒数
  * (core `ExecutionError` 第五构造参;core 读它时向下取整、不足 1 秒不说 —— 本函数同读:不足 1 秒的窗口不带这一位)。远端流式错误(`RemoteExecutionError`)没有这一位的座,只带码与句。
  */
 export declare function buildLivenessCut(bound: LivenessBound): {