@sema-agent/server 7.129.0 → 7.129.1

package/MIGRATION.md

@@ -7,6 +7,28 @@
 > ⚠️ 完整清单在仓库根 `CHANGELOG.md`——它**不随 npm tarball 出包**(本文件随包)。看完整迁移窗的
 > 权威姿势是源码 tag diff:`git diff v<旧>..v<新>`(每版都推 `v<版本>` tag);npm 包页也镜像 CHANGELOG。
 
+## 7.129.1 —— k8s / e2b 车道:带超时的命令不再被静默切断(行为修复)· 新旋钮 `K8S_LIVENESS_MS` · 两只活性旋钮非正值拒启
+
+1. **一条命令的界只来自调用方说出口的那些**(零 DDL):墙钟 `timeout`、流式面自己的 `readTimeoutMs`;两样都没说时才由车道活性界(无输出满 N 毫秒即切,
+   缺省 120 s)兜底。界从调用开始算、覆盖全程(含 e2b 建命令那一段;那一段另受 e2b SDK 自己的建命令握手约束,缺省 60 s,比命令的界早时先由它切)。
+   引擎的 Bash 工具每一发都带超时,所以 Bash 调用从此不再被活性界切断(安静的长构建跑到它的超时)。`timedOut` / `timeoutSec` 仍不全是跑满:e2b 上建命令
+   卡住被那只 60 s 握手切掉、或沙箱中途死掉时,这一发仍以 `timeout` 码回来,Bash 照旧报「Command timed out after <N>s」(独立的码属于引擎的码表)。
+   活性切断的句子三车道一句,点名旋钮;错误码仍是引擎的 `timeout`。
+   - **新旋钮** `K8S_LIVENESS_MS`(ms,`E2B_LIVENESS_MS` 的孪生:同一只解析器;缺席 ⇒ 120 s;只在 `REMOTE_EXEC=k8s` 时求值)。两只旋钮都**只管没有显式超时的
+     命令** —— 此前为了让带超时的长构建跑完而调大 `E2B_LIVENESS_MS` 的部署,可以调回缺省(调大只会放宽引擎探针与文件读写的挂死护栏)。
+   - 🔴 **两只活性旋钮的值必须是正数**:非数、`0`、负数 ⇒ **拒启**,拒句点名旋钮(`E2B_LIVENESS_MS=0` 此前照收,结果是每条 e2b 命令都建不起来)。
+     升级前删掉这类设置或改成正数。嵌入方直接构造 k8s / e2b 执行环境时传非正的 `livenessMs` ⇒ 构造即抛。
+   - **受伤方**:依赖「120 s 无输出即杀」兜底带超时调用的部署 —— 带超时的挂死命令要等到它自己的超时(Bash 不传参数时 120 s,与改前同;显式最长到引擎上限)。
+     出路:给命令更短的超时;不带超时的调用照旧受活性界,可调小两只旋钮。
+   - **受伤方(调大过引擎的 `BASH_DEFAULT_TIMEOUT_MS` 的部署)**:每一发不传超时参数的 Bash 都带着这个调大了的超时,从此失去 120 s 的挂死护栏 —— 挂死的命令
+     要等满它,且没有本服务的旋钮能补回。出路:把 `BASH_DEFAULT_TIMEOUT_MS` 调回,或给需要护栏的命令显式的短超时。
+   - **读面**:e2b 车道的墙钟切断、活性切断与建命令期限到点此前报 `unknown`,现在报 `timeout`(e2b 上把这类切断当 `unknown` 读的消费方改读 `timeout`);
+     k8s 流式 exec 此前忽略 `timeout`,现在照它切。
+   - **e2b 建命令被切之后才到的句柄**:一到即被杀、输出丢弃;在**看见**它不在跑之前(供应商答了杀,或 `wait()` 以成功 / 非零退出结算 —— 流先断了、连接期限到点不算看见,进程哪怕已死也继续持有)该环境的挂起(`suspendVM`)照旧以
+     `command_in_flight` 拒。杀被供应商拒时记一行 warn `e2b_abandoned_start_kill_failed`(沙箱 id / 进程号 / 拒因类名),继续等看见退出;杀被拒且退出看不见的环境从此不能挂起、VM 计费到任务结束(fail-closed),出路 = 让命令退出或结束任务。建命令一直悬着(供应商既不交回
+     句柄、也不报失败)、或杀被拒而进程不退出的那一种,挂起会一直拒(说不出那条命令没在跑,不快照在跑的命令);任务结束销毁环境不受影响。建命令**以失败
+     告终**(含 SDK 自己的 60 s 握手到点)时在途保护即撤,与 7.129.0 同 —— 供应商若其实已起了那个进程、只是回执丢了,它不受这道保护。
+
 ## 7.129.0 —— 引擎 7.51.2 提货 · 会话规则一种文法与列改名(🔴 先停旧副本再起新)· 卡词换与存量一次性改写 · 读拒三席热生效 · 直连不跟重定向 · 两只告警标签改名
 
 1. **引擎 7.51.2(精确钉;7.51.0 的硬破坏 + 7.51.1 / 7.51.2 两补丁)**:本服务随引擎的硬破坏在下列第 2–13 条;引擎自己的收窄直接落到部署上的见第 14 条。DDL 只有第 2 条的一处列改名(SQL 后端,由起服一次性迁移做,不用手跑);第 3 条的存量改写同样由起服一次性迁移做。

package/USAGE.md

@@ -2315,6 +2315,31 @@ k8s 车道每条 run 一只新 pod(pod 寿命 = 泄漏护栏,不跨 run 复用)
 
 自检是**读数,不是边界**:起服之后加入的节点在下一次起服读到;射程里的三面(所在节点、宿主 DNAT、CNI 不执行)读不出,不在闭集里。
 
+### 9.3f 沙箱车道的命令静默切断:显式超时优先(`K8S_LIVENESS_MS`,7.129.1 起)
+
+k8s 与 e2b 两条沙箱车道各有一只**活性界**:一条命令无输出满这么久(缺省 120 s)即判挂死、切断。一条命令由它的调用方**说出口**的界约束,活性界只在调用方什么都没说时兜底:
+
+- **带显式超时 ⇒ 只受这个超时约束**,无输出多久都不切。引擎的 Bash 工具每一发都带超时(`timeout` 参数;不传时引擎给缺省值 120 s,上限 600 s)—— 所以 Bash 调用一律走这一条。
+  引擎的缺省值可由进程 env `BASH_DEFAULT_TIMEOUT_MS` 调大:调大它就是调大每一发不传参数的 Bash 的挂死护栏(挂死的命令要等满它),本服务没有旋钮能再收紧 —— 要护栏就调回它,或给命令显式的短超时。
+  安静的长构建(Gradle / R8 一段几分钟不出声)给命令一个够长的 `timeout` 即可;超出引擎上限的工作用 `run_in_background`。
+- 流式调用自己说了静默界(`readTimeoutMs`)⇒ 照它。
+- 两样都没说(引擎自己的 git 探针、文件读写这类)⇒ 车道活性界兜底,它是这条命令唯一的挂死护栏。
+
+界从调用开始算,覆盖命令全程 —— 含 e2b 供应商建命令那一段(命令还没起跑,自然没有输出):建命令卡住按这条命令最早的那一界切(说了超时按超时,没说界按活性界)。
+e2b SDK 自己的建命令握手另有一界(缺省 60 s),比命令的界早时先由它切:超时或活性界长于 60 s 的命令(含缺省 120 s 的活性界)建命令卡住在约 60 s 被切 —— 缓冲 exec(Bash 走的这一面)报 `timeout`,流式 exec 报 `connect_failed`。
+
+| 旋钮 | 车道 | 缺省 | 说明 |
+|---|---|---|---|
+| `K8S_LIVENESS_MS` | `REMOTE_EXEC=k8s` | 缺席 ⇒ 120000(ms) | 7.129.1 起;与 `E2B_LIVENESS_MS` 同一只解析器:必须是正数,非数 / `0` / 负数拒启;只在本车道被选中时求值 |
+| `E2B_LIVENESS_MS` | `REMOTE_EXEC=e2b` | 缺席 ⇒ 120000(ms) | 同上(7.129.1 起 `0` / 负数拒启;此前照收,结果是每条命令建不起来) |
+
+**有显式超时时这两只旋钮不参与**:调大不会让一条带超时的 Bash 跑得更久,调小也不会更早切它 —— 要更早切就给命令更短的超时。
+
+切断时报的是真正触发的那一界:活性切断的句子是 `no output for <N> s — cut off by the exec liveness bound (set K8S_LIVENESS_MS or give the command an explicit timeout)`
+(e2b 点名 `E2B_LIVENESS_MS`);错误码沿用引擎的 `timeout`(引擎码表把墙钟与活性两种超界归同一词,靠句子区分)。Bash 工具结果里的 `timedOut: true` / `timeoutSec: N`
+不再是活性切断的投影,但仍不全是「跑满了 N 秒」:e2b 上建命令卡住被那只 60 s 握手切掉、或沙箱中途死掉时,这一发仍以 `timeout` 码回来,Bash 照旧报
+「Command timed out after <N>s」(把它们与超时分开的独立码属于引擎的码表)。host 车道没有活性界(命令只受调用方的超时,缓冲 exec 不带超时时受 `HOST_COMMAND_TIMEOUT_MS`)。
+
 ### 9.4 auto 模式(`permissionMode:"auto"`):武装三态、本地 org deny、自查(与 core 的意图武装式合修)
 
 **背景**:此前引擎只在「组织授予」(web-admin 解出的 per-principal `runtimeCaps.autoMode === true`)时武装

package/dist/boot/execution-env.js

@@ -222,6 +222,7 @@ export function createExecutionEnv(ctx) {
             ...(config.remoteExec.runtimeClass != null ? { runtimeClass: config.remoteExec.runtimeClass } : {}),
             ...(config.remoteExec.mountPath ? { mountPath: config.remoteExec.mountPath } : {}),
             ...(config.remoteExec.timeoutMs != null ? { timeoutMs: config.remoteExec.timeoutMs } : {}),
+            ...(config.remoteExec.livenessMs != null ? { livenessMs: config.remoteExec.livenessMs } : {}),
             dataTimeoutMs: workspaceSnapshotTimeoutOf(config.remoteExec),
             ...(config.remoteExec.memory ? { memory: config.remoteExec.memory } : {}),
             ...(config.remoteExec.cpu ? { cpu: config.remoteExec.cpu } : {}),

package/dist/config-catalog.js

@@ -5,6 +5,7 @@ import { CENTER_CREDENTIAL_RENEW_LEAD_DEFAULT_MS, CENTER_CREDENTIAL_RENEW_LEAD_M
 import { SANDBOX_IPV6_DEFAULT, SANDBOX_IPV6_WORDS } from "./sandbox-egress-policy.js";
 import { WORKSPACE_CACHE_DEFAULT, WORKSPACE_CACHE_MOUNT_DEFAULT, WORKSPACE_CACHE_SIZE_DEFAULT, WORKSPACE_CACHE_WORDS } from "./workspace-cache.js";
 import { WORKSPACE_PERSIST_DEFAULT, WORKSPACE_PERSIST_WORDS, WORKSPACE_SNAPSHOT_KEEP_DEFAULT, WORKSPACE_SNAPSHOT_KEEP_RANGE, WORKSPACE_SNAPSHOT_TIMEOUT_MS_DEFAULT, WORKSPACE_SNAPSHOT_TIMEOUT_MS_RANGE } from "./workspace-space.js";
+import { LIVENESS_MS_DEFAULT } from "./exec-bounds.js";
 import { THINKING_FORMATS } from "./model-compat.js";
 import { AUTO_MODE_CLASSIFIER_TIMEOUT_BOUNDS, CENTER_BASE_URL_RULE, CONFIG_PROVIDER_WORDS, DRAIN_SECOND_SIGNAL_MIN_GAP_BOUNDS, DRAIN_SECOND_SIGNAL_MIN_GAP_DEFAULT_MS, FIRST_BYTE_TIMEOUT_BOUNDS, FLEET_LEASE_OUTAGE_MAX_DEFAULT_MS, RESILIENCE_DEFAULTS, TASK_WRITE_FACE_ESCALATIONS } from "./config-types.js";
 import { webSearchProviderFromEnv, WEB_SEARCH_PROVIDERS } from "./plugins/web-search.js";
@@ -30,6 +31,8 @@ const RESTART_SLICE_SET = {
 };
 export const CATALOG_RESTART_SLICES = Object.keys(RESTART_SLICE_SET);
 const r = (name, domain, type, semantics, opts = {}) => ({ name, domain, type, semantics, ...opts });
+const LIVENESS_KNOB_SEMANTICS = (lane) => `${lane} 命令静默活性上限(ms):无输出满这么久即判挂死切断,只管没有显式超时的命令 —— 带显式超时的命令只受那个超时约束(安静的长构建给命令一个显式超时即可,不必调大本值)`;
+const LIVENESS_KNOB_DEFAULT_NOTE = `缺席 ⇒ adapter 默认 ${LIVENESS_MS_DEFAULT / 1000}s`;
 const cLimits = (path, over = {}) => ({
     domain: "limits",
     path,
@@ -138,7 +141,7 @@ export const CONFIG_CATALOG = [
     r("E2B_BG_DEFAULT_TIMEOUT_SEC", "orchestration", "number", "e2b 后台 shell 缺省超时(秒)", { staticDefault: "300" }),
     r("E2B_BG_MAX_CONCURRENT", "orchestration", "number", "e2b 后台 shell 并发帽", { staticDefault: "8" }),
     r("E2B_BG_MAX_TIMEOUT_SEC", "orchestration", "number", "e2b 后台 shell 超时上限(秒)", { staticDefault: "1800" }),
-    r("E2B_LIVENESS_MS", "orchestration", "number", "e2b 单命令静默活性上限(长静默构建请调大;后台+轮询仍是首选)", { derivedDefaultNote: "缺席 ⇒ adapter 默认 120s" }),
+    r("E2B_LIVENESS_MS", "orchestration", "number", LIVENESS_KNOB_SEMANTICS("e2b"), { derivedDefaultNote: LIVENESS_KNOB_DEFAULT_NOTE }),
     r("E2B_MOUNT_PATH", "orchestration", "path", "e2b 工作区根(resume 用当前值,改前先 drain 挂起任务)"),
     r("E2B_ORPHAN_RECLAIM", "orchestration", "boolean", "崩溃遗留沙盒回收腿(boot 一次+周期;判据保守,拿不准恒不杀)", { staticDefault: "true", danger: BILL }),
     r("E2B_SANDBOX_ENV", "orchestration", "secret", "转发进 e2b 沙箱的本进程 env 点名表(NAME,NAME;点到的键从 worker env 原样取,值不进 spec/center/事件日志;与 LSP_ENV_ALLOW / DOCKER_SANDBOX_ENV 同一只解析器与「点名放行」谓词:形错 / 点名名单型旋钮拒启且不回显值;本进程环境里没有的名按序号 warn、不转发;只在本车道被选中时求值;原文按凭据类对待:只回在场位、不进任何子进程)", { danger: SEC }),
@@ -191,6 +194,7 @@ export const CONFIG_CATALOG = [
     r("K8S_CA_CERT_B64", "orchestration", "opaque", "k8s API CA 证书(base64;registry secrets 无换行约束)", { danger: SEC }),
     r("K8S_CPU", "orchestration", "string", "沙箱 pod CPU 限额(profile 数据)"),
     r("K8S_INSECURE_TLS", "orchestration", "boolean", "跳过 k8s API TLS 校验", { staticDefault: "false", danger: SEC }),
+    r("K8S_LIVENESS_MS", "orchestration", "number", LIVENESS_KNOB_SEMANTICS("k8s"), { derivedDefaultNote: LIVENESS_KNOB_DEFAULT_NOTE }),
     r("K8S_MEMORY", "orchestration", "string", "沙箱 pod 内存限额(2Gi 默认曾被真 OOM)"),
     r("K8S_MOUNT_PATH", "orchestration", "path", "k8s 工作区挂载路径"),
     r("K8S_NAMESPACE", "orchestration", "string", "沙箱 pod namespace"),

package/dist/config-types.d.ts

@@ -898,6 +898,9 @@ export interface ServiceConfigFlat {
         runtimeClass?: string;
         mountPath?: string;
         timeoutMs?: number;
+        /** `K8S_LIVENESS_MS` — the lane's liveness bound (ms; the `E2B_LIVENESS_MS` twin, same parser; absent ⇒ the adapter's
+         *  default 120 s): cuts a command silent for this long ONLY when its caller stated no timeout (`exec-bounds.ts`). */
+        livenessMs?: number;
         /** Resource-profile knobs: sandbox pod limits (adapter defaults: 2Gi / 1 cpu). */
         memory?: string;
         cpu?: string;

package/dist/config.js

@@ -27,6 +27,7 @@ import { bakeOperatorPrincipalsRefusal, bakeRunnerCredentialRefusal, centerIdent
 import { declaredSemaConfigDir } from "./sema-config-dir.js";
 import { lkgPathOverrideOf } from "./config-lkg.js";
 import { K8S_WORKSPACE_MOUNT_DEFAULT, WORKSPACE_PERSIST_DEFAULT, WORKSPACE_PERSIST_WORDS, WORKSPACE_SNAPSHOT_KEEP_DEFAULT, WORKSPACE_SNAPSHOT_KEEP_RANGE, WORKSPACE_SNAPSHOT_TIMEOUT_MS_DEFAULT, WORKSPACE_SNAPSHOT_TIMEOUT_MS_RANGE, parseWorkspaceSnapshotExclude } from "./workspace-space.js";
+import { laneLivenessOf } from "./exec-bounds.js";
 import { SANDBOX_IPV6_DEFAULT, SANDBOX_IPV6_WORDS } from "./sandbox-egress-policy.js";
 import { WORKSPACE_CACHE_DEFAULT, WORKSPACE_CACHE_MOUNT_DEFAULT, WORKSPACE_CACHE_SIZE_DEFAULT, WORKSPACE_CACHE_WORDS, isK8sQuantity, mountsOverlap } from "./workspace-cache.js";
 import { REMOTE_EXEC_PROVIDER_WORDS, executionLaneOf, executionLaneRequiredRefusal, isSingleMachineDefaultLane, laneRequiredEnv } from "./execution-lane-caps.js";
@@ -333,6 +334,10 @@ function optNumEnvStrict(name) {
         return undefined;
     return parseNumOrFail(name, raw);
 }
+function livenessMsEnv(name) {
+    const n = optNumEnvStrict(name);
+    return n === undefined ? undefined : laneLivenessOf(n, name).ms;
+}
 function parseDeviceEnrollTokenTtlEnv() {
     const raw = process.env.DEVICE_ENROLL_TOKEN_TTL_SEC;
     if (raw === undefined || raw === "")
@@ -1836,7 +1841,7 @@ function parseOrchestrationDomain(ctx) {
                 apiKey: process.env.E2B_API_KEY,
                 ...(process.env.E2B_TEMPLATE ? { template: process.env.E2B_TEMPLATE } : {}),
                 ...((n) => (n !== undefined ? { timeoutMs: n } : {}))(optNumEnvStrict("E2B_TIMEOUT_MS")),
-                ...((n) => (n !== undefined ? { livenessMs: n } : {}))(optNumEnvStrict("E2B_LIVENESS_MS")),
+                ...((n) => (n !== undefined ? { livenessMs: n } : {}))(livenessMsEnv("E2B_LIVENESS_MS")),
                 ...(process.env.E2B_ALLOW_NET ? { allowInternetAccess: boolEnv("E2B_ALLOW_NET", true) } : {}),
                 ...((names) => (names !== undefined ? { sandboxEnv: allowlistedEnv(names, process.env) } : {}))(parseEnvNameAllowlist("E2B_SANDBOX_ENV", singleUserTurnkey)),
                 ...(process.env.E2B_MOUNT_PATH ? { mountPath: process.env.E2B_MOUNT_PATH } : {}),
@@ -1855,6 +1860,7 @@ function parseOrchestrationDomain(ctx) {
                         ...(process.env.K8S_RUNTIME_CLASS != null ? { runtimeClass: process.env.K8S_RUNTIME_CLASS } : {}),
                         ...(process.env.K8S_MOUNT_PATH ? { mountPath: process.env.K8S_MOUNT_PATH } : {}),
                         ...((n) => (n !== undefined ? { timeoutMs: n } : {}))(optNumEnvStrict("K8S_TIMEOUT_MS")),
+                        ...((n) => (n !== undefined ? { livenessMs: n } : {}))(livenessMsEnv("K8S_LIVENESS_MS")),
                         ...(process.env.K8S_MEMORY ? { memory: process.env.K8S_MEMORY } : {}),
                         ...(process.env.K8S_CPU ? { cpu: process.env.K8S_CPU } : {}),
                         sandboxIpv6: enumEnv("K8S_SANDBOX_IPV6", SANDBOX_IPV6_DEFAULT, SANDBOX_IPV6_WORDS),

package/dist/exec-bounds.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 执行车道上「什么约束一条命令」的**唯一一条律**(host / e2b / k8s 三只 adapter 同读这一只;纯叶,零依赖):
+ *
+ *   命令由调用方**说出口**的界约束 —— 墙钟 `timeout`(buffered 与流式两面)与 / 或它自己的静默界 `readTimeoutMs`
+ *   (流式面)。调用方**两样都没说**时,才由车道自己的活性界兜底:无输出满这么久即判挂死(k8s `K8S_LIVENESS_MS` /
+ *   e2b `E2B_LIVENESS_MS`,缺省 {@link LIVENESS_MS_DEFAULT};host 没有这一界)—— 那时它是这条命令唯一的挂死护栏。
+ *   切断时报的是**真正触发的那一界**(活性切断的句子只在 {@link livenessCutMessage} 铸)。
+ *
+ * 为什么「说了墙钟就不再活性切断」:墙钟本身就是挂死护栏(它到点必切),而调用方说出一个墙钟,就是在说「这条命令可以跑
+ * 这么久」—— 安静的长构建(Gradle / R8 一段几分钟不出声)正是这种命令。两界并存时,活性界会先于墙钟切掉一条按约正在跑的
+ * 命令,而调用方(core 的 Bash 工具)只知道自己说过的墙钟,便把这次切断报成「跑满了 N 秒」。两界互斥之后,一次切断只可能
+ * 是它报的那一界。
+ *
+ * 与 core 远端契约(`ExecStreamOptions.readTimeoutMs`:「缺省也 SHOULD 有活性界,一条命令不得等到环境死」)的对齐:
+ * 说了墙钟的命令被墙钟兜住,不会无限等;两界都没说的命令仍有车道活性界。切断码沿用 core 的 `timeout`(core 远端码表
+ * 把墙钟与活性两种超界都归这一词);两者靠句子区分 —— 独立的活性码属于 core 的码表。
+ *
+ * 不在本律里的界(adapter 自己的上限,不是调用方说的话,不关活性界):k8s 文件读写的数据上限 `dataTimeoutMs`、e2b 交给
+ * 供应商的沙箱寿命上限。adapter 自己的整段数据搬运(k8s 快照 tar 上 / 下)天生静默,它们**自己说**一个墙钟(数据上限),
+ * 落在本律的第一支。
+ */
+/** 车道活性界的缺省(ms)—— k8s / e2b 两只 adapter 与配置目录的「缺席 ⇒ 默认」说法同读这一只。 */
+export declare const LIVENESS_MS_DEFAULT = 120000;
+/** 有活性界的车道各自的旋钮名(闭集;切断句点名它,运维据此知道调哪一只)。 */
+export type LivenessKnob = "K8S_LIVENESS_MS" | "E2B_LIVENESS_MS";
+/** 一条车道自己的活性界:k8s / e2b 有,host 没有(传 `undefined`)。只经 {@link laneLivenessOf} 铸(值已判过)。 */
+export interface LaneLiveness {
+    readonly ms: number;
+    readonly knob: LivenessKnob;
+}
+/**
+ * 车道活性界的唯一铸点与唯一判据:值必须是有限正数(ms),否则**拒**(抛,句子点名旋钮)。活性界是不说界的命令唯一的挂死护栏 ——
+ * `0` / 负数会把它整个撤掉(那条命令从此无界),非数无从计时。boot 的旋钮解析(`E2B_LIVENESS_MS` / `K8S_LIVENESS_MS`)与 adapter
+ * 构造(嵌入方直接传 `livenessMs`)都经这一只判,一个判据、一句拒词。
+ */
+export declare function laneLivenessOf(ms: number, knob: LivenessKnob): LaneLiveness;
+/** 本条命令的静默界:调用方说的(`readTimeoutMs`),或车道兜底的。 */
+export type LivenessBound = {
+    readonly ms: number;
+    readonly setBy: "caller";
+} | {
+    readonly ms: number;
+    readonly setBy: "lane";
+    readonly knob: LivenessKnob;
+};
+/** 一条命令最终受的界:墙钟(调用方说的)与静默界,各自可缺。 */
+export interface CommandBounds {
+    readonly wallMs: number | undefined;
+    readonly liveness: LivenessBound | undefined;
+}
+/** 调用方说出口的界(ms)。`timeoutMs` = 墙钟;`readTimeoutMs` = 它自己的静默界。 */
+export interface StatedBounds {
+    readonly timeoutMs?: number | undefined;
+    readonly readTimeoutMs?: number | undefined;
+}
+/** 本律的唯一实现(见文件头注)。 */
+export declare function commandBoundsOf(stated: StatedBounds, lane: LaneLiveness | undefined): CommandBounds;
+/**
+ * 一条**还没出过一个字节**的命令最早被哪一界切:墙钟与静默界里较早的那只(都从调用开始算)。供应商建命令那一段(命令还没起跑,
+ * 自然也没有输出)就受它约束 —— 说了墙钟的命令不会被车道活性界在建命令时切掉;没说界的命令建命令卡住按活性界切 —— 但供应商自己的建命令期限
+ * 先到就先切(e2b SDK 的 60 s 握手:到点报的是供应商那一界,不是本模块的任何一只)。两只都缺 ⇒ 无界(只剩供应商自己的界)。
+ */
+export declare function firstBoundOf(bounds: CommandBounds): {
+    readonly ms: number;
+    readonly cut: "wall" | LivenessBound;
+} | undefined;
+/** 活性切断的句子 —— 三车道唯一铸点(车道兜底的界点名旋钮与出路;调用方自己说的界点名那一参数)。 */
+export declare function livenessCutMessage(bound: LivenessBound): string;
+//# sourceMappingURL=exec-bounds.d.ts.map

package/dist/exec-bounds.js

@@ -0,0 +1,37 @@
+export const LIVENESS_MS_DEFAULT = 120_000;
+export function laneLivenessOf(ms, knob) {
+    if (!(Number.isFinite(ms) && ms > 0)) {
+        throw new Error(`${knob}=${ms} must be a positive number of milliseconds — it is the only hang guard of a command whose caller states no timeout, and a zero, negative or non-numeric value would remove it`);
+    }
+    return { ms, knob };
+}
+const said = (ms) => (ms !== undefined && Number.isFinite(ms) && ms > 0 ? ms : undefined);
+export function commandBoundsOf(stated, lane) {
+    const wallMs = said(stated.timeoutMs);
+    const idleMs = said(stated.readTimeoutMs);
+    if (idleMs !== undefined)
+        return { wallMs, liveness: { ms: idleMs, setBy: "caller" } };
+    if (wallMs !== undefined || lane === undefined)
+        return { wallMs, liveness: undefined };
+    return { wallMs, liveness: { ms: lane.ms, setBy: "lane", knob: lane.knob } };
+}
+export function firstBoundOf(bounds) {
+    const { wallMs, liveness } = bounds;
+    if (liveness !== undefined && (wallMs === undefined || liveness.ms <= wallMs))
+        return { ms: liveness.ms, cut: liveness };
+    return wallMs === undefined ? undefined : { ms: wallMs, cut: "wall" };
+}
+function spoken(ms) {
+    if (ms < 1000)
+        return `${ms} ms`;
+    return ms % 1000 === 0 ? `${ms / 1000} s` : `${(ms / 1000).toFixed(1)} s`;
+}
+export function livenessCutMessage(bound) {
+    switch (bound.setBy) {
+        case "lane":
+            return `no output for ${spoken(bound.ms)} — cut off by the exec liveness bound (set ${bound.knob} or give the command an explicit timeout)`;
+        case "caller":
+            return `no output for ${spoken(bound.ms)} — cut off by the command's own idle bound (readTimeoutMs)`;
+    }
+}
+//# sourceMappingURL=exec-bounds.js.map

package/dist/plugins/remote-env-e2b.d.ts

@@ -71,8 +71,9 @@ export interface RemoteContainerEnvConfig extends RemoteEnvObservers {
      *  isRunning/files.*. A provider hang is surfaced as a typed retryable `RemoteExecutionError("timeout")` after
      *  this, instead of pinning the worker for the sandbox lifetime. Default {@link DEFAULT_RPC_TIMEOUT_MS}. */
     rpcTimeoutMs?: number;
-    /** 🔴 (hang class-fix) Idle/liveness bound (ms) for a command (exec/execStream): max time with NO output
-     *  and not yet complete = suspected hang. Also bounds the command-creation RPC. Default {@link DEFAULT_LIVENESS_MS}. */
+    /** 🔴 (hang class-fix) The lane's idle/liveness bound (ms; env `E2B_LIVENESS_MS`): max time with NO output and not yet
+     *  complete = suspected hang — cuts a running command ONLY when its caller stated neither a wall-clock (`timeout`) nor its own
+     *  idle bound (`readTimeoutMs`); the rule: `exec-bounds.ts` (creation included). Positive only (`laneLivenessOf`). Default `LIVENESS_MS_DEFAULT`. */
     livenessMs?: number;
     /** 🔴 Wall-clock for data-transfer/provisioning RPCs (large file io, snapshot suspend/resume,
      *  create/connect) — wider than {@link rpcTimeoutMs} so a legit multi-minute transfer is not killed. Default
@@ -105,6 +106,8 @@ export declare class RemoteContainerExecutionEnv implements RemoteExecutionEnv,
     readonly cdPath: "unknown";
     private readonly cfg;
     private readonly sandboxApi;
+    /** This lane's own liveness bound — what {@link commandBoundsOf} falls back to when a command's caller stated no bound. */
+    private readonly laneLiveness;
     private sbx?;
     /** 🔴 BL-31 keep-alive — the E2B sandbox lifetime is hard-capped (≈1h, {@link E2B_SANDBOX_MAX_MS}), but a long
      *  leader/repair run legitimately exceeds it. This interval RE-extends the sandbox (`setTimeout(timeoutMs)` resets
@@ -287,23 +290,42 @@ export declare class RemoteContainerExecutionEnv implements RemoteExecutionEnv,
      * the adapter NEVER blind-retries). A caller AbortSignal still aborts independently (op surfaces it / "aborted").
      */
     private rpc;
+    /**
+     * A command start that already returned to its caller (its creation deadline fired, or it failed): a handle the provider
+     * hands over LATER is killed — the caller was told the command was cut, so it must not run on. The rule for the in-flight
+     * count this start holds: it is released **once, and only when the command is confirmed not running** (council #4: never
+     * snapshot a running command). Confirmations: the provider answered `kill()` (`true` killed / `false` no such process);
+     * the handle's one `wait()` reports the process exited (a result, or `CommandExitError` for a non-zero exit). Not
+     * confirmations: a refused `kill()` (logged; the exit is still awaited), a `wait()` that ends without an exit (the
+     * connection deadline, a lost stream — the process may still run). With neither the count stays held and `suspendVM`
+     * keeps refusing `command_in_flight` — the same arm as a start that never settles. No start promise (the op never ran)
+     * ⇒ released now. A failed start is released at once too, as in 7.129.0 — and that one is NOT a confirmation: there is
+     * no handle to kill or wait on, and a start whose reply was lost (the SDK's own 60 s handshake) may have spawned the
+     * process. Closing it means classifying the start failure (provider refused ⇒ not started; lost reply ⇒ held) — open,
+     * not done here.
+     */
+    private settleAbandonedStart;
     /**
      * Per-command wall-clock for the E2B SDK (seconds→ms). 🔴 This is a PHYSICAL CAP, NOT the hang
      * detector. The old code returned `this.cfg.timeoutMs` (the sandbox lifetime) when no `timeout` was given AND
      * had no liveness check → a hung command waited the WHOLE lifetime (~30 min, the original hang bug). The fix is
      * NOT to shorten this cap (that would spuriously kill a long-but-progressing `npm ci`) — it's to add a LIVENESS
      * bound ({@link cfg.livenessMs}) in exec/execStream that catches a *zero-progress* command in ~livenessMs,
-     * independent of this cap. So: explicit caller `timeout` wins; else the lifetime is the cap (a command can't
-     * outlive its VM) but hang detection no longer depends on it.
+     * independent of this cap. So: explicit caller `timeout` wins — and is then the command's bound (the liveness bound
+     * stays out, `exec-bounds.ts`); else the lifetime is the cap (a command can't outlive its VM) and the liveness bound
+     * is the hang detector.
      */
     private commandTimeoutMs;
     /**
-     * 🔴 Liveness for the buffered exec WAIT phase. `handle.wait()` is a long-poll with no read timeout —
+     * 🔴 Bounds for the buffered exec WAIT phase. `handle.wait()` is a long-poll with no read timeout —
      * a command that hangs DURING execution (not creation) would otherwise wait the E2B command timeout (= the
-     * lifetime when none is set, the original hang bug). Races wait() against an idle check: if no stdout/stderr for
-     * `livenessMs`, the command is hung → kill + typed retryable "timeout". `lastProgress()` is bumped by the
-     * stdout/stderr callbacks, so a slow-but-PROGRESSING command (long `npm ci`) is never killed. (execStream has
-     * its own chunk-driven idle timer; this is the buffered-exec analogue.)
+     * lifetime when none is set, the original hang bug). With a `liveness` bound (the caller stated no `timeout` —
+     * `exec-bounds.ts`) it races wait() against an idle check: no stdout/stderr for `liveness.ms` ⇒ hung → kill + typed
+     * retryable "timeout" with the shared cut sentence. `lastProgress()` is bumped by the stdout/stderr callbacks, so a
+     * slow-but-PROGRESSING command (long `npm ci`) is never killed. Both cuts reject with an `ExecutionError` carrying
+     * its real code (exec returns it as-is) — a `RemoteExecutionError` here would reach {@link execError}'s text match
+     * and land as `unknown`. The rejection is armed BEFORE the kill: the kill rejects `wait()` too, and the race must
+     * see the bound, not the kill. (execStream has its own chunk-driven idle timer; this is the buffered-exec analogue.)
      */
     private waitWithLiveness;
     /** Lazily provision the VM on first use: a task that never touches the hand pays zero cost.

package/dist/plugins/remote-env-e2b.js

@@ -3,13 +3,13 @@ import { Sandbox, CommandExitError, FileType } from "e2b";
 import { FileError, ExecutionError, RemoteExecutionError, RollingTailBuffer, markTruncated, } from "@sema-agent/core";
 import { fileErrorFromExec } from "./remote-env-file-error.js";
 import { numEnvOr, runSymlinkChain, shellQuote } from "./remote-shell.js";
+import { commandBoundsOf, firstBoundOf, laneLivenessOf, livenessCutMessage, LIVENESS_MS_DEFAULT } from "../exec-bounds.js";
 import { BackgroundShellManager } from "./background-shell-support.js";
 const PROVIDER = "e2b";
 const DEFAULT_MOUNT_PATH = "/home/user";
 const DEFAULT_TIMEOUT_MS = 5 * 60_000;
 const E2B_SANDBOX_MAX_MS = numEnvOr("E2B_SANDBOX_MAX_MS", 3_600_000, 60_000);
 const DEFAULT_RPC_TIMEOUT_MS = 60_000;
-const DEFAULT_LIVENESS_MS = 120_000;
 const DEFAULT_DATA_TIMEOUT_MS = 5 * 60_000;
 const E2B_BG_MAX_CONCURRENT = numEnvOr("E2B_BG_MAX_CONCURRENT", 8, 1);
 const E2B_BG_DEFAULT_TIMEOUT_SEC = numEnvOr("E2B_BG_DEFAULT_TIMEOUT_SEC", 300, 1);
@@ -22,6 +22,7 @@ export class RemoteContainerExecutionEnv {
     cdPath = "unknown";
     cfg;
     sandboxApi;
+    laneLiveness;
     sbx;
     keepAlive;
     handle;
@@ -36,9 +37,10 @@ export class RemoteContainerExecutionEnv {
             timeoutMs: Math.min(config.timeoutMs ?? DEFAULT_TIMEOUT_MS, E2B_SANDBOX_MAX_MS),
             allowInternetAccess: config.allowInternetAccess ?? true,
             rpcTimeoutMs: config.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS,
-            livenessMs: config.livenessMs ?? DEFAULT_LIVENESS_MS,
+            livenessMs: config.livenessMs ?? LIVENESS_MS_DEFAULT,
             dataTimeoutMs: config.dataTimeoutMs ?? DEFAULT_DATA_TIMEOUT_MS,
         };
+        this.laneLiveness = laneLivenessOf(this.cfg.livenessMs, "E2B_LIVENESS_MS");
         this.cwd = this.cfg.mountPath;
         this.homeDir = config.homeDir;
         this.sandboxApi = deps.sandboxApi ?? Sandbox;
@@ -255,9 +257,14 @@ export class RemoteContainerExecutionEnv {
             s.total += b.length;
         };
         let lastProgress = Date.now();
+        const startedAt = lastProgress;
+        const bounds = commandBoundsOf({ timeoutMs: options?.timeout != null ? options.timeout * 1000 : undefined }, this.laneLiveness);
+        const first = firstBoundOf(bounds);
         let handle;
+        let starting;
+        let startCut = false;
         try {
-            handle = await this.rpc("commands.run", () => sbx.commands.run(command, {
+            handle = await this.rpc("commands.run", () => (starting = sbx.commands.run(command, {
                 background: true,
                 cwd: this.resolve(options?.cwd ?? this.cwd),
                 ...(options?.env ? { envs: options.env } : {}),
@@ -265,6 +272,8 @@ export class RemoteContainerExecutionEnv {
                     ? Math.max(this.commandTimeoutMs(options?.timeout), (E2B_BG_MAX_TIMEOUT_SEC + E2B_BG_PROVIDER_BACKSTOP_PAD_SEC) * 1000)
                     : this.commandTimeoutMs(options?.timeout),
                 onStdout: (d) => {
+                    if (startCut)
+                        return;
                     if (tee)
                         teePush(tee.stdout, d);
                     if (!detached) {
@@ -273,6 +282,8 @@ export class RemoteContainerExecutionEnv {
                     }
                 },
                 onStderr: (d) => {
+                    if (startCut)
+                        return;
                     if (tee)
                         teePush(tee.stderr, d);
                     if (!detached) {
@@ -280,11 +291,13 @@ export class RemoteContainerExecutionEnv {
                         options?.onStderr?.(d);
                     }
                 },
-            }), options?.abortSignal, this.cfg.livenessMs);
+            })), options?.abortSignal, first.ms);
         }
         catch (e) {
-            this.activeCommands--;
-            return { ok: false, error: this.execError(e, options?.abortSignal) };
+            startCut = true;
+            this.settleAbandonedStart(starting);
+            const cut = e instanceof RemoteExecutionError && e.code === "timeout" && !options?.abortSignal?.aborted;
+            return { ok: false, error: cut ? new ExecutionError("timeout", boundCutMessage(first)) : this.execError(e, options?.abortSignal) };
         }
         const onAbort = () => { if (!detached)
             void handle.kill().catch(() => { }); };
@@ -333,7 +346,8 @@ export class RemoteContainerExecutionEnv {
             const fg = this.waitWithLiveness(handle, () => lastProgress, {
                 waitP,
                 disarmed: () => detached,
-                ...(tee ? { wallMs: this.commandTimeoutMs(options?.timeout) } : {}),
+                ...(tee ? { wall: { totalMs: this.commandTimeoutMs(options?.timeout), leftMs: Math.max(0, this.commandTimeoutMs(options?.timeout) - (Date.now() - startedAt)) } } : {}),
+                liveness: bounds.liveness,
             });
             const winner = await (detachedP ? Promise.race([fg, detachedP]) : fg);
             if (winner === "detached") {
@@ -385,6 +399,9 @@ export class RemoteContainerExecutionEnv {
         };
         let bytes = 0;
         const cap = options?.maxOutputBytes;
+        const bounds = commandBoundsOf({ timeoutMs: options?.timeout != null ? options.timeout * 1000 : undefined, readTimeoutMs: options?.readTimeoutMs }, this.laneLiveness);
+        const liveness = bounds.liveness;
+        const first = firstBoundOf(bounds);
         const push = (type, data) => {
             if (finished)
                 return;
@@ -394,18 +411,22 @@ export class RemoteContainerExecutionEnv {
         };
         this.activeCommands++;
         let handle;
+        let starting;
         try {
-            handle = await this.rpc("commands.run", () => sbx.commands.run(command, {
+            handle = await this.rpc("commands.run", () => (starting = sbx.commands.run(command, {
                 background: true,
                 cwd: this.resolve(options?.cwd ?? this.cwd),
                 ...(options?.env ? { envs: options.env } : {}),
                 timeoutMs: this.commandTimeoutMs(options?.timeout),
                 onStdout: (d) => push("stdout", d),
                 onStderr: (d) => push("stderr", d),
-            }), options?.signal, this.cfg.livenessMs);
+            })), options?.signal, first.ms);
         }
         catch (e) {
-            this.activeCommands--;
+            finished = true;
+            this.settleAbandonedStart(starting);
+            if (e instanceof RemoteExecutionError && e.code === "timeout" && !options?.signal?.aborted)
+                throw new RemoteExecutionError("timeout", boundCutMessage(first), e);
             throw this.remoteError(e, "connect_failed");
         }
         handle
@@ -424,7 +445,7 @@ export class RemoteContainerExecutionEnv {
                 exitCode = e.exitCode;
             }
             else {
-                failure = this.remoteError(e, "unknown");
+                failure = this.remoteError(e, providerTimedOut(e) ? "timeout" : "unknown");
             }
             finished = true;
             signalReady();
@@ -465,13 +486,14 @@ export class RemoteContainerExecutionEnv {
                 const next = new Promise((resolve) => {
                     wake = resolve;
                 });
-                const idleMs = options?.readTimeoutMs ?? this.cfg.livenessMs;
                 let timer;
-                const idle = new Promise((_, reject) => {
-                    timer = setTimeout(() => reject(new RemoteExecutionError("timeout", `execStream idle > ${idleMs}ms (provider hang / unreachable sandbox)`)), idleMs);
-                });
+                const idle = liveness === undefined
+                    ? undefined
+                    : new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new RemoteExecutionError("timeout", livenessCutMessage(liveness))), liveness.ms);
+                    });
                 try {
-                    await Promise.race([next, idle]);
+                    await (idle === undefined ? next : Promise.race([next, idle]));
                 }
                 catch (e) {
                     finished = true;
@@ -794,36 +816,59 @@ export class RemoteContainerExecutionEnv {
             combined?.dispose();
         }
     }
+    settleAbandonedStart(starting) {
+        let held = true;
+        const release = () => {
+            if (!held)
+                return;
+            held = false;
+            this.activeCommands--;
+        };
+        if (starting === undefined)
+            return release();
+        void starting.then((late) => {
+            late.wait().then(release, (e) => {
+                if (e instanceof CommandExitError)
+                    release();
+            });
+            late.kill().then(release, (e) => {
+                this.cfg.logger?.warn?.("e2b_abandoned_start_kill_failed", { sandboxId: this.sbx?.sandboxId, pid: late.pid, error: e instanceof Error ? e.name : typeof e });
+            });
+        }, release);
+    }
     commandTimeoutMs(timeoutSec) {
         return timeoutSec != null ? timeoutSec * 1000 : this.cfg.timeoutMs;
     }
     async waitWithLiveness(handle, lastProgress, opts) {
         let timer;
         let wallTimer;
+        const liveness = opts?.liveness;
         const idle = new Promise((_, reject) => {
-            const arm = () => {
+            const arm = (bound) => {
                 timer = setTimeout(() => {
                     if (opts?.disarmed?.())
                         return;
                     const idleFor = Date.now() - lastProgress();
-                    if (idleFor >= this.cfg.livenessMs) {
+                    if (idleFor >= bound.ms) {
+                        reject(new ExecutionError("timeout", livenessCutMessage(bound)));
                         void handle.kill().catch(() => { });
                         this.cfg.metrics?.inc("remote_env_exec_idle_timeout_total", { provider: PROVIDER });
-                        reject(new RemoteExecutionError("timeout", `exec idle > ${this.cfg.livenessMs}ms (provider hang / unreachable sandbox)`));
                     }
                     else {
-                        arm();
+                        arm(bound);
                     }
-                }, Math.max(this.cfg.livenessMs - (Date.now() - lastProgress()), 0));
+                }, Math.max(bound.ms - (Date.now() - lastProgress()), 0));
             };
-            arm();
-            if (opts?.wallMs != null) {
+            if (liveness !== undefined)
+                arm(liveness);
+            if (opts?.wall !== undefined) {
+                const wall = opts.wall;
                 wallTimer = setTimeout(() => {
                     if (opts.disarmed?.())
                         return;
+                    reject(new ExecutionError("timeout", boundCutMessage({ ms: wall.totalMs, cut: "wall" })));
                     void handle.kill().catch(() => { });
-                    reject(new RemoteExecutionError("timeout", `exec exceeded ${opts.wallMs}ms`));
-                }, opts.wallMs);
+                }, wall.leftMs);
             }
         });
         try {
@@ -905,7 +950,7 @@ export class RemoteContainerExecutionEnv {
         const name = e?.name;
         if (abortSignal?.aborted || name === "AbortError")
             return new ExecutionError("aborted", msg);
-        if (name === "TimeoutError" || /timeout|timed out/i.test(msg))
+        if (providerTimedOut(e))
             return new ExecutionError("timeout", msg);
         return new ExecutionError("unknown", msg, e instanceof Error ? e : undefined);
     }
@@ -924,6 +969,12 @@ export function e2bExecutionEnvFactory(config, deps) {
 function errMsg(e) {
     return e instanceof Error ? e.message : String(e);
 }
+function boundCutMessage(first) {
+    return first.cut === "wall" ? `exec exceeded ${first.ms}ms` : livenessCutMessage(first.cut);
+}
+function providerTimedOut(e) {
+    return e?.name === "TimeoutError" || /timeout|timed out/i.test(errMsg(e));
+}
 function anySignal(signals) {
     const ctor = AbortSignal;
     if (typeof ctor.any === "function")

package/dist/plugins/remote-env-host.js

@@ -6,6 +6,7 @@ import { randomBytes } from "node:crypto";
 import { openSync, closeSync, readSync, statSync, truncateSync, unlinkSync, mkdirSync, rmdirSync, mkdtempSync, existsSync, realpathSync, accessSync, constants as FS_CONST } from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 import { armPipeDestroyGrace, numEnvOr, SYMLINK_CHAIN_MAX_HOPS } from "./remote-shell.js";
+import { commandBoundsOf, livenessCutMessage } from "../exec-bounds.js";
 import { hostBackgroundShellEnabled, hostExecSpoolEnabled } from "../config.js";
 import { IS_WIN32, resolveHostShell, hostShell, pinHostShell, spawnGroupOptions, killTreeHard, killTreeSoft, hardKillGroupNow, collapseWin32EnvKeys, adoptHostForegroundChild } from "./host-platform.js";
 import { BackgroundShellManager, seedMemStream, feedMemStream, drainMemStream } from "./background-shell-support.js";
@@ -810,8 +811,9 @@ export class RemoteHostExecutionEnv {
         if (!ready.ok)
             throw new RemoteExecutionError("connect_failed", ready.error.message, ready.error);
         const cwd = this.resolve(options?.cwd ?? this.cwd);
-        const timeoutMs = options?.timeout != null ? options.timeout * 1000 : undefined;
-        const idleMs = options?.readTimeoutMs;
+        const bounds = commandBoundsOf({ timeoutMs: options?.timeout != null ? options.timeout * 1000 : undefined, readTimeoutMs: options?.readTimeoutMs }, undefined);
+        const timeoutMs = bounds.wallMs;
+        const liveness = bounds.liveness;
         const cap = options?.maxOutputBytes;
         const queue = [];
         let finished = false;
@@ -905,7 +907,7 @@ export class RemoteHostExecutionEnv {
                     throw failure;
                 if (finished)
                     break;
-                const waitMs = idleMs != null ? Math.max(1, idleMs - (Date.now() - lastChunk)) : 30_000;
+                const waitMs = liveness !== undefined ? Math.max(1, liveness.ms - (Date.now() - lastChunk)) : 30_000;
                 let waitTimer;
                 try {
                     await new Promise((r) => { wake = r; waitTimer = setTimeout(r, waitMs); });
@@ -914,10 +916,10 @@ export class RemoteHostExecutionEnv {
                     if (waitTimer !== undefined)
                         clearTimeout(waitTimer);
                 }
-                if (idleMs != null && !finished && Date.now() - lastChunk >= idleMs) {
+                if (liveness !== undefined && !finished && Date.now() - lastChunk >= liveness.ms) {
                     finished = true;
                     kill();
-                    throw new RemoteExecutionError("timeout", `execStream idle > ${idleMs}ms (command hang)`);
+                    throw new RemoteExecutionError("timeout", livenessCutMessage(liveness));
                 }
             }
             while (queue.length)

package/dist/plugins/remote-env-k8s.d.ts

@@ -38,7 +38,9 @@ export interface K8sEnvConfig {
     readyTimeoutMs?: number;
     /** Control-plane RPC wall-clock (pod create/get/delete). */
     rpcTimeoutMs?: number;
-    /** Zero-progress liveness bound for commands (no output AND not finished ⇒ hang). */
+    /** The lane's zero-progress liveness bound (env `K8S_LIVENESS_MS`; default {@link LIVENESS_MS_DEFAULT}): a command that
+     *  produces no output for this long and has not finished is cut as a hang — ONLY when its caller stated neither a wall-clock
+     *  (`timeout`) nor its own idle bound (`readTimeoutMs`); a stated bound replaces it (the rule: `exec-bounds.ts`). */
     livenessMs?: number;
     /** The ONE data bound (`WORKSPACE_SNAPSHOT_TIMEOUT_MS`; default = `WORKSPACE_SNAPSHOT_TIMEOUT_MS_DEFAULT`, owned by
      *  `workspace-space.ts`): the snapshot upload's and restore's wall-clock, the deadline this replica's commits write into
@@ -257,6 +259,8 @@ export declare class RemoteK8sExecutionEnv implements RemoteExecutionEnv, Backgr
     /** The known occupant's incarnation (`undefined` = this run has no known occupant: a delegated child, an unread session, a direct construction) — the
      *  ownership mark of every snapshot id this env mints, both lanes ({@link mintSnapshotId}); the space lane's partition is the same reading. */
     private readonly occupantIncarnation;
+    /** This lane's own liveness bound — what {@link commandBoundsOf} falls back to when a command's caller stated no bound. */
+    private readonly laneLiveness;
     /** This env's space lane (resolved once from the policy + the occupant's incarnation; see {@link SpaceLane}). */
     private readonly spaceLane;
     /** `workspace_space_unavailable` is said once per env. */
@@ -551,8 +555,10 @@ export declare class RemoteK8sExecutionEnv implements RemoteExecutionEnv, Backgr
     private execUrl;
     /**
      * Run a command over the exec WebSocket. Frames: byte0=channel (1 stdout / 2 stderr / 3 status JSON with the
-     * REAL exit code). Bounds: caller wall-clock (explicit `timeout`) + zero-progress liveness (`livenessMs`) —
-     * a socket killed by either does NOT kill the remote process (disposable-pod posture, see header).
+     * REAL exit code). Bounds = {@link commandBoundsOf} over what the caller stated (`timeoutMs` wall / `readTimeoutMs` idle)
+     * and this lane's liveness — the one rule, decided here and nowhere else on this lane — plus the adapter's own ceiling
+     * `capMs` (a data bound, not a statement: it never turns the liveness bound off). A socket killed by any bound does NOT
+     * kill the remote process (disposable-pod posture, see header).
      */
     private runExec;
     exec(command: string, options?: ExecOpts): Promise<Result<{
@@ -654,7 +660,9 @@ export declare class RemoteK8sExecutionEnv implements RemoteExecutionEnv, Backgr
         suffix?: string;
         abortSignal?: AbortSignal;
     }): Promise<Result<string, FileError>>;
-    /** exec with the data-transfer bound (large reads/writes legitimately run longer than a control op). */
+    /** exec with the data-transfer ceiling (large reads/writes legitimately run longer than a control op). The engine states no
+     *  bound for a file op, so the lane liveness bound stays on (a stalled transfer is cut by it); the data bound is this
+     *  adapter's own ceiling (`capMs`), not a statement. */
     private execData;
     /** 本腿只定工作目录(缺省 cwd 规则 + 绝对化);串的形状归 {@link buildCwdEnvCommand} / {@link createCwdGuardedCall}(S-410:cwd 不可用 ⇒ 命令不跑;
      *  车PL:buffered `exec` 上守卫触发 ⇒ `spawn_error`)。 */

package/dist/plugins/remote-env-k8s.js

@@ -11,6 +11,7 @@ import { spaceCommitAlive } from "../workspace-space-commit.js";
 import { incarnationLogPrefix, redactIncarnations } from "../session-incarnation.js";
 import { WORKSPACE_CACHE_SPACE_LABEL, workspaceCacheClaimOf, workspaceCacheEnv } from "../workspace-cache.js";
 import { recordFailOpen } from "../observability/fail-open.js";
+import { commandBoundsOf, laneLivenessOf, livenessCutMessage, LIVENESS_MS_DEFAULT } from "../exec-bounds.js";
 import { SANDBOX_IPV6_DEFAULT, sandboxEgressGaps, sandboxPodSysctls } from "../sandbox-egress-policy.js";
 import { FileError, ExecutionError, RemoteExecutionError, withRetry, RollingTailBuffer, markTruncated, } from "@sema-agent/core";
 import { fileErrorFromExec, classifyFsStderr } from "./remote-env-file-error.js";
@@ -141,6 +142,7 @@ export class RemoteK8sExecutionEnv {
     cfg;
     deps;
     occupantIncarnation;
+    laneLiveness;
     spaceLane;
     spaceUnavailableSaid = false;
     unreadableOccupantSaid = false;
@@ -161,7 +163,7 @@ export class RemoteK8sExecutionEnv {
             timeoutMs: config.timeoutMs ?? 30 * 60_000,
             readyTimeoutMs: config.readyTimeoutMs ?? 120_000,
             rpcTimeoutMs: config.rpcTimeoutMs ?? 30_000,
-            livenessMs: config.livenessMs ?? 120_000,
+            livenessMs: config.livenessMs ?? LIVENESS_MS_DEFAULT,
             dataTimeoutMs: dataTimeoutMsOf(config),
             cpu: config.cpu ?? "1",
             memory: config.memory ?? "2Gi",
@@ -176,6 +178,7 @@ export class RemoteK8sExecutionEnv {
         this.cwd = this.cfg.mountPath;
         this.homeDir = config.homeDir;
         this.deps = deps ?? {};
+        this.laneLiveness = laneLivenessOf(this.cfg.livenessMs, "K8S_LIVENESS_MS");
         const occupant = occupantKeyOf(config.spaceOccupant);
         this.occupantIncarnation = "incarnation" in occupant ? occupant.incarnation : undefined;
         this.spaceLane = spaceLaneOf(config.s3Snapshot?.space, config.spaceOccupant);
@@ -875,7 +878,7 @@ export class RemoteK8sExecutionEnv {
         const excludes = (this.cfg.snapshotExclude ?? []).map((item) => ` --exclude=${shellQuote(`./${item}`)}`).join("");
         const cmd = `tar czf ${tmp}${excludes} -C ${shellQuote(this.cfg.mountPath)} . && curl -fsS -X PUT -T ${tmp} ${shellQuote(url)}; ` +
             `rc=$?; rm -f ${tmp}; exit $rc`;
-        const r = await this.runExec(cmd, { timeoutMs: this.cfg.dataTimeoutMs, livenessMs: 0 });
+        const r = await this.runExec(cmd, { timeoutMs: this.cfg.dataTimeoutMs });
         if (!r.ok)
             return { ok: false, error: new RemoteExecutionError("connect_failed", `workspace snapshot upload failed: ${this.redactUrl(r.error.message, url)}`, r.error) };
         if (r.value.exitCode !== 0)
@@ -911,7 +914,7 @@ export class RemoteK8sExecutionEnv {
             const c = await this.provision(abortSignal);
             if (!c.ok)
                 return c;
-            const r = await this.runExec(cmd, { timeoutMs: this.cfg.dataTimeoutMs, livenessMs: 0 });
+            const r = await this.runExec(cmd, { timeoutMs: this.cfg.dataTimeoutMs });
             const failure = !r.ok
                 ? { cls: r.error.code === "timeout" ? "timeout" : "transport", detail: `workspace snapshot restore failed: ${this.redactUrl(r.error.message, url)}`, cause: r.error }
                 : r.value.exitCode !== 0
@@ -1127,20 +1130,22 @@ export class RemoteK8sExecutionEnv {
                 }
                 resolvePromise(r);
             };
-            const wallMs = opts?.timeoutMs;
-            const wallTimer = wallMs ? setTimeout(() => finish({ ok: false, error: new ExecutionError("timeout", `command exceeded ${wallMs}ms`) }), wallMs) : undefined;
+            const bounds = commandBoundsOf({ timeoutMs: opts?.timeoutMs, readTimeoutMs: opts?.readTimeoutMs }, this.laneLiveness);
+            const capMs = opts?.capMs;
+            const wallMs = bounds.wallMs === undefined ? capMs : capMs === undefined ? bounds.wallMs : Math.min(bounds.wallMs, capMs);
+            const wallTimer = wallMs !== undefined ? setTimeout(() => finish({ ok: false, error: new ExecutionError("timeout", `command exceeded ${wallMs}ms`) }), wallMs) : undefined;
             let livenessTimer;
-            const livenessMs = opts?.livenessMs ?? this.cfg.livenessMs;
+            const liveness = bounds.liveness;
             const armLiveness = () => {
-                if (livenessMs <= 0)
+                if (liveness === undefined)
                     return;
                 clearTimeout(livenessTimer);
                 const idle = Date.now() - lastProgress;
-                if (idle >= livenessMs) {
-                    finish({ ok: false, error: new ExecutionError("timeout", `no output for ${idle}ms (exec liveness) — suspected hang`) });
+                if (idle >= liveness.ms) {
+                    finish({ ok: false, error: new ExecutionError("timeout", livenessCutMessage(liveness)) });
                     return;
                 }
-                livenessTimer = setTimeout(armLiveness, livenessMs - idle);
+                livenessTimer = setTimeout(armLiveness, liveness.ms - idle);
             };
             armLiveness();
             const onAbort = () => finish({ ok: false, error: new ExecutionError("aborted", "command aborted") });
@@ -1343,22 +1348,20 @@ export class RemoteK8sExecutionEnv {
             wake = undefined;
             w?.();
         };
-        let lastChunk = Date.now();
-        const idleMs = options?.readTimeoutMs ?? this.cfg.livenessMs;
         const cap = options?.maxOutputBytes;
         let bytes = 0;
         const ac = new AbortController();
         const signal = options?.signal ? AbortSignal.any([options.signal, ac.signal]) : ac.signal;
         const done = this.runExec(buildCwdEnvCommand(command, this.workingDirOf(options?.cwd), options?.env, "raw").command, {
             signal,
+            timeoutMs: options?.timeout != null ? options.timeout * 1000 : undefined,
+            readTimeoutMs: options?.readTimeoutMs,
             boundOutput: true,
             onStdout: (d) => {
-                lastChunk = Date.now();
                 queue.push({ type: "stdout", data: d });
                 signalReady();
             },
             onStderr: (d) => {
-                lastChunk = Date.now();
                 queue.push({ type: "stderr", data: d });
                 signalReady();
             },
@@ -1395,21 +1398,9 @@ export class RemoteK8sExecutionEnv {
                     throw failure;
                 if (finished)
                     break;
-                const waitMs = Math.max(1, idleMs - (Date.now() - lastChunk));
-                let waitTimer;
-                try {
-                    await new Promise((r) => {
-                        wake = r;
-                        waitTimer = setTimeout(r, Math.min(waitMs, 30_000));
-                    });
-                }
-                finally {
-                    if (waitTimer !== undefined)
-                        clearTimeout(waitTimer);
-                }
-                if (!finished && Date.now() - lastChunk >= idleMs) {
-                    throw new RemoteExecutionError("timeout", `execStream idle > ${idleMs}ms (suspected hang)`);
-                }
+                await new Promise((r) => {
+                    wake = r;
+                });
             }
             while (queue.length)
                 yield queue.shift();
@@ -1428,7 +1419,7 @@ export class RemoteK8sExecutionEnv {
     }
     makeBgDriver() {
         const self = this;
-        const bgExec = (script, boundOutput) => self.runExec(script, { timeoutMs: self.cfg.rpcTimeoutMs, livenessMs: self.cfg.livenessMs, boundOutput });
+        const bgExec = (script, boundOutput) => self.runExec(script, { timeoutMs: self.cfg.rpcTimeoutMs, boundOutput });
         return {
             async launch(command, options, ctx) {
                 const conn = await self.ensureConnected();
@@ -1628,7 +1619,7 @@ export class RemoteK8sExecutionEnv {
         const c = await this.ensureConnected();
         if (!c.ok)
             return c;
-        return this.runExec(command, { signal: abortSignal, timeoutMs: this.cfg.dataTimeoutMs });
+        return this.runExec(command, { signal: abortSignal, capMs: this.cfg.dataTimeoutMs });
     }
     workingDirOf(cwd) {
         const dir = cwd ?? this.cwd;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.129.0",
+  "version": "7.129.1",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",