@sema-agent/server 1.314.0 → 1.316.0

package/dist/http/sse-log.d.ts

@@ -0,0 +1,25 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface SseLogProvider<E extends {
+    seq: number;
+}> {
+    statusOf(id: string): Promise<{
+        status: string;
+        updatedAt: string;
+    } | null | undefined>;
+    getEvents(id: string, after: number): Promise<E[]>;
+    retainedFrom(id: string): Promise<number>;
+    formatEvent(ev: E): {
+        id: number;
+        event: string;
+        data: unknown;
+    };
+    staleFrame(): {
+        event: string;
+        data: unknown;
+    };
+}
+export declare function streamSseLog<E extends {
+    seq: number;
+}>(req: IncomingMessage, res: ServerResponse, provider: SseLogProvider<E>, id: string, staleMs: number): Promise<void>;
+export declare function sleep(ms: number): Promise<void>;
+//# sourceMappingURL=sse-log.d.ts.map

package/dist/http/sse-log.js

@@ -0,0 +1,59 @@
+import { sendJson, sseHeaders } from "./send.js";
+export async function streamSseLog(req, res, provider, id, staleMs) {
+    const lastId = Number(req.headers["last-event-id"] ?? new URL(req.url ?? "", "http://x").searchParams.get("from") ?? 0);
+    let from = Number.isFinite(lastId) ? lastId : 0;
+    if (from > 0) {
+        const retainedFrom = await provider.retainedFrom(id);
+        if (retainedFrom > from + 1) {
+            sendJson(res, 416, { error: "resume point evicted past retention", retainedFrom });
+            return;
+        }
+    }
+    sseHeaders(res);
+    let closed = false;
+    req.on("close", () => {
+        closed = true;
+    });
+    const start = Date.now();
+    const MAX_MS = 15 * 60 * 1000;
+    let lastBeat = Date.now();
+    const write = (events) => {
+        for (const ev of events) {
+            const f = provider.formatEvent(ev);
+            res.write(`id: ${f.id}\nevent: ${f.event}\ndata: ${JSON.stringify(f.data)}\n\n`);
+            from = ev.seq;
+        }
+    };
+    while (!closed) {
+        const [events, row] = await Promise.all([provider.getEvents(id, from), provider.statusOf(id)]);
+        write(events);
+        if (!row)
+            break;
+        if (row.status !== "running") {
+            write(await provider.getEvents(id, from));
+            break;
+        }
+        const stale = Date.now() - new Date(row.updatedAt).getTime() > staleMs;
+        if (stale && events.length === 0) {
+            const sf = provider.staleFrame();
+            res.write(`event: ${sf.event}\ndata: ${JSON.stringify(sf.data)}\n\n`);
+            break;
+        }
+        if (Date.now() - start > MAX_MS) {
+            res.write(`event: error\ndata: ${JSON.stringify({ type: "error", code: "STREAM_MAX_DURATION", message: "stream reached its 15-minute cap — reconnect with Last-Event-ID to continue (the run is still active)" })}\n\n`);
+            break;
+        }
+        if (events.length === 0) {
+            if (Date.now() - lastBeat > 15_000) {
+                res.write(`event: heartbeat\ndata: {}\n\n`);
+                lastBeat = Date.now();
+            }
+            await sleep(250);
+        }
+    }
+    res.end();
+}
+export function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+//# sourceMappingURL=sse-log.js.map

package/dist/http/workspace-content.d.ts

@@ -0,0 +1,3 @@
+export declare function workspaceContentType(relPath: string): string;
+export declare function looksBinary(bytes: Uint8Array): boolean;
+//# sourceMappingURL=workspace-content.d.ts.map

package/dist/http/workspace-content.js

@@ -0,0 +1,20 @@
+export function workspaceContentType(relPath) {
+    const base = relPath.slice(relPath.lastIndexOf("/") + 1);
+    const dot = base.lastIndexOf(".");
+    const ext = dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
+    const TABLE = {
+        txt: "text/plain; charset=utf-8", md: "text/plain; charset=utf-8", log: "text/plain; charset=utf-8",
+        json: "application/json; charset=utf-8", csv: "text/csv; charset=utf-8",
+        png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp",
+        pdf: "application/pdf",
+    };
+    return TABLE[ext] ?? "application/octet-stream";
+}
+export function looksBinary(bytes) {
+    const n = Math.min(bytes.byteLength, 8192);
+    for (let i = 0; i < n; i++)
+        if (bytes[i] === 0)
+            return true;
+    return false;
+}
+//# sourceMappingURL=workspace-content.js.map

package/dist/index.d.ts

@@ -22,5 +22,5 @@ export { createCouncilTool } from "./capabilities/code-review-council.js";
 export { loadSkills, skillsForScenario, type LoadedSkill } from "./capabilities/skills.js";
 export { buildScenarios, selectScenario, type Scenario, type ScenarioBundle, type ScenarioDeps, type ScenarioRequest, } from "./capabilities/scenarios.js";
 export { createAuthorizer, principalFrom, memoryScopeFor, memoryEngineBackendFor, HttpError, type AuthContext, type OwnerAwareSessionStore, } from "./security.js";
-export { createHttpServer, type ServiceDeps, type TaskRequestBody, type RequestAuth, } from "./http/server.js";
+export { createHttpServer, type ServiceDeps, type TaskRequestBody, type RequestAuth, type FlatServiceDeps, type ServiceDepGroups, type ServiceCoreDeps, type ServiceStoreDeps, type ServiceCoordinatorDeps, type ServiceSeamDeps, type ServiceObservabilityDeps, type ServiceGovernanceDeps, type ServiceDeploymentDeps, type ServiceKnobDeps, } from "./http/server.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/leader/leader.js

@@ -161,7 +161,9 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
             }));
             return out;
         };
-        if (deps.moduleGate) {
+        const runModuleGate = async () => {
+            if (!deps.moduleGate)
+                return;
             const subById = new Map(subs.map((s) => [s.workerId, s]));
             const maxR = deps.moduleGate.maxRepairs ?? 1;
             await Promise.all(reports.filter((r) => r.status === "completed").map(async (r) => {
@@ -194,7 +196,8 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
                     }
                 }
             }));
-        }
+        };
+        await runModuleGate();
         const mergeDeps = {
             pullWorkerDiff: async (r) => workerDiff(byId.get(r.workerId)),
             provisionIntegrationSandbox: deps.provisionIntegrationSandbox,

package/dist/leader/wire.js

@@ -192,186 +192,190 @@ export function createLeaderRunner(cfg) {
             if (!ex.ok)
                 throw ex.error;
         };
-        const deps = {
-            plan: async () => {
-                if (Array.isArray(body.subtasks) && body.subtasks.length > 0) {
-                    return validateSubtasks(body.subtasks);
-                }
-                const planRunner = new Runner({ brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing });
-                const runRoute = async (prompt) => {
-                    const res = await planRunner.runTaskStream({
-                        objective: prompt,
-                        sessionId: `leader-route-${Date.now()}`,
-                        ...(cfg.routerModel ? { model: cfg.routerModel } : {}),
-                    }).result();
-                    return res.result ?? "";
+        const plan = async () => {
+            if (Array.isArray(body.subtasks) && body.subtasks.length > 0) {
+                return validateSubtasks(body.subtasks);
+            }
+            const planRunner = new Runner({ brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing });
+            const runRoute = async (prompt) => {
+                const res = await planRunner.runTaskStream({
+                    objective: prompt,
+                    sessionId: `leader-route-${Date.now()}`,
+                    ...(cfg.routerModel ? { model: cfg.routerModel } : {}),
+                }).result();
+                return res.result ?? "";
+            };
+            const { subs, collapsed, rawSample } = await routePlanWithFallback(body.objective, runRoute, {
+                ...(body.planContext ? { context: body.planContext } : {}),
+                ...(cfg.fanoutEnabled === false ? { fanoutEnabled: false } : {}),
+            });
+            if (collapsed)
+                cfg.logger?.warn?.("plan_collapsed_to_single", { reason: collapsed, ...(rawSample ? { rawSample } : {}) });
+            return subs;
+        };
+        const provisionWorker = async (sub) => {
+            const sessionId = `leader-${sub.workerId}-${Date.now()}`;
+            let durableSpec = {};
+            if (cfg.durable) {
+                const d = cfg.durable;
+                durableSpec = {
+                    toolPolicy: combinePolicies(createDurableQuestionPolicy(), createDurableAskPolicy({ requireApproval: d.requireApproval, ...(d.deny ? { deny: d.deny } : {}), ...(d.autoBudget ? { autoBudget: d.autoBudget } : {}), ...(d.neverAuto ? { neverAuto: d.neverAuto } : {}) })),
+                    checkpointStore: d.checkpointStore,
+                    durableApproval: { scope: "_leader", ...(d.ttlMs ? { ttlMs: d.ttlMs } : {}) },
+                    onQuestion: QUESTION_AWAITS_RESUME,
                 };
-                const { subs, collapsed, rawSample } = await routePlanWithFallback(body.objective, runRoute, {
-                    ...(body.planContext ? { context: body.planContext } : {}),
-                    ...(cfg.fanoutEnabled === false ? { fanoutEnabled: false } : {}),
+                await d.checkpointStore.putCtx(sessionId, { body: { objective: sub.spec.objective } }).catch((e) => {
+                    cfg.logger?.warn?.("leader_putctx_failed", { workerId: sub.workerId, err: String(e) });
                 });
-                if (collapsed)
-                    cfg.logger?.warn?.("plan_collapsed_to_single", { reason: collapsed, ...(rawSample ? { rawSample } : {}) });
-                return subs;
-            },
-            provisionWorker: async (sub) => {
-                const sessionId = `leader-${sub.workerId}-${Date.now()}`;
-                let durableSpec = {};
-                if (cfg.durable) {
-                    const d = cfg.durable;
-                    durableSpec = {
-                        toolPolicy: combinePolicies(createDurableQuestionPolicy(), createDurableAskPolicy({ requireApproval: d.requireApproval, ...(d.deny ? { deny: d.deny } : {}), ...(d.autoBudget ? { autoBudget: d.autoBudget } : {}), ...(d.neverAuto ? { neverAuto: d.neverAuto } : {}) })),
-                        checkpointStore: d.checkpointStore,
-                        durableApproval: { scope: "_leader", ...(d.ttlMs ? { ttlMs: d.ttlMs } : {}) },
-                        onQuestion: QUESTION_AWAITS_RESUME,
-                    };
-                    await d.checkpointStore.putCtx(sessionId, { body: { objective: sub.spec.objective } }).catch((e) => {
-                        cfg.logger?.warn?.("leader_putctx_failed", { workerId: sub.workerId, err: String(e) });
-                    });
-                }
-                let resourceSpec = {};
-                const repairLoopActive = repairLoopOn && REPAIR_LOOP_WIRED;
-                if (repairLoopActive && resourceCfg) {
-                    cfg.logger?.warn?.("leader_resource_suspend_disabled_for_repair_loop", { workerId: sub.workerId, reason: "LEADER_REPAIR_LOOP active — resource-suspend mutually exclusive with the repair loop (§10.5)" });
-                }
-                if (resourceCfg && !repairLoopActive && cfg.durable && cfg.toolResultStore && cfg.sessionStore) {
-                    resourceSpec = {
-                        checkpointStore: cfg.durable.checkpointStore,
-                        resourceSuspend: { scope: `_leader-resource-${sub.workerId}`, totalBudgetUsd: resourceCfg.totalBudgetUsd },
-                        maxCostUsd: resourceCfg.sliceMaxCostUsd,
-                        maxSuspends: resourceCfg.maxSuspends,
-                    };
-                }
-                else if (resourceCfg && !repairLoopActive) {
-                    cfg.logger?.warn?.("leader_resource_suspend_inactive", {
-                        workerId: sub.workerId,
-                        reason: !cfg.durable
-                            ? "no durable checkpoint store"
-                            : !cfg.toolResultStore
-                                ? "no durable tool-result store"
-                                : "no durable session store",
-                    });
-                }
-                const keepCtxWarm = (runner) => {
-                    const d = cfg.durable;
-                    if (!d)
-                        return runner;
-                    const orig = runner.runTaskStream.bind(runner);
-                    runner.runTaskStream = (spec, resume) => {
-                        const stream = orig(spec, resume);
-                        const iv = setInterval(() => {
-                            void d.checkpointStore.putCtx(sessionId, { body: { objective: sub.spec.objective } }).catch(() => { });
-                        }, 45_000);
-                        iv.unref?.();
-                        void stream.result().then(() => clearInterval(iv), () => clearInterval(iv));
-                        return stream;
-                    };
+            }
+            let resourceSpec = {};
+            const repairLoopActive = repairLoopOn && REPAIR_LOOP_WIRED;
+            if (repairLoopActive && resourceCfg) {
+                cfg.logger?.warn?.("leader_resource_suspend_disabled_for_repair_loop", { workerId: sub.workerId, reason: "LEADER_REPAIR_LOOP active — resource-suspend mutually exclusive with the repair loop (§10.5)" });
+            }
+            if (resourceCfg && !repairLoopActive && cfg.durable && cfg.toolResultStore && cfg.sessionStore) {
+                resourceSpec = {
+                    checkpointStore: cfg.durable.checkpointStore,
+                    resourceSuspend: { scope: `_leader-resource-${sub.workerId}`, totalBudgetUsd: resourceCfg.totalBudgetUsd },
+                    maxCostUsd: resourceCfg.sliceMaxCostUsd,
+                    maxSuspends: resourceCfg.maxSuspends,
+                };
+            }
+            else if (resourceCfg && !repairLoopActive) {
+                cfg.logger?.warn?.("leader_resource_suspend_inactive", {
+                    workerId: sub.workerId,
+                    reason: !cfg.durable
+                        ? "no durable checkpoint store"
+                        : !cfg.toolResultStore
+                            ? "no durable tool-result store"
+                            : "no durable session store",
+                });
+            }
+            const keepCtxWarm = (runner) => {
+                const d = cfg.durable;
+                if (!d)
                     return runner;
+                const orig = runner.runTaskStream.bind(runner);
+                runner.runTaskStream = (spec, resume) => {
+                    const stream = orig(spec, resume);
+                    const iv = setInterval(() => {
+                        void d.checkpointStore.putCtx(sessionId, { body: { objective: sub.spec.objective } }).catch(() => { });
+                    }, 45_000);
+                    iv.unref?.();
+                    void stream.result().then(() => clearInterval(iv), () => clearInterval(iv));
+                    return stream;
+                };
+                return runner;
+            };
+            if (cfg.s3 && cfg.envFactory) {
+                const s3 = cfg.s3;
+                const envFactory = cfg.envFactory;
+                const baseSha = body.baseSha;
+                const seedCmd = body.seedCmd;
+                const key = `${s3.keyPrefix ?? "leader-diff"}/${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}/${sub.workerId}.patch`;
+                const ttl = presignTtlSec;
+                const base = { endpoint: s3.endpoint, bucket: s3.bucket, accessKey: s3.accessKey, secretKey: s3.secretKey, ...(s3.region ? { region: s3.region } : {}), key, expiresSec: ttl };
+                const putUrl = presignS3Url({ ...base, method: "PUT" });
+                const getUrl = presignS3Url({ ...base, method: "GET" });
+                const script = buildUploadScript({ repoDir: repo, baseSha, putUrl, workDir: W });
+                const stage = async (env) => {
+                    await stageWorkerEnv(env, { seedCmd, repo, branch: sub.branch, uploadScriptPath: `${W}/.leader-upload.sh`, uploadScript: script });
+                    void sh(env)(`nohup sh -c 'while true; do sleep 90; sh ${W}/.leader-upload.sh >/dev/null 2>&1 || true; done' </dev/null >/dev/null 2>&1 &`).catch(() => { });
                 };
-                if (cfg.s3 && cfg.envFactory) {
-                    const s3 = cfg.s3;
-                    const envFactory = cfg.envFactory;
-                    const baseSha = body.baseSha;
-                    const seedCmd = body.seedCmd;
-                    const key = `${s3.keyPrefix ?? "leader-diff"}/${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}/${sub.workerId}.patch`;
-                    const ttl = presignTtlSec;
-                    const base = { endpoint: s3.endpoint, bucket: s3.bucket, accessKey: s3.accessKey, secretKey: s3.secretKey, ...(s3.region ? { region: s3.region } : {}), key, expiresSec: ttl };
-                    const putUrl = presignS3Url({ ...base, method: "PUT" });
-                    const getUrl = presignS3Url({ ...base, method: "GET" });
-                    const script = buildUploadScript({ repoDir: repo, baseSha, putUrl, workDir: W });
-                    const stage = async (env) => {
-                        await stageWorkerEnv(env, { seedCmd, repo, branch: sub.branch, uploadScriptPath: `${W}/.leader-upload.sh`, uploadScript: script });
-                        void sh(env)(`nohup sh -c 'while true; do sleep 90; sh ${W}/.leader-upload.sh >/dev/null 2>&1 || true; done' </dev/null >/dev/null 2>&1 &`).catch(() => { });
-                    };
-                    return {
-                        workerId: sub.workerId, sessionId, branch: sub.branch,
-                        baseSha,
-                        runner: keepCtxWarm(new Runner({
-                            brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing,
-                            ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}),
-                            ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}),
-                            executionEnvFactory: (ctx) => withStaging(envFactory(ctx), stage, async (e) => {
-                                await sh(e)(`cd ${repo} && git add -A && git -c user.name='leader-belt' -c user.email='belt@leader' commit -qm 'belt: auto-commit uncommitted worker output' || true; sh ${W}/.leader-upload.sh`);
-                            }),
-                        })),
-                        fetchDiff: () => fetchUploadedDiff(getUrl),
-                        spec: { ...workerLimits, ...sub.spec, ...durableSpec, ...resourceSpec, objective: `${sub.spec.objective}${uploadStepSuffix(W)}` },
-                    };
-                }
-                if (!cfg.e2bApiKey)
-                    throw new Error("leader wire: no envFactory+s3 (factory mode) and no e2bApiKey (static mode)");
-                const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs });
-                if (!(await env.connect()).ok)
-                    throw new Error(`connect failed for ${sub.workerId}`);
-                await sh(env)(`${body.seedCmd}; cd ${repo}; git checkout -q -b ${sub.branch}`);
-                const baseSha = await sh(env)(`cd ${repo} && git rev-parse HEAD`);
                 return {
-                    workerId: sub.workerId, sessionId, branch: sub.branch, baseSha,
-                    runner: keepCtxWarm(new Runner({ brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing, ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}), ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}), executionEnv: env })),
-                    diffEnv: env,
-                    destroy: () => env.destroy().then(() => { }),
-                    spec: { ...workerLimits, ...sub.spec, ...durableSpec, ...resourceSpec },
+                    workerId: sub.workerId, sessionId, branch: sub.branch,
+                    baseSha,
+                    runner: keepCtxWarm(new Runner({
+                        brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing,
+                        ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}),
+                        ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}),
+                        executionEnvFactory: (ctx) => withStaging(envFactory(ctx), stage, async (e) => {
+                            await sh(e)(`cd ${repo} && git add -A && git -c user.name='leader-belt' -c user.email='belt@leader' commit -qm 'belt: auto-commit uncommitted worker output' || true; sh ${W}/.leader-upload.sh`);
+                        }),
+                    })),
+                    fetchDiff: () => fetchUploadedDiff(getUrl),
+                    spec: { ...workerLimits, ...sub.spec, ...durableSpec, ...resourceSpec, objective: `${sub.spec.objective}${uploadStepSuffix(W)}` },
                 };
-            },
-            provisionIntegrationSandbox: async () => {
-                if (cfg.envFactory) {
-                    const env = cfg.envFactory({ sessionId: `leader-integ-${Date.now()}` });
-                    try {
-                        await sh(env)(body.seedCmd);
-                        await injectOracles(env);
-                    }
-                    catch (e) {
-                        await Promise.resolve(env.destroy()).catch(() => { });
-                        throw e;
-                    }
-                    return { env: asIntegrationEnv(env), destroy: () => Promise.resolve(env.destroy()).then(() => { }), ...(mkRepair(env, repo, body.oracleFiles ?? []) ? { repair: mkRepair(env, repo, body.oracleFiles ?? []) } : {}), ...(mkConflictResolver(env, repo, body.oracleFiles ?? []) ? { conflictResolver: mkConflictResolver(env, repo, body.oracleFiles ?? []) } : {}) };
-                }
-                if (!cfg.e2bApiKey)
-                    throw new Error("leader wire: no envFactory and no e2bApiKey");
-                const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs });
-                if (!(await env.connect()).ok) {
-                    await env.destroy().catch(() => { });
-                    throw new Error("integ connect failed");
-                }
+            }
+            if (!cfg.e2bApiKey)
+                throw new Error("leader wire: no envFactory+s3 (factory mode) and no e2bApiKey (static mode)");
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs });
+            if (!(await env.connect()).ok)
+                throw new Error(`connect failed for ${sub.workerId}`);
+            await sh(env)(`${body.seedCmd}; cd ${repo}; git checkout -q -b ${sub.branch}`);
+            const baseSha = await sh(env)(`cd ${repo} && git rev-parse HEAD`);
+            return {
+                workerId: sub.workerId, sessionId, branch: sub.branch, baseSha,
+                runner: keepCtxWarm(new Runner({ brain: cfg.brain, models: cfg.models, roles: cfg.roles, pricing: cfg.pricing, ...(cfg.toolResultStore ? { toolResultStore: cfg.toolResultStore } : {}), ...(cfg.sessionStore ? { sessionStore: cfg.sessionStore } : {}), executionEnv: env })),
+                diffEnv: env,
+                destroy: () => env.destroy().then(() => { }),
+                spec: { ...workerLimits, ...sub.spec, ...durableSpec, ...resourceSpec },
+            };
+        };
+        const provisionIntegrationSandbox = async () => {
+            if (cfg.envFactory) {
+                const env = cfg.envFactory({ sessionId: `leader-integ-${Date.now()}` });
                 try {
                     await sh(env)(body.seedCmd);
                     await injectOracles(env);
                 }
                 catch (e) {
-                    await env.destroy().catch(() => { });
+                    await Promise.resolve(env.destroy()).catch(() => { });
                     throw e;
                 }
-                return { env: asIntegrationEnv(env), destroy: () => env.destroy().then(() => { }), ...(mkRepair(env, repo, body.oracleFiles ?? []) ? { repair: mkRepair(env, repo, body.oracleFiles ?? []) } : {}), ...(mkConflictResolver(env, repo, body.oracleFiles ?? []) ? { conflictResolver: mkConflictResolver(env, repo, body.oracleFiles ?? []) } : {}) };
-            },
-            push: async (integratedPatch, baseSha) => {
-                const dir = mkdtempSync(join(tmpdir(), "leader-coord-"));
-                const gitEnv = { ...process.env, LC_ALL: "C" };
-                try {
-                    execFileSync("git", ["clone", "-q", body.durableRemote, dir], { env: gitEnv });
-                    execFileSync("git", ["-C", dir, "config", "user.name", ident.name]);
-                    execFileSync("git", ["-C", dir, "config", "user.email", ident.email]);
-                    writeFileSync(join(dir, ".leader.patch"), integratedPatch);
-                    execFileSync("git", ["-C", dir, "am", "--3way", ".leader.patch"], { env: gitEnv });
-                    rmSync(join(dir, ".leader.patch"));
-                    const ref = body.targetRef ?? "refs/heads/main";
-                    const ls = execFileSync("git", ["-C", dir, "ls-remote", "--refs", "origin", ref], { encoding: "utf8", env: gitEnv });
-                    const exists = ls.split("\n").some((l) => l.split("\t")[1] === ref);
-                    if (exists) {
-                        execFileSync("git", ["-C", dir, "push", `--force-with-lease=${ref}:${baseSha}`, "origin", `HEAD:${ref}`], { env: gitEnv });
-                    }
-                    else {
-                        execFileSync("git", ["-C", dir, "push", `--force-with-lease=${ref}:`, "origin", `HEAD:${ref}`], { env: gitEnv });
-                    }
-                    return { ok: true, ref };
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    return { ok: false, raced: /stale info|force-with-lease|\[rejected\]|non-fast-forward/.test(msg), error: msg };
+                return { env: asIntegrationEnv(env), destroy: () => Promise.resolve(env.destroy()).then(() => { }), ...(mkRepair(env, repo, body.oracleFiles ?? []) ? { repair: mkRepair(env, repo, body.oracleFiles ?? []) } : {}), ...(mkConflictResolver(env, repo, body.oracleFiles ?? []) ? { conflictResolver: mkConflictResolver(env, repo, body.oracleFiles ?? []) } : {}) };
+            }
+            if (!cfg.e2bApiKey)
+                throw new Error("leader wire: no envFactory and no e2bApiKey");
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs });
+            if (!(await env.connect()).ok) {
+                await env.destroy().catch(() => { });
+                throw new Error("integ connect failed");
+            }
+            try {
+                await sh(env)(body.seedCmd);
+                await injectOracles(env);
+            }
+            catch (e) {
+                await env.destroy().catch(() => { });
+                throw e;
+            }
+            return { env: asIntegrationEnv(env), destroy: () => env.destroy().then(() => { }), ...(mkRepair(env, repo, body.oracleFiles ?? []) ? { repair: mkRepair(env, repo, body.oracleFiles ?? []) } : {}), ...(mkConflictResolver(env, repo, body.oracleFiles ?? []) ? { conflictResolver: mkConflictResolver(env, repo, body.oracleFiles ?? []) } : {}) };
+        };
+        const push = async (integratedPatch, baseSha) => {
+            const dir = mkdtempSync(join(tmpdir(), "leader-coord-"));
+            const gitEnv = { ...process.env, LC_ALL: "C" };
+            try {
+                execFileSync("git", ["clone", "-q", body.durableRemote, dir], { env: gitEnv });
+                execFileSync("git", ["-C", dir, "config", "user.name", ident.name]);
+                execFileSync("git", ["-C", dir, "config", "user.email", ident.email]);
+                writeFileSync(join(dir, ".leader.patch"), integratedPatch);
+                execFileSync("git", ["-C", dir, "am", "--3way", ".leader.patch"], { env: gitEnv });
+                rmSync(join(dir, ".leader.patch"));
+                const ref = body.targetRef ?? "refs/heads/main";
+                const ls = execFileSync("git", ["-C", dir, "ls-remote", "--refs", "origin", ref], { encoding: "utf8", env: gitEnv });
+                const exists = ls.split("\n").some((l) => l.split("\t")[1] === ref);
+                if (exists) {
+                    execFileSync("git", ["-C", dir, "push", `--force-with-lease=${ref}:${baseSha}`, "origin", `HEAD:${ref}`], { env: gitEnv });
                 }
-                finally {
-                    rmSync(dir, { recursive: true, force: true });
+                else {
+                    execFileSync("git", ["-C", dir, "push", `--force-with-lease=${ref}:`, "origin", `HEAD:${ref}`], { env: gitEnv });
                 }
-            },
+                return { ok: true, ref };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { ok: false, raced: /stale info|force-with-lease|\[rejected\]|non-fast-forward/.test(msg), error: msg };
+            }
+            finally {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        };
+        const deps = {
+            plan,
+            provisionWorker,
+            provisionIntegrationSandbox,
+            push,
             testCmd: body.testCmd,
             repoDir: repo, workerRepoDir: repo,
             timeoutMs: leaderTimeoutMs, maxConcurrency: 4,