@sema-agent/server 7.146.0 → 7.148.0

package/dist/plugins/remote-env-local-docker.d.ts

@@ -1,11 +1,37 @@
 import { spawn } from "node:child_process";
 import { type LaneHomeConfig } from "../lane-home-probe.js";
+import { type LaneLogger } from "./remote-shell.js";
 import { FileError, ExecutionError, RemoteExecutionError, type ExecutionEnv, type RemoteExecutionEnv, type WorkspaceHandle, type FileInfo, type Result, type SymlinkChain, type OutputChunk, type ExecStreamOptions, type RemoteConnectConfig, type SnapshotId, type SessionToken, type VmLifecycleOptions, type ExecutionEnvFactory, type ExecutionEnvCapabilities } from "@sema-agent/core";
 import { type SandboxReadFloorKnob } from "../execution-lane-caps.js";
 import { type SandboxReadFloor } from "./sandbox-read-floor.js";
 import type { WorkspaceFill, WorkspaceFillOf } from "./workspace-fill.js";
+import type { LocalDockerCapacity, RegistryReading } from "./local-docker-capacity.js";
+import type { LocalDockerReapPort } from "./local-docker-reaper.js";
 /** Options accepted by `ExecutionEnv.exec` (core does not re-export the type; derive it from the seam). */
 type ExecOpts = Parameters<ExecutionEnv["exec"]>[1];
+/**
+ * 一只环境对它那只身份的容器负的责(闭集,穷举;一个事实一格 —— 环境的 `custody`):
+ *  · `none` —— 什么都不持有;
+ *  · `held` —— 持有这只实例(起成的 / 附着的 / 正要 `docker start` 的;先持有再动它):`docker exec` / 读地板中继指它的 id,收场删它;
+ *  · `doomed` —— 决定删、删除还没被证实:永不附着;下一次连接先按 id 再删(证实才往下走),收场再删;
+ *  · `doomed-unknown` —— 一次起动的结局没定(没回 id、事后问这只名也读不出):下一次读出的本 worker 那只就是它(⇒ 删);收场再问一次。
+ * 收场之后仍欠着删除(`doomed` / `doomed-unknown`)⇒ 工厂把它交给这只身份的下一只环境({@link LocalDockerEnvConfig.leftover}):删除被证实之前,谁都不附着那只容器。
+ */
+export type LocalDockerCustody = {
+    readonly kind: "none";
+} | {
+    readonly kind: "held";
+    readonly id: string;
+} | {
+    readonly kind: "doomed";
+    readonly id: string;
+} | {
+    readonly kind: "doomed-unknown";
+};
+/** 欠着的删除(工厂交接的那一格)。 */
+export type LocalDockerLeftover = Extract<LocalDockerCustody, {
+    readonly kind: "doomed" | "doomed-unknown";
+}>;
 /** Construction config for {@link RemoteLocalDockerExecutionEnv}. */
 export interface LocalDockerEnvConfig extends LaneHomeConfig {
     /**
@@ -55,13 +81,23 @@ export interface LocalDockerEnvConfig extends LaneHomeConfig {
     commandTimeoutMs?: number;
     /** Wall-clock bound (ms) for a docker control op (run/rm/inspect/cp). Default {@link DEFAULT_CONTROL_TIMEOUT_MS}. */
     controlTimeoutMs?: number;
-    /** Stable id mixed into the container NAME (e.g. the sessionId). A random suffix is always appended so two
-     *  envs sharing an id never collide. Default = a random id. */
+    /** 这只环境持有的工作区的身份:容器名由它与 {@link workerLabel} 确定({@link localDockerContainerNameOf}),同一 worker 上同一身份 = 同一只容器
+     *  (连接时在跑就附着)。工厂恒给 `taskId ?? sessionId`;直接构造不给 ⇒ 随机身份(一只不与任何人共用的工作区)。 */
     id?: string;
+    /** 同一身份的上一只环境收场时没能证实删掉的那只({@link LocalDockerLeftover};工厂交接,直接构造不给):本环境从它开始负责 —— 先删它,永不附着它。 */
+    leftover?: LocalDockerLeftover;
     /** `SANDBOX_READ_FLOOR`(keep | off;缺席 ⇒ keep):本容器守不守读拒表的字节地板 = 读地板模块服务本车道 ∧ 本键不是 off(`sandbox-read-floor.ts`)。 */
     sandboxReadFloor?: SandboxReadFloorKnob;
     /** 恢复点的填充座(`workspace-fill.ts`;工厂按 run 装配):容器新建之后、交给本环境之前,经本适配器自己的 `docker exec` 往工作区里放内容。缺席 ⇒ 不放。 */
     workspaceFill?: WorkspaceFill;
+    /** 本 worker 的身份标签(`sema.local-docker=<worker>`,`localDockerWorkerLabelOf(数据根)` 铸;装配在 `boot/execution-env.ts`)。**恒打**:本 worker 起的每只容器都带它,
+     *  与上限开没开无关 —— 上限只是它的读者(读数按它过滤),所以上限随时可开,开之前起的容器照计。 */
+    workerLabel: string;
+    /** 车道容器帽的闸(`local-docker-capacity.ts`;一进程一只,装配在 `boot/execution-env.ts`,同一工厂铸的 env 共用)。在场 ⇒ 每次 `docker run` 先经它准入;
+     *  缺席(`DOCKER_MAX_CONTAINERS` 0)⇒ 不准入、不读 daemon。 */
+    capacity?: LocalDockerCapacity;
+    /** 运维日志座(起服装配递本服务的 logger):暂存写「已有目标的权限位没带过去」那一行经它(缺席 ⇒ 暂存编排自建一只,见 `remote-shell.ts` `StagedWriteLane.logger`)。 */
+    logger?: LaneLogger;
 }
 /** Inject `spawn` for tests (a fake docker CLI). Defaults to node's child_process spawn. */
 export interface LocalDockerEnvDeps {
@@ -86,10 +122,18 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
     readonly withheldEnv: readonly [];
     private readonly cfg;
     private readonly spawnFn;
-    /** Stable container NAME (also our handle id). Created on connect; targeted by every docker exec/cp/rm. */
+    /** 容器名(也是句柄 id)= 身份 × 本 worker 的确定名({@link localDockerContainerNameOf}):只用来**找**这只身份的容器(`docker inspect` / `docker run --name`)。 */
     private readonly containerName;
-    /** Set once the container is up + the workspace dir created. */
+    /** 这只环境对它那只身份的容器负的责({@link LocalDockerCustody}:持有 / 欠着删除 / 没有)。实例 id 是 daemon 给的、不可变 —— 名下换了一只别的容器,本环境也碰不到它。
+     *  唯一写处是本类的连接 / 起动 / 删除 / 收场;没持有 ⇒ 什么都不删(连接被拒的环境不删别人的东西)。 */
+    private custody;
+    /** 标「已连」:连接的关口全过之后 = 持有的那只实例的 id。 */
     private containerId?;
+    /** 本环境发出的 `docker rm -f` 有没有真的删掉过一只容器(退 0;daemon 答「没有这只容器」只证实它不在,不算删)—— {@link reapWorkspace} 的读数。 */
+    private removedAny;
+    /** {@link destroy} 的那一次收场(第二次调用等同一只);工厂等它落定才给同一身份铸新环境(删除还在飞时新环境附着上去 = 随后被删)。 */
+    private teardown?;
+    private teardownSettled;
     private handle?;
     /** Terminal once {@link destroy} ran — guards exec/fs from running against a removed container. */
     private destroyed;
@@ -100,7 +144,19 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
     private connectRefusal?;
     /** 家目录的座(声明在场 ⇒ 开环境那一拍对证 · 否则开容器那一拍实测 · 实测缺席 ⇒ 缺席 + 一行 warn)。与其余读得出家目录的车道同一只判官、同一句拒。 */
     private readonly homeSeat;
+    /** 本环境的生命期信号:{@link destroy} 先断它 —— 在帽前等空位的那一次起动立刻收场(不拖满预算)。 */
+    private readonly lifecycle;
+    /** 帽前等空位的预算终点(ms epoch):第一次排队时定下 = 那一刻 + `controlTimeoutMs`,此后各次连接共用(花完后每次只读一次,有空位就起、没有立拒)。 */
+    private capacityDeadline?;
     constructor(config: LocalDockerEnvConfig, deps?: LocalDockerEnvDeps);
+    /** 持有的那只实例的 id(`held`);其余 ⇒ 缺席 —— `docker exec` / 中继只指它。 */
+    private get instance();
+    /** 欠着的删除(收场之后工厂读它,交给同一身份的下一只环境);不欠 ⇒ 缺席。 */
+    get leftover(): LocalDockerLeftover | undefined;
+    /** 收场的进度:活着 ⇒ 缺席;{@link destroy} 开始 ⇒ 那一次收场(容器删除证实或放弃之后落定)。工厂读它:活着就交回、收场中就等它落定。 */
+    get releasing(): Promise<void> | undefined;
+    /** 收场已落定(工厂从同身份表里清掉它)。 */
+    get released(): boolean;
     private resolve;
     /** 收据句柄。还没连上(懒环境:续跑腿的引擎在恢复相**之前**先取它比车道)⇒ 未连接形 `{ sandboxId: "(unconnected)", provider, mountPath }`(与 k8s / e2b 车道同形),
      *  不抛 —— 抛了,续跑腿在恢复相就失败。 */
@@ -112,8 +168,44 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
         ok: false;
         error: RemoteExecutionError;
     }>;
+    /** 一只在飞的连接(并发的首用调用方 / 附着都 join 它 —— 只起一只容器、只附着一次);失败 ⇒ 清掉备忘,下一次重来。 */
+    private connectOnce;
+    /**
+     * 先问 daemon 这只身份的容器({@link sightContainer}),再按它的样子(状态闭集,穷举):
+     *  · 不在 ⇒ 起一只({@link startContainer});
+     *  · 本 worker 的 · `running` ⇒ 附着({@link attachContainer});`exited`(daemon 重起 / 宿主重启 / 外部 `docker stop` —— 可写层还在)⇒ 经容器帽准入、先持有,再 `docker start` 这只、附着;
+     *    `created`(建了从没跑过 —— 上一次起动半途而废,里面什么都没有)⇒ 删掉再起;`paused` / `restarting` / `removing` / `dead` ⇒ 拒、不动它(工作区可能还在,不替运维毁掉);
+     *  · 别人的 ⇒ 拒,不起、不删;读不出(含 daemon 答了一个不在闭集里的状态)⇒ 拒(读不出不是「不在」)。
+     * 问之前先还欠着的删除(`doomed`:按 id 再删,证实才往下走);上一次起动结局没定(`doomed-unknown`)⇒ 这一读读出的本 worker 那只就是它 —— 删了(证实)再按「不在」走。
+     * 欠着删除的那只永不附着。`attach-only`(`reconnect`)从不起新容器:不在 / `created` ⇒ `connect_failed`。
+     */
     private doConnect;
-    /** 恢复点的填充:有座 ⇒ 经 {@link fillChannel} 放(容器恒是新起的 ⇒ `minted`;本车道不可挂起);没有 ⇒ 什么都不放。 */
+    private stillOwed;
+    private notResumable;
+    /**
+     * 这只身份的容器在 daemon 上的样子 —— 一次 `docker inspect`(id + 状态 + 标签)。不在 = daemon 答「没有这个对象」;本 worker 的 = 标签里有本 worker 的那一枚
+     * (整枚 `键=值` 相等,不解析标签的形);状态不在 docker 的闭集里 / 答的形读不出 / 别的失败 ⇒ 读不出。
+     */
+    private sightContainer;
+    /**
+     * 附着在跑的、本 worker 的那只容器实例(上一只进程起的、它没收的 —— 重起之后的续跑;`reconnect`):先持有它(此后 exec / rm 都指这只 id),再过与起新容器
+     * 同一组关口,只是来处不同 —— 先定命令用的 shell、过家目录,读地板以 `resumed` 附着(来历标记必须在),恢复点以 `restored` 放(只放附件、不播种)。
+     * 关口拒了不删它(它是这只身份停驻着的工作区,不是这次连接起的);本环境收场时照删 —— 收场就是释放这只身份的工作区。期间落下的 destroy 照样赢。
+     */
+    private attachContainer;
+    /** 起这只身份的新容器(daemon 上没有它):准入 → `docker run` → 家目录 → 读地板(`created`)→ 恢复点(`minted`)。任一步不过 ⇒ 收掉这次起的容器,不交半只工作区。 */
+    private startContainer;
+    /**
+     * 车道容器帽的准入 —— 容器从「不占资源」变「占」之前(`docker run`、`docker start` 停着的那只)同一只:没空位 ⇒ 有界等待,到期拒(什么都没动);
+     * 放行 ⇒ 票(起动落定后按 {@link startOutcomeOf} 交回)。帽缺席 ⇒ 放行、没有票。
+     */
+    private admitStart;
+    /**
+     * 一次起动(`docker run` / `docker start`)的结局 —— 帽的记账与失败收尾读同一个:退 0 ⇒ `present`;请求没到 daemon(二进制没起来)或 daemon 答这只名已被占用
+     * ⇒ `absent`(这一次什么都没建);其余(非零退出、超时、中止、被信号杀)⇒ `unknown`。
+     */
+    private startOutcomeOf;
+    /** 恢复点的填充:有座 ⇒ 经 {@link fillChannel} 放(来处:新起的容器 `minted`、附着的容器 `restored`);没有 ⇒ 什么都不放。 */
     private fillWorkspace;
     /** 恢复点手里的通道:`docker exec` 经唯一起动接缝(起动形 `adapter`,与引擎命令同一执行用户;连接进行中,不经懒连接的文件面);写 = 容器内 `cat >` 从 stdin 收整份字节。 */
     private fillChannel;
@@ -146,9 +238,8 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
         error: RemoteExecutionError;
     }>;
     /**
-     * Liveness re-check (NOT a snapshot resume): if the container is still running → idempotent success; if it's
-     * gone (crashed / externally removed) → `connect_failed` (no managed snapshot to re-attach to). `sessionToken`
-     * is the container name (== our handle id); a mismatch with this env's container fails closed.
+     * 附着(不是快照恢复;`sessionToken` = 容器名 = 句柄 id,不符 ⇒ 拒):没连过 ⇒ 与 {@link connect} 同一条附着路,但从不起新容器(不在 / 建了没跑过 ⇒ `connect_failed`);
+     * 起容器在飞 ⇒ join 那一次;连着 ⇒ 活性复核(名下仍是本环境持有的那只实例、在跑 ⇒ 成功,否则 `connect_failed`)。
      */
     reconnect(sessionToken: SessionToken): Promise<{
         ok: true;
@@ -157,10 +248,28 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
         ok: false;
         error: RemoteExecutionError;
     }>;
-    /** `docker rm -f` the container (full teardown). Idempotent, best-effort, never throws (cleanup contract). */
+    /** 收场:断生命期信号、等在飞的连接落定、关读地板中继,再还清本环境对容器负的责(持有的 / 欠着删除的按 id 删;结局没定的再问一次;没持有 ⇒ 什么都不删)。
+     *  删除证实不了 ⇒ 仍欠着({@link leftover}),工厂交给同一身份的下一只环境。幂等(第二次调用等同一只),best-effort,从不抛。 */
     destroy(): Promise<void>;
     cleanup(): Promise<void>;
-    private forceRemove;
+    /**
+     * 无主收割(`local-docker-reaper.ts`;调用方已按 run 行判过:这只身份的 run 终局了,没有哪条腿还会用它的工作区):认领这只身份名下本 worker 的那一只容器、经**同一只**欠着机按 id 删。
+     * 持有着的 / 欠着的 ⇒ 就是 {@link destroy} 本来要删的那一只(停驻腿留下、引擎没人销毁的环境:本进程里它就是这只环境);什么都没持有(重起之后的新环境、从没连过)⇒
+     * 先记成「结局没定」(`doomed-unknown`:下一次读出的本 worker 那只就是它)再收场 —— 名下是别人的容器 ⇒ 不动,读不出 ⇒ 仍欠着,下一轮再来。本环境此后即告终(与 `destroy` 同)。
+     * 答:`removed` = 本环境的 `docker rm -f` 真删掉了一只;`nothing` = 删除证实了、但没有我们删的(名下已没有本 worker 的容器 / 是别人的);`owed` = 删除没证实,仍欠着(下一轮再删,永不附着)。
+     */
+    reapWorkspace(): Promise<"removed" | "nothing" | "owed">;
+    /**
+     * `docker rm -f <id>` —— 只删一只确定的容器实例(best-effort,不抛)。先记成欠着删除(`doomed`:此后永不附着它):删除被证实(退 0,或 daemon 答 no such container)
+     * ⇒ 告诉车道容器帽的闸(这只名出未定集、唤醒等空位的)、责任清掉,答 `true`;证实不了 ⇒ 仍欠着(下一次连接 / 收场再删),答 `false`。
+     */
+    private removeInstance;
+    /** 一次起动结局没定(没回 id)时认领它的产物:问 daemon 这只名 —— 是本 worker 的 ⇒ 那是这一次起动的半成品(起之前问过:这只名不在),按 id 收掉
+     *  (删不掉 ⇒ 欠着,下一次连接 / 收场再删);不在 ⇒ daemon 证实了没建出来(告诉车道容器帽的闸);别人的 ⇒ 不是这一次的,不动;读不出 ⇒ 结局没定(`doomed-unknown`)。 */
+    private claimLeftoverOfThisStart;
+    /** 车道容器帽的读数:本 worker 标签下的全部容器(全状态一次读,`名\t状态` 一行一只)。读不出 ⇒ 原因(闸把它读成「证不了有空位」,不是 0)。
+     *  两个读者一只读数口:车道容器帽的准入({@link admitStart})与无主容器回收器({@link localDockerExecutionEnvFactory} 的 `reapPort.list`)—— 「本 worker 有哪些容器」只有这一个读法。 */
+    readLaneRegistry(budgetMs: number, signal: AbortSignal | undefined): Promise<RegistryReading>;
     exec(command: string, options?: ExecOpts): Promise<Result<{
         stdout: string;
         stderr: string;
@@ -176,7 +285,7 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
         abortSignal?: AbortSignal;
     }): Promise<Result<string[], FileError>>;
     /** 暂存写的两只面(规则与提交脚本的唯一属主 = `remote-shell.ts` `writeFileStaged` / `appendFileStaged`;父目录与私有暂存目录由编排的准备那一步建):
-     *  上传 = 容器内 `cat` 从 stdin 收整份字节落到私有目录里的暂存件({@link pipeIn});提交 = 容器内一次 shell 往返。两者同一身份 ——
+     *  上传 = 容器内 `cat` 从 stdin 收整份字节落到私有目录里的暂存件({@link pipeIn};阶段一无事可做 —— 传输调用本身就是起进程);提交 = 容器内一次 shell 往返。两者同一身份 ——
      *  同一只 argv 构造({@link startArgv}),都是镜像的用户。不用 `docker cp`:它由守护进程以 root 落盘,镜像用户 ≠ root 时暂存件属 root、
      *  提交方拿不走也清不掉,「目录不收新名字」也探不出来(root 哪里都写得进)。 */
     private stagedLane;
@@ -242,6 +351,11 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
     private floorTransport;
     /** Spawn the docker binary with argv; collect stdout/stderr (+ raw bytes when binary), bound by timeout/abort. */
     private docker;
+    /**
+     * 懒连接的共享一只({@link connect} 本身单飞),与调用方自己的取消赛跑:调用方的信号断了 ⇒ 它立刻拿 `aborted`,共享连接照走(别的调用方还在等它)。
+     * 连接可能在帽前等空位(每只 env 一份预算);不赛跑的话,一次被取消的工具调用要陪着等满。
+     */
+    private joinConnect;
     /** Lazy connect for an exec path → ExecutionError on failure (fail closed, never throws). */
     /** S1([ref]):容器内**用户命令**的 shell。缺省 /bin/sh;首次连接后探测一次 `command -v bash`,
      *  有则切 bash(TB 实测 dash 三病:$'\t' 静默错字节/[[ ]] 127/进程替换)。镜像无 bash(alpine 裸底)
@@ -261,15 +375,38 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
     /** Map an ExecutionError from a docker CONTROL op (run/inspect) onto a RemoteExecutionError code. */
     private dockerToRemoteError;
 }
+/**
+ * 一只工作区的容器名 = `sema-docker-<身份的可读形>-<摘要>`,摘要 = sha256(本 worker 标签 · 身份) 的前 12 位 hex:同一 worker 上同一身份恒同名(停驻 → 续跑、
+ * 重起之后的续跑找得到它),别的 worker 标签 / 别的身份不同名(可读形被截断或替换过也不撞)。名里不放随机尾 —— 名字就是身份。
+ */
+export declare function localDockerContainerNameOf(workerLabel: string, identity: string): string;
+/**
+ * {@link localDockerContainerNameOf} 的逆:从名读回身份 —— 名 = `sema-docker-<可读形>-<12 位摘要>`;可读形就是身份本身(身份只含 `[A-Za-z0-9._-]` 且不超过 48 位)时,
+ * 用**正向函数**验证(摘要对得上本 worker 标签 × 这只身份才认,一个事实一个写法)。读不回 ⇒ `undefined`:旧版的随机尾名(摘要位是 8 位随机)、可读形被截断 / 替换过的身份、
+ * 别的 worker 铸的名、不是本适配器铸的名 —— 回收器对它们一律不动。
+ */
+export declare function localDockerIdentityOfName(workerLabel: string, name: string): string | undefined;
 /**
  * `ExecutionEnvFactory` for the TOC `local-docker` backend (DUAL-MODE-DESIGN §5). Wiring this onto a deployment
  * makes its agent run each task in a per-task container on the worker's OWN docker daemon (isolation:true,
  * suspendable:false). Returns the env UNCONNECTED (lazy — the container starts on first fs/exec use); the Runner
- * owns the lifetime and calls `destroy()` (= `docker rm -f`) on task end. Folds the per-task `ctx.taskId`/
- * `ctx.sessionId` into the container name so two concurrent tasks never share a container.
+ * owns the lifetime and calls `destroy()` (= `docker rm -f`) on task end.
+ *
+ * 身份 = `ctx.taskId ?? ctx.sessionId`(与引擎交给工具的宿主任务号同一读法:顶层 run = run 号,委派子代 = 它自己的会话号 —— 子代从不带 `taskId`)。
+ * 一只身份一只工作区:本工厂对同一身份交回**那一只**还没销毁的环境(停驻腿的环境引擎还拿着;续跑腿拿到的就是它 —— 引擎 park-only 契约要的「重连到同一工作区」,
+ * 在同一进程里就是同一只环境,读地板的中继也只有一只);上一只正在收场 ⇒ 等它的删除落定再铸;没有 ⇒ 铸一只(它连接时在跑的同名容器就附着 —— 上一只进程起的)。
+ * 收场落定的从表里清掉。
+ * 无主容器:停驻中取消 / 停驻过期(本服务在店层结清,不经引擎的仲裁器,停驻腿的环境没有销毁者)与重起之后才结清的停驻,容器一直在跑 ——
+ * 回收器(`local-docker-reaper.ts`,维护 tick 的沙箱回收腿)按它那条 run 的行已终局判无主,经本工厂的 `reapPort` 删:同一张同身份表(本进程还拿着那只环境 ⇒ 就是它收场)、
+ * 同一只欠着机(重起之后没有环境对象 ⇒ 铸一只只为删的、认领这只身份名下本 worker 的容器按 id 删)。
+ * 同一身份同一时刻只有一条腿(会话锁 + run 认领),所以交回同一只不会让两条腿同时用它。
  */
-export declare function localDockerExecutionEnvFactory(config: Omit<LocalDockerEnvConfig, "workspaceFill"> & {
+export declare function localDockerExecutionEnvFactory(config: Omit<LocalDockerEnvConfig, "workspaceFill" | "id" | "leftover"> & {
     readonly workspaceFillOf?: WorkspaceFillOf;
-}, deps?: LocalDockerEnvDeps): ExecutionEnvFactory;
+}, deps?: LocalDockerEnvDeps): LocalDockerEnvFactory;
+/** 本车道的工厂(`ExecutionEnvFactory`)+ 无主容器回收器读它的窄面({@link LocalDockerReapPort}):二者同一张同身份表、同一只欠着机。包装工厂(远端 scratchpad / worktree)之前先取走 `reapPort`。 */
+export type LocalDockerEnvFactory = ExecutionEnvFactory & {
+    readonly reapPort: LocalDockerReapPort;
+};
 export {};
 //# sourceMappingURL=remote-env-local-docker.d.ts.map