@sema-agent/server 7.128.0 → 7.129.1

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.d.ts

@@ -1,4 +1,4 @@
-import { FileError, ExecutionError, RemoteExecutionError, SchedulerError, type SchedulerCapability, type ScheduledIntent, type SchedulerContext, type ScheduledTaskId, type ScheduledTaskSummary, type ExecutionEnv, type RemoteExecutionEnv, type WorkspaceHandle, type FileInfo, type Result, type SymlinkChain, type BoundFileObject, type OutputChunk, type ExecStreamOptions, type RemoteConnectConfig, type SnapshotId, type SessionToken, type VmLifecycleOptions, type ExecutionEnvFactory, BackgroundShellError, type BackgroundShellCapability, type BackgroundShellId, type BackgroundHardKillOutcome, type BackgroundPoll, type BackgroundSpawnOptions } from "@sema-agent/core";
+import { FileError, type InheritEnvPolicy, ExecutionError, RemoteExecutionError, SchedulerError, type SchedulerCapability, type ScheduledIntent, type SchedulerContext, type ScheduledTaskId, type ScheduledTaskSummary, type ExecutionEnv, type RemoteExecutionEnv, type WorkspaceHandle, type FileInfo, type Result, type SymlinkChain, type BoundFileObject, type OutputChunk, type ExecStreamOptions, type RemoteConnectConfig, type SnapshotId, type SessionToken, type VmLifecycleOptions, type ExecutionEnvFactory, BackgroundShellError, type BackgroundShellCapability, type BackgroundShellId, type BackgroundHardKillOutcome, type BackgroundPoll, type BackgroundSpawnOptions } from "@sema-agent/core";
 /** Options accepted by `ExecutionEnv.exec` (core does not re-export the type; derive it from the seam). */
 type ExecOpts = Parameters<ExecutionEnv["exec"]>[1];
 /** SIGTERM → grace → SIGKILL (no host isolation). 🔴 宽限的**唯一属主**:本 driver 的 `kill` 梯子用它排升级定时器;会话级收敛
@@ -35,18 +35,17 @@ export interface HostEnvConfig {
     homeDir?: string;
     /** Per-command wall-clock bound (ms) when the caller gives none. Default {@link DEFAULT_COMMAND_TIMEOUT_MS}. */
     commandTimeoutMs?: number;
-    /** Shell-child env policy (D1; mirrors core's `NodeExecutionEnv`). Default `"scrub"`: inherit the worker's
-     *  `process.env` but DROP secret-pattern keys (core's `scrubSecretEnv` — `*_KEY`/`*_TOKEN`/`*_SECRET`/`*_PASSWORD`…)
-     *  AND every env name the server's config catalog types as `secret` (`server-secret-env.ts`; 7.99.0 F7 —
-     *  `SERVICE_AUTH_TOKENS` / `APPROVAL_HMAC_KEYS` slip the shape rule)
-     *  so a model-driven shell can't `printenv DEEPSEEK_API_KEY` and exfiltrate orchestrator secrets — keeps PATH/HOME/
-     *  locale/build (low breakage). `"all"` = inherit everything (explicit opt-out, trusted local dev). A `string[]` =
-     *  strict (hermetic) allowlist via `allowlistedEnv` — the repo's one "named keys pass verbatim" predicate, shared with
-     *  the local language server's `LSP_ENV_ALLOW` (S-699; that leg puts named keys back ON TOP of the scrub instead).
-     *  `env`/per-command `options.env` ALWAYS pass through verbatim. */
-    inheritEnv?: "scrub" | "all" | string[];
-    /** @deprecated use {@link inheritEnv}. `true`→`"all"`, `false`→`[]` (hermetic). Ignored if `inheritEnv` is set. */
-    inheritProcessEnv?: boolean;
+    /** Shell-child env policy — core's `InheritEnvPolicy`, read by core's `inheritedHostEnv` (the three words are judged
+     *  in ONE place, the engine; this adapter never reads them). Default `"scrub"`: inherit the worker's `process.env`
+     *  minus credential-shaped names (core's shape rules) minus this deployment's OWN credentials (every env name the
+     *  server's config catalog types as `secret` + the name-list knobs + the effective model entries' `apiKeyEnv` — declared at boot and
+     *  re-declared before every config generation lands, names only ever added, `declareServerWithheldEnv`),
+     *  so a model-driven shell can't `printenv DEEPSEEK_API_KEY` — keeps PATH/HOME/locale/build (low breakage).
+     *  `"all"` = the whole environment MINUS the declared own credentials (the user's own `GH_TOKEN` flows, the engine's
+     *  `SERVICE_AUTH_TOKEN` never does — 7.129.0 / core 7.51.1). A `string[]` = strict (hermetic) allowlist; naming a declared
+     *  own credential is REFUSED at construction (`inheritEnvPolicyProblem`) and again at every spawn. `env`/per-command
+     *  `options.env` are the adapter's explicit grant and ALWAYS pass through verbatim. */
+    inheritEnv?: InheritEnvPolicy;
     /**
      * EXACT persistent working directory (TOC, CC-like): when set, the adapter uses THIS dir verbatim — NO
      * `sema-host-<id>-<rand>` per-task subdir — and **NEVER `rm -rf`s it on {@link destroy}**. It is the
@@ -419,21 +418,19 @@ export declare class RemoteHostExecutionEnv implements RemoteExecutionEnv, Sched
      *  同步 `existsSync` 而不是 await:这是拆除路径上的判据,不该再引入一次异步让出。 */
     private isLingeringMirrorTarget;
     private fsReady;
-    /** Base env (process.env when inheriting) merged with the adapter's secret env, then per-command overrides win. */
-    /** D1 secure default = `"scrub"`: inherit `process.env` minus secret-pattern keys (core's `scrubSecretEnv`, single
-     *  source of the shape rule) minus the config catalog's `secret`-typed names (`scrubServerSecrets`, 7.99.0 F7). `"all"` = full inherit (opt-out); a `string[]` = strict allowlist. Legacy `inheritProcessEnv`
-     *  maps `true`→`"all"` / `false`→`[]`. */
-    private inheritMode;
     /** 每次 spawn 交给子进程的 env(组合 + 剥除披露 + win32 的 SHELL 钉)。`sh` = 调用点刚从 {@link hostShell} 读到的那只(spawn 路径
      *  都在 `shellReady()` 之后):没有已落定的 shell 就到不了这条腿 —— 类型即次序守卫。 */
     private mergeEnv;
     /**
      * 子进程 env 的**唯一组合**,分两层(一条律:**env 组合是纯函数,shell 只属于 spawn**):
-     *  · **组合层**(恒有)—— 继承姿态 + `cfg.env` + perCommand + win32 大小写折叠。**不碰 shell**,所以读面(如 {@link cdPath})任何时候
+     *  · **组合层**(恒有)—— 继承面 + `cfg.env` + perCommand + win32 大小写折叠。继承面 = 本仓唯一组合(`server-secret-env.ts`)交引擎
+     *    `inheritedHostEnv(policy)`:三个继承词(`"all"` / `"scrub"` / `[names]`)只在引擎一处判,本进程自有凭据名(起服声明)任何词都不交 ——
+     *    本类不再有三臂字面(7.129.0 / core 7.51.1;修前 `all` 是 `{ ...process.env }` 零剥除)。**不碰 shell**,所以读面(如 {@link cdPath})任何时候
      *    都能读,不依赖 shell 是否已落定。
-     *  · **spawn 层**(`spawnShell` 在场)—— 这一次是真要交给子进程:scrub 腿经 `hostSubprocessEnv` 记剥除(`spawnShell` 缺席 ⇒ 只读组合,
+     *  · **spawn 层**(`spawnShell` 在场)—— 这一次是真要交给子进程:经 `hostSubprocessEnv` 记剥除(`spawnShell` 缺席 ⇒ 只读组合 `composeHostSubprocessEnv`,
      *    不计数:一次没发生的 spawn 不进剥除账),win32 上把 `SHELL` 钉到已解析的 Git Bash({@link pinHostShell},在大小写折叠**之前**)。
      * 披露与钉同一个开关(`spawnShell`)—— 「真 spawn」只有一种说法,不再有 `disclose` 与钉各自一个布尔。
+     * 引擎对点到自有凭据名的白名单在这里**抛**(spawn 时的拒;构造器已先问过同一只判)—— 子进程不起,拒句带名。
      */
     private childEnv;
     private fileError;

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

@@ -6,11 +6,12 @@ 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";
-import { FileError, NodeExecutionEnv, ExecutionError, RemoteExecutionError, RollingTailBuffer, markTruncated, SchedulerError, BackgroundShellError, } from "@sema-agent/core";
-import { allowlistedEnv, composeHostSubprocessEnv, hostSubprocessEnv } from "../server-secret-env.js";
+import { FileError, NodeExecutionEnv, inheritEnvPolicyProblem, ExecutionError, RemoteExecutionError, RollingTailBuffer, markTruncated, SchedulerError, BackgroundShellError, } from "@sema-agent/core";
+import { composeHostSubprocessEnv, hostSubprocessEnv } from "../server-secret-env.js";
 import { trackEphemeralHostWorkspace, untrackEphemeralHostWorkspace } from "./host-workspace-registry.js";
 const PROVIDER = "host";
 const DEFAULT_COMMAND_TIMEOUT_MS = 30 * 60_000;
@@ -122,10 +123,18 @@ export class RemoteHostExecutionEnv {
             this.workspaceDir = path.resolve(base, `sema-host-${sanitizeId(id)}-${suffix}`);
             this.persistent = false;
         }
+        const inheritEnvProblem = inheritEnvPolicyProblem(config.inheritEnv);
+        if (inheritEnvProblem !== undefined)
+            throw new Error(`RemoteHostExecutionEnv: ${inheritEnvProblem}`);
+        if ("inheritProcessEnv" in config) {
+            throw new Error('RemoteHostExecutionEnv: inheritProcessEnv was retired in 7.129.0 and is refused rather than read — write inheritEnv: "all" (for true) or inheritEnv: [] (for false)');
+        }
         this.cfg = {
             ...config,
             commandTimeoutMs: config.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
         };
+        if (Array.isArray(config.inheritEnv))
+            this.cfg.inheritEnv = [...config.inheritEnv];
         this.cwd = this.workspaceDir;
         this.homeDir = config.homeDir;
         this.handle = { sandboxId: this.workspaceDir, provider: PROVIDER, mountPath: this.workspaceDir };
@@ -802,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;
@@ -897,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); });
@@ -906,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)
@@ -1310,33 +1320,13 @@ export class RemoteHostExecutionEnv {
             return { ok: false, error: new FileError("unknown", `failed to create host workspace: ${errMsg(e)}`, this.resolve(p), asError(e)) };
         }
     }
-    inheritMode() {
-        if (this.cfg.inheritEnv !== undefined)
-            return this.cfg.inheritEnv;
-        if (this.cfg.inheritProcessEnv === false)
-            return [];
-        if (this.cfg.inheritProcessEnv === true)
-            return "all";
-        return "scrub";
-    }
     mergeEnv(perCommand, sh) {
         return this.childEnv(perCommand, sh);
     }
     childEnv(perCommand, spawnShell) {
-        const disclose = spawnShell !== undefined;
-        const mode = this.inheritMode();
-        let base;
-        if (mode === "all")
-            base = { ...process.env };
-        else if (Array.isArray(mode)) {
-            base = allowlistedEnv(mode, process.env);
-        }
-        else if (!disclose) {
-            base = composeHostSubprocessEnv([]);
-        }
-        else {
-            base = hostSubprocessEnv({ site: "server.remote-env-host.inherit-scrub", allow: [] });
-        }
+        const base = spawnShell !== undefined
+            ? hostSubprocessEnv({ site: "server.remote-env-host.inherit-scrub", policy: this.cfg.inheritEnv, allow: [] })
+            : composeHostSubprocessEnv({ policy: this.cfg.inheritEnv, allow: [] });
         if (this.cfg.env)
             Object.assign(base, this.cfg.env);
         if (perCommand)

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;