@sema-agent/server 1.314.0 → 1.315.0

package/dist/http/server.d.ts

@@ -30,58 +30,59 @@ export interface RequestAuth {
     memoryScope?: string;
     resolvedProjectId?: string;
 }
-export interface ServiceDeps {
+export interface ServiceCoreDeps {
     runner: Runner;
     config: ServiceConfig;
-    registryJwtVerifier?: {
-        verify: (bearer: string) => Promise<import("../auth-bridge.js").VerifyOutcome>;
-    };
-    hookWakeBus?: {
-        deliver?: (sessionId: string, text: string) => Promise<boolean>;
-    };
-    drainState?: {
-        draining: boolean;
-        since?: number;
-        inflight?: () => number;
-        lastActivityAt?: () => number;
-    };
-    storeDegraded?: boolean;
-    sessionStoreLabel?: string;
-    modelReady?: () => boolean;
-    scenarioDetails?: Record<string, import("../capabilities/scenarios.js").ScenarioDetail>;
-    authorize?: (ctx: {
-        req: IncomingMessage;
-        body: TaskRequestBody;
-    }) => Promise<RequestAuth>;
     resolveSpec: (body: TaskRequestBody, req: IncomingMessage | undefined, auth?: RequestAuth, opts?: {
         leg?: "fresh" | "resume";
     }) => TaskSpec | Promise<TaskSpec>;
+}
+export interface ServiceStoreDeps {
     runStore?: RunStore;
     resumeAnchorStore?: ResumeAnchorStore;
-    sessionTitler?: {
-        maybeTitle(sessionId: string, objective: string): void;
-    };
+    approvalStore?: ApprovalStore;
     approvalExemptionStore?: ApprovalExemptionStore;
+    checkpointStore?: CheckpointStoreFull;
     sessionPolicyStore?: ServiceSessionPolicyStore;
     fileSnapshotStore?: ServiceFileSnapshotStore;
-    snapshotBlobSqlCapBytes?: number;
-    backend?: StoreBackend;
-    sessionMirrorRuling?: (principal: string | undefined) => Promise<SessionMirrorRuling | undefined>;
-    approvalStore?: ApprovalStore;
-    checkpointStore?: CheckpointStoreFull;
-    backgroundAgentStore?: import("@sema-agent/core").BackgroundAgentStore;
-    parkedReviveTool?: import("@sema-agent/core").ToolSpec;
-    parkedKnownAgentTypes?: ReadonlySet<string>;
-    parkedReviveInheritedGate?: (row: import("@sema-agent/core").BackgroundAgentRecord) => unknown;
     taskAttachmentStore?: TaskAttachmentStore;
-    imageIndex?: ImageIndex;
-    imageBakes?: ImageBake;
-    leaderEndpoint?: LeaderEndpoint;
+    backgroundAgentStore?: import("@sema-agent/core").BackgroundAgentStore;
+    sessionStorage?: OwnerAwareSessionStore;
     workflowRunStore?: WorkflowRunStore;
     workflowJournalStore?: import("@sema-agent/core").WorkflowJournalStore;
-    workflowsCapable?: boolean;
+    imageIndex?: ImageIndex;
+    imageBakes?: ImageBake;
+    outcomeSink?: import("../plugins/file-outcome-sink.js").OutcomeSink;
+    sendFileLedger?: import("../plugins/send-file-ledger.js").SendFileLedger;
+    backend?: StoreBackend;
+}
+export interface ServiceCoordinatorDeps {
+    elicitation?: ElicitationCoordinator;
+    question?: QuestionCoordinator;
+    toolApproval?: ToolApprovalCoordinator;
     workflowAgentRegistry?: WorkflowAgentRegistry;
     subagentSteerRegistry?: SubagentSteerRegistry;
+    workflowCompletionInbox?: WorkflowCompletionInbox;
+    fleetBus?: FleetEventBus;
+    sessionWatch?: import("../session-watch.js").SessionWatchRegistry;
+    hookWakeBus?: {
+        deliver?: (sessionId: string, text: string) => Promise<boolean>;
+    };
+    sendUserFile?: import("../capabilities/send-user-file-tool.js").SendUserFileEmitter;
+    leaderEndpoint?: LeaderEndpoint;
+    sessionTitler?: {
+        maybeTitle(sessionId: string, objective: string): void;
+    };
+}
+export interface ServiceSeamDeps {
+    sessionAudit?: (sessionId: string) => Promise<({
+        owner: string | null;
+    } & Record<string, unknown>) | undefined>;
+    purgeSession?: (sessionId: string, owner: string | null) => Promise<{
+        deleted: boolean;
+    } | {
+        active: string;
+    }>;
     subagentTaskOutput?: (handle: string, access: {
         owner: string;
         scope: string;
@@ -106,23 +107,10 @@ export interface ServiceDeps {
         content: string;
         details: unknown;
     }>;
-    workflowCompletionInbox?: WorkflowCompletionInbox;
-    fleetBus?: FleetEventBus;
-    sessionAudit?: (sessionId: string) => Promise<({
-        owner: string | null;
-    } & Record<string, unknown>) | undefined>;
-    sessionStorage?: OwnerAwareSessionStore;
-    purgeSession?: (sessionId: string, owner: string | null) => Promise<{
-        deleted: boolean;
-    } | {
-        active: string;
-    }>;
-    instanceId?: string;
-    logger?: Logger;
-    metrics?: Metrics;
-    rateLimiter?: RateGate;
-    costQuota?: QuotaTracker;
-    fleetLease?: FleetLeaseManager;
+    memoryExport?: (scope: string) => Promise<MemoryEntry[]>;
+    memorySync?: (scope: string, syncReq: MemorySyncRequest) => Promise<MemorySyncResponse>;
+    sessionMirrorRuling?: (principal: string | undefined) => Promise<SessionMirrorRuling | undefined>;
+    instrumentDegenerate?: (result: TaskResult) => void;
     sideQueryAccounting?: (principal: string | undefined, r: {
         model: string;
         family?: "input-includes-cached" | "input-excludes-cached";
@@ -136,30 +124,68 @@ export interface ServiceDeps {
             };
         };
     }) => void;
-    outcomeSink?: import("../plugins/file-outcome-sink.js").OutcomeSink;
-    memoryExport?: (scope: string) => Promise<MemoryEntry[]>;
-    memorySync?: (scope: string, syncReq: MemorySyncRequest) => Promise<MemorySyncResponse>;
-    instrumentDegenerate?: (result: TaskResult) => void;
-    planCacheProbe?: PlanCacheProbe;
+    parkedReviveTool?: import("@sema-agent/core").ToolSpec;
+    parkedKnownAgentTypes?: ReadonlySet<string>;
+    parkedReviveInheritedGate?: (row: import("@sema-agent/core").BackgroundAgentRecord) => unknown;
+}
+export interface ServiceObservabilityDeps {
+    logger?: Logger;
+    metrics?: Metrics;
     modelUsage?: ModelUsageTracker;
     promptManifests?: PromptManifestTracker;
-    elicitation?: ElicitationCoordinator;
-    question?: QuestionCoordinator;
-    toolApproval?: ToolApprovalCoordinator;
-    sendUserFile?: import("../capabilities/send-user-file-tool.js").SendUserFileEmitter;
-    sendFileLedger?: import("../plugins/send-file-ledger.js").SendFileLedger;
-    sessionWatch?: import("../session-watch.js").SessionWatchRegistry;
-    sessionEventsMaxConnections?: number;
-    sessionEventsHeartbeatMs?: number;
-    sessionEventsStallMs?: number;
+    planCacheProbe?: PlanCacheProbe;
+}
+export interface ServiceGovernanceDeps {
+    authorize?: (ctx: {
+        req: IncomingMessage;
+        body: TaskRequestBody;
+    }) => Promise<RequestAuth>;
+    registryJwtVerifier?: {
+        verify: (bearer: string) => Promise<import("../auth-bridge.js").VerifyOutcome>;
+    };
+    rateLimiter?: RateGate;
+    costQuota?: QuotaTracker;
+    fleetLease?: FleetLeaseManager;
+}
+export interface ServiceDeploymentDeps {
+    instanceId?: string;
     capabilities?: Record<string, unknown>;
+    scenarioDetails?: Record<string, import("../capabilities/scenarios.js").ScenarioDetail>;
+    sessionStoreLabel?: string;
+    storeDegraded?: boolean;
+    drainState?: {
+        draining: boolean;
+        since?: number;
+        inflight?: () => number;
+        lastActivityAt?: () => number;
+    };
+    modelReady?: () => boolean;
     restartState?: () => RestartSignal | undefined;
     planeDeferredState?: () => {
         version: number;
         since: number;
         blocked?: string[];
     } | undefined;
+    workflowsCapable?: boolean;
+}
+export interface ServiceKnobDeps {
+    snapshotBlobSqlCapBytes?: number;
+    sessionEventsMaxConnections?: number;
+    sessionEventsHeartbeatMs?: number;
+    sessionEventsStallMs?: number;
+}
+export interface ServiceDepGroups {
+    stores?: ServiceStoreDeps;
+    coordinators?: ServiceCoordinatorDeps;
+    seams?: ServiceSeamDeps;
+    observability?: ServiceObservabilityDeps;
+    governance?: ServiceGovernanceDeps;
+    deployment?: ServiceDeploymentDeps;
+    knobs?: ServiceKnobDeps;
 }
+export type FlatServiceDeps = ServiceCoreDeps & Partial<ServiceStoreDeps & ServiceCoordinatorDeps & ServiceSeamDeps & ServiceObservabilityDeps & ServiceGovernanceDeps & ServiceDeploymentDeps & ServiceKnobDeps>;
+export type ServiceDeps = FlatServiceDeps & ServiceDepGroups;
+export declare function flattenServiceDeps(deps: ServiceDeps): FlatServiceDeps;
 export type { TaskRequestBody } from "./wire-types.js";
 export declare const MAX_USER_SKILLS = 10;
 export declare const MAX_SKILL_CONTENT_CHARS = 1048576;
@@ -175,7 +201,7 @@ export declare function cascadeConfig(ladder: readonly string[], maxCostUsd?: nu
 export declare function clampVerifyRounds(v: unknown): number;
 export declare function scopedIdempotencyKey(raw: string | undefined, source: string | null, principal: string | undefined): string | undefined;
 export declare function isQuestionAnswer(v: unknown): v is QuestionAnswer;
-export declare function createHttpServer(deps: ServiceDeps): http.Server & {
+export declare function createHttpServer(rawDeps: ServiceDeps): http.Server & {
     denyExpiredApprovals: (now: number) => Promise<void>;
 };
 export declare function streamApprovals(req: IncomingMessage, res: ServerResponse, cs: Pick<CheckpointStoreFull, "listPending">, scope: string | undefined, pollMs?: number): Promise<void>;

package/dist/http/server.js

@@ -35,6 +35,12 @@ import { redactSecrets, redactDeep, redactedPreview } from "../trace/redact.js";
 import { usageSummary, usageSeries, usageBreakdown } from "../usage-analytics.js";
 import { IdempotencyCache } from "./idempotency.js";
 import { pgHasUnstorable } from "../plugins/pg-safe-json.js";
+export function flattenServiceDeps(deps) {
+    const { stores, coordinators, seams, observability, governance, deployment, knobs, ...flat } = deps;
+    if (!(stores || coordinators || seams || observability || governance || deployment || knobs))
+        return deps;
+    return { ...stores, ...coordinators, ...seams, ...observability, ...governance, ...deployment, ...knobs, ...flat };
+}
 export const MAX_USER_SKILLS = 10;
 export const MAX_SKILL_CONTENT_CHARS = 1_048_576;
 export const MAX_SYSTEM_PROMPT_CHARS = 16_384;
@@ -195,7 +201,8 @@ function bearerPresentedButUnverified(req, config) {
         return false;
     return true;
 }
-export function createHttpServer(deps) {
+export function createHttpServer(rawDeps) {
+    const deps = flattenServiceDeps(rawDeps);
     const idemCache = new IdempotencyCache();
     let sseConnections = 0;
     let sseOwnerLookups = 0;

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,