@straiffi/archon 1.8.23 → 1.10.1

package/dist/server/lib/checkRunner.js

@@ -1,22 +1,22 @@
 import { randomUUID } from 'crypto';
-import { spawn } from 'child_process';
 import db from '../db.js';
-import { existsSync, lstatSync, realpathSync } from 'fs';
-import { basename, relative, resolve } from 'path';
+import { existsSync, lstatSync } from 'fs';
 import { StringDecoder } from 'string_decoder';
-import { findActiveCheckBatchForTarget, findActiveCheckAutoFixForTarget, canAutoFixStartCheckBatch, getCheckBatchDetails, getCheckAttemptDetails, inspectCheckBatchAggregation, listCheckAttemptDetails, rerunCheckBatch, setCheckBatchStopRequested, } from './checkRuns.js';
+import { isDeepStrictEqual } from 'node:util';
+import { findActiveCheckBatchForTarget, findActiveCheckAutoFixForTarget, canAutoFixStartCheckBatch, bindCheckBatchEnvironment, captureCheckAttemptPlacement, getCheckBatchDetails, getCheckAttemptDetails, inspectCheckBatchAggregation, listCheckAttemptDetails, rerunCheckBatch, setCheckBatchStopRequested, } from './checkRuns.js';
 import { getCheckDefinitionFingerprint } from './checkDefinitions.js';
 import { captureCheckWorkspaceIdentity } from './checkWorkspaceIdentity.js';
 import { getProjectById, getProjectCheckDefinitions } from './projects.js';
 import { aggregateCheckBatch, completeCheckAttempt, startCheckAttempt, withExecutionRunTransaction, } from './executionRuns.js';
-import { resolveCommandWorkspacePath } from './testCommandRunner.js';
-import { createWorkspaceProcessEnvironment } from './workspaceProcessEnvironment.js';
-import { createGovernedHostRuntimeEnvironment } from './workspaceProcessEnvironment.js';
+import { resolveDefinitionCwd } from './checkDefinitionCwd.js';
+import { getHostShellArguments, resolveShell } from './shell.js';
 import { cancelApprovalRequest, consumeApprovalRequest, createApprovalRequestInTransaction, emitApprovalRequestCreated, getApprovalRequest, invalidateApprovalRequest, registerApprovalRequestTerminalHandler, } from './approvalRequests.js';
 import { fingerprintConsequentialAction } from './consequentialActions.js';
 import { buildProductionCheckAction, PRODUCTION_CHECK_APPROVAL_TTL_MS } from './productionCheckApprovals.js';
 import { appendCheckAttemptEvidence, appendCheckDiagnostics, completeCheckDiagnosticParser, initializeCheckDiagnosticParser, } from './checkDiagnostics.js';
 import { createCheckDiagnosticParserSession } from './checkDiagnosticParsers.js';
+import { resolveCheckBatchExecutionEnvironment } from './checkExecutionEnvironment.js';
+import { createExecutionProfileSelectionMetadata } from './executionRunAuthority.js';
 const MAX_CONCURRENT_CHECK_ATTEMPTS = 2;
 const OUTPUT_FLUSH_BYTES = 32 * 1024;
 const OUTPUT_FLUSH_DELAY_MS = 25;
@@ -42,6 +42,8 @@ const invalidatedBatches = new Set();
 const stoppedBatches = new Set();
 const forcedAttemptOutcomes = new Map();
 const batchWaiters = new Map();
+const batchExecutions = new Map();
+const batchReleasePromises = new Map();
 let admittedAttempts = 0;
 let acceptingAdmissions = true;
 let inFlightAdmissions = 0;
@@ -76,63 +78,13 @@ export const closeCheckRunnerAdmissions = () => {
 export const openCheckRunnerAdmissions = () => {
     acceptingAdmissions = true;
 };
-const resolveShell = () => process.env.SHELL?.trim() || '/bin/zsh';
 export const getCheckShellArguments = (shell, command, governedProductionEnvironment = false) => {
-    if (!governedProductionEnvironment) {
-        return ['-i', '-c', command];
-    }
-    const shellName = basename(shell);
-    if (shellName === 'zsh') {
-        return ['-f', '-c', command];
-    }
-    if (shellName === 'bash') {
-        return ['--noprofile', '--norc', '-c', command];
-    }
-    if (shellName === 'fish') {
-        return ['--no-config', '-c', command];
-    }
-    return ['-c', command];
-};
-const createShellEnvironment = (cwd, definition, governedProductionEnvironment = false) => {
-    const env = definition.consequence === 'production' && governedProductionEnvironment
-        ? createGovernedHostRuntimeEnvironment(cwd).variables
-        : createWorkspaceProcessEnvironment(cwd);
-    delete env.PORT;
-    return env;
+    return getHostShellArguments(shell, command, !governedProductionEnvironment);
 };
 const identitiesMatch = (left, right) => (left.state === 'available'
     && right.state === 'available'
     && left.fingerprint === right.fingerprint);
-const isPathInside = (root, candidate) => {
-    const pathFromRoot = relative(root, candidate).replaceAll('\\', '/');
-    return pathFromRoot === '' || (!pathFromRoot.startsWith('..') && !pathFromRoot.includes('/../'));
-};
-export const resolveDefinitionCwd = (workspaceCwd, definition) => {
-    const workspacePath = resolveCommandWorkspacePath(definition);
-    if (!workspacePath) {
-        return workspaceCwd;
-    }
-    const resolvedPath = resolve(workspaceCwd, workspacePath);
-    if (!isPathInside(workspaceCwd, resolvedPath)) {
-        throw new Error(`Check definition ${definition.id} working directory must stay inside the target workspace`);
-    }
-    let realWorkspacePath;
-    let realResolvedPath;
-    try {
-        realWorkspacePath = realpathSync(workspaceCwd);
-        realResolvedPath = realpathSync(resolvedPath);
-    }
-    catch {
-        throw new Error(`Check definition ${definition.id} working directory is unavailable`);
-    }
-    if (!isPathInside(realWorkspacePath, realResolvedPath)) {
-        throw new Error(`Check definition ${definition.id} working directory must stay inside the target workspace`);
-    }
-    if (!lstatSync(realResolvedPath).isDirectory()) {
-        throw new Error(`Check definition ${definition.id} working directory is unavailable`);
-    }
-    return definition.cwd?.trim() ? realResolvedPath : workspaceCwd;
-};
+export { resolveDefinitionCwd } from './checkDefinitionCwd.js';
 const validateDefinitions = (selectedDefinitions, availableDefinitions) => {
     if (selectedDefinitions.length === 0) {
         throw new Error('At least one check definition must be selected');
@@ -298,29 +250,93 @@ const appendProcessOutput = (record, text) => {
         record.flushTimer = setTimeout(() => requestOutputFlush(record), OUTPUT_FLUSH_DELAY_MS);
     }
 };
-const signalProcessGroup = (child, signal) => {
-    if (child.pid && process.platform !== 'win32') {
-        try {
-            process.kill(-child.pid, signal);
-            return;
-        }
-        catch (error) {
-            if (error.code === 'ESRCH') {
-                return;
+const terminateProcess = (record) => {
+    if (record.batchExecution.environment.provider === 'docker_sandbox' && record.terminalCause !== 'user_stop') {
+        for (const sibling of processes.values()) {
+            if (sibling.batchRunId === record.batchRunId && sibling.attemptRunId !== record.attemptRunId) {
+                sibling.terminalCause ??= 'environment_loss';
             }
         }
+        void captureCheckWorkspaceIdentity(record.cwd).then(identity => (failQueuedBatch(record.batchRunId, 'environment_loss', identity))).catch(error => {
+            console.error('Unable to terminalize queued attempts after sandbox loss', {
+                batch_run_id: record.batchRunId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
+    void record.handle.interrupt('SIGTERM');
+    if (!record.killTimer) {
+        record.killTimer = setTimeout(() => void record.handle.interrupt('SIGKILL'), STOP_GRACE_MS);
     }
+};
+const releaseBatchExecution = (batchRunId) => {
+    const existing = batchReleasePromises.get(batchRunId);
+    if (existing) {
+        return existing;
+    }
+    const execution = batchExecutions.get(batchRunId);
+    if (!execution) {
+        return Promise.resolve();
+    }
+    const release = execution.execution.release().finally(() => {
+        batchExecutions.delete(batchRunId);
+        batchReleasePromises.delete(batchRunId);
+    });
+    batchReleasePromises.set(batchRunId, release);
+    return release;
+};
+const restoreBatchExecution = async (input) => {
+    if (!input.batch.batch_environment || !input.batch.runtime_compatibility || !input.attempt.placement) {
+        throw new Error('Check batch execution evidence is incomplete');
+    }
+    const project = getProjectById(input.projectId);
+    if (!project) {
+        throw new Error('The check batch project is unavailable');
+    }
+    const execution = await resolveCheckBatchExecutionEnvironment({
+        project,
+        batchRunId: input.batch.execution_run_id,
+        targetKind: input.batch.target_kind,
+        targetBundleId: input.batch.target_bundle_id,
+        cwd: input.workspaceCwd,
+        pinnedEnvironment: input.batch.batch_environment,
+    });
+    const restoredPlacement = execution.createAttemptPlacement(input.attempt.execution_run_id);
+    if (!isDeepStrictEqual(execution.environment, input.batch.batch_environment)
+        || !isDeepStrictEqual(execution.compatibility, input.batch.runtime_compatibility)
+        || !isDeepStrictEqual(restoredPlacement, input.attempt.placement)) {
+        await execution.execution.release();
+        throw new Error('The persisted check batch execution environment could not be restored exactly');
+    }
+    batchExecutions.set(input.batch.execution_run_id, execution);
+    return execution;
+};
+const rollbackUnadmittedBatch = async (input) => {
+    await releaseBatchExecution(input.batchRunId);
     try {
-        child.kill(signal);
+        db.transaction(() => {
+            db.prepare('DELETE FROM execution_runs WHERE parent_run_id = ? AND project_id = ?').run(input.batchRunId, input.projectId);
+            db.prepare('DELETE FROM execution_runs WHERE id = ? AND project_id = ?').run(input.batchRunId, input.projectId);
+        })();
+        return;
     }
     catch {
-        // The process may have exited between the liveness check and the signal.
-    }
-};
-const terminateProcess = (record) => {
-    signalProcessGroup(record.child, 'SIGTERM');
-    if (!record.killTimer) {
-        record.killTimer = setTimeout(() => signalProcessGroup(record.child, 'SIGKILL'), STOP_GRACE_MS);
+        const message = input.error instanceof Error ? input.error.message : String(input.error);
+        for (const attemptRunId of input.attemptRunIds) {
+            const attempt = getCheckAttemptDetails(input.projectId, attemptRunId);
+            if (!attempt?.outcome) {
+                completeCheckAttempt({
+                    projectId: input.projectId,
+                    runId: attemptRunId,
+                    outcome: 'infrastructure_failure',
+                    finalWorkspaceIdentity: input.identity,
+                    exitError: `Check batch environment admission failed: ${message}`,
+                }, input.emitter);
+            }
+        }
+        aggregateCheckBatch(input.projectId, input.batchRunId, input.emitter, {
+            finalWorkspaceIdentity: input.identity,
+        });
     }
 };
 const waitForProcessFinalization = (record) => {
@@ -364,6 +380,7 @@ const aggregateBatchAfterAttempt = async (entry) => {
     aggregateCheckBatch(entry.projectId, entry.batchRunId, entry.emitter, {
         finalWorkspaceIdentity: batchFinalIdentity,
     });
+    await releaseBatchExecution(entry.batchRunId);
 };
 const completeAttempt = async (entry, outcome, finalIdentity, options = {}) => {
     completeCheckAttempt({
@@ -390,6 +407,7 @@ const finalizeProcess = (record, code, signal, error) => {
         clearTimeout(record.killTimer);
     }
     record.finalizationPromise = (async () => {
+        await record.placementVerificationPromise;
         appendProcessOutput(record, record.stdoutDecoder.end());
         appendProcessOutput(record, record.stderrDecoder.end());
         try {
@@ -455,7 +473,7 @@ const failQueuedBatch = async (batchRunId, outcome, identity) => {
         await completeAttempt(entry, outcome, identity, {
             exitError: outcome === 'workspace_changed_before_start'
                 ? 'Workspace identity changed before this check could start'
-                : null,
+                : outcome === 'environment_loss' ? 'The batch-owned sandbox was lost while sibling attempts were active' : null,
         });
     }
 };
@@ -486,7 +504,7 @@ const runQueuedAttempt = async (entry) => {
     if (entry.approvalRequestId) {
         const request = getApprovalRequest(entry.projectId, entry.approvalRequestId, { emitter: entry.emitter });
         const batch = getCheckBatchDetails(entry.projectId, entry.batchRunId);
-        if (!request || request.status !== 'consumed' || !batch) {
+        if (!request || request.status !== 'consumed' || request.action.kind !== 'custom_check' || !batch) {
             throw new Error('Production check approval is no longer consumable');
         }
         const currentDefinitions = getProjectCheckDefinitions(getProjectById(entry.projectId));
@@ -502,6 +520,9 @@ const runQueuedAttempt = async (entry) => {
             batch,
             workspaceIdentity: identity,
             expiresAt: request.expires_at,
+            launcher: request.action.target.launcher ?? 'host_shell',
+            batchEnvironment: request.action.target.batch_environment ?? null,
+            attemptPlacement: entry.expectedPlacement,
         });
         if (fingerprintConsequentialAction(current.action) !== request.action_fingerprint) {
             throw new Error('Production check action changed before spawn');
@@ -513,15 +534,27 @@ const runQueuedAttempt = async (entry) => {
         runId: entry.attemptRunId,
     }, entry.emitter);
     await new Promise((resolveAttempt, rejectAttempt) => {
+        let handle;
         let child;
         try {
             const shell = resolveShell();
-            child = spawn(shell, getCheckShellArguments(shell, entry.definition.command, entry.governedProductionEnvironment), {
+            const runtimeEnvironment = entry.batchExecution.execution.runtimeEnvironment;
+            const governedHostEnvironment = entry.batchExecution.execution.provider.kind === 'host'
+                && runtimeEnvironment.kind === 'host'
+                && runtimeEnvironment.inheritance === 'governed';
+            handle = entry.batchExecution.execution.provider.execute({
+                phase: 'agent',
+                target: entry.batchExecution.target,
+                command: shell,
+                args: getCheckShellArguments(shell, entry.definition.command, entry.governedProductionEnvironment || governedHostEnvironment),
                 cwd: spawnCwd,
+                launcherEnvironment: entry.batchExecution.execution.launcherEnvironment,
+                runtimeEnvironment: entry.batchExecution.execution.runtimeEnvironment,
                 detached: process.platform !== 'win32',
-                env: createShellEnvironment(entry.cwd, entry.definition, entry.governedProductionEnvironment),
                 stdio: ['ignore', 'pipe', 'pipe'],
+                placementExecutionRunId: entry.attemptRunId,
             });
+            child = handle.child;
         }
         catch (error) {
             const spawnError = error instanceof Error ? error : new Error(String(error));
@@ -533,6 +566,7 @@ const runQueuedAttempt = async (entry) => {
         const record = {
             ...entry,
             child,
+            handle,
             stdoutDecoder: new StringDecoder('utf8'),
             stderrDecoder: new StringDecoder('utf8'),
             pendingOutput: '',
@@ -545,6 +579,7 @@ const runQueuedAttempt = async (entry) => {
             spawned: false,
             finalized: false,
             finalizationPromise: null,
+            placementVerificationPromise: Promise.resolve(),
             diagnosticParser: createCheckDiagnosticParserSession({
                 definition: entry.definition,
                 workspaceCwd: entry.cwd,
@@ -554,6 +589,22 @@ const runQueuedAttempt = async (entry) => {
             persistenceFailure: null,
         };
         processes.set(entry.attemptRunId, record);
+        record.placementVerificationPromise = Promise.all([
+            handle.placementFailure,
+            handle.placementIdentity ?? Promise.resolve(null),
+        ]).then(([failure, placement]) => {
+            if (failure
+                || (handle.placementIdentity && !placement)
+                || (placement && !isDeepStrictEqual(placement, entry.expectedPlacement))) {
+                record.terminalCause ??= 'infrastructure_failure';
+                terminateProcess(record);
+            }
+        }).catch(() => {
+            if (!record.terminalCause) {
+                record.terminalCause ??= 'infrastructure_failure';
+                terminateProcess(record);
+            }
+        });
         child.once('spawn', () => {
             record.spawned = true;
         });
@@ -629,6 +680,8 @@ const enqueueCheckAttempts = (input) => {
         emitter: input.emitter,
         approvalRequestId: attempt.approvalRequestId,
         governedProductionEnvironment: attempt.governedProductionEnvironment,
+        batchExecution: input.batchExecution,
+        expectedPlacement: attempt.expectedPlacement,
     })));
     pumpScheduler();
 };
@@ -670,7 +723,11 @@ export const startCheckBatch = async (input, emitter) => withCheckAdmission(asyn
     if (initialIdentity.state !== 'available') {
         throw new Error(`Check workspace identity is unavailable: ${initialIdentity.message}`);
     }
-    const currentDefinitions = getProjectCheckDefinitions(getProjectById(input.projectId));
+    const project = getProjectById(input.projectId);
+    if (!project) {
+        throw new Error(`Project ${input.projectId} was not found`);
+    }
+    const currentDefinitions = getProjectCheckDefinitions(project);
     validateDefinitions(input.selectedDefinitions, currentDefinitions);
     for (const definition of input.selectedDefinitions) {
         resolveDefinitionCwd(input.cwd, definition);
@@ -685,86 +742,136 @@ export const startCheckBatch = async (input, emitter) => withCheckAdmission(asyn
     const scopeLinks = targetBundleId
         ? [{ entityType: 'bundle', entityId: targetBundleId, relationship: 'context' }]
         : [];
-    withExecutionRunTransaction(transaction => {
-        const transactionConflict = findActiveCheckBatchForTarget(input.projectId, input.targetKind, targetBundleId);
-        if (transactionConflict) {
-            throw new Error(`Check batch ${transactionConflict} is already active for this target`);
-        }
-        const transactionAutoFixConflict = findActiveCheckAutoFixForTarget(input.projectId, input.targetKind, targetBundleId);
-        if (transactionAutoFixConflict && transactionAutoFixConflict !== input.autoFixParentRunId) {
-            throw new Error(`Check auto-fix ${transactionAutoFixConflict} is already active for this target`);
-        }
-        assertAutoFixAdmission();
-        transaction.createExecutionRun({
-            id: batchRunId,
-            projectId: input.projectId,
-            kind: 'check_batch',
-            initiatedBy: input.automationParentRunId || input.autoFixParentRunId ? 'automation' : input.postBuildParentRunId ? 'system' : 'user',
-            parentRunId: input.automationParentRunId ?? input.postBuildParentRunId ?? input.autoFixParentRunId ?? null,
-            domainStatus: 'queued',
-            metadata: input.automationBoundaryKind ? { automation_boundary_kind: input.automationBoundaryKind } : null,
-            sourceReference: input.sourceReference ?? null,
-            links: scopeLinks,
-            eventType: 'check_batch_created',
-            allowedActiveAutomationChildRunId: input.allowedActiveAutomationChildRunId,
-            checkBatchDetails: {
-                ...checkTarget,
-                targetLabel: input.targetLabel,
-                selectedDefinitions: input.selectedDefinitions,
-                initialWorkspaceIdentity: initialIdentity,
-                rerunOfBatchRunId: input.rerunOfBatchRunId,
-                automationBoundaryPurpose,
-                purpose: input.autoFixParentRunId ? 'auto_fix' : input.postBuildParentRunId ? 'post_build' : input.automationParentRunId ? 'automation_gate' : 'manual',
-                causalSourceRunId: input.autoFixOriginBatchRunId ?? input.postBuildParentRunId ?? null,
-            },
-        });
-        for (const attempt of attempts) {
+    let batchExecution;
+    let placements;
+    try {
+        withExecutionRunTransaction(transaction => {
+            const transactionConflict = findActiveCheckBatchForTarget(input.projectId, input.targetKind, targetBundleId);
+            if (transactionConflict) {
+                throw new Error(`Check batch ${transactionConflict} is already active for this target`);
+            }
+            const transactionAutoFixConflict = findActiveCheckAutoFixForTarget(input.projectId, input.targetKind, targetBundleId);
+            if (transactionAutoFixConflict && transactionAutoFixConflict !== input.autoFixParentRunId) {
+                throw new Error(`Check auto-fix ${transactionAutoFixConflict} is already active for this target`);
+            }
+            assertAutoFixAdmission();
             transaction.createExecutionRun({
-                id: attempt.runId,
+                id: batchRunId,
                 projectId: input.projectId,
-                kind: 'check_attempt',
-                parentRunId: batchRunId,
-                sourceReference: { kind: 'project', id: input.projectId },
-                links: scopeLinks,
+                kind: 'check_batch',
+                initiatedBy: input.automationParentRunId || input.autoFixParentRunId ? 'automation' : input.postBuildParentRunId ? 'system' : 'user',
+                parentRunId: input.automationParentRunId ?? input.postBuildParentRunId ?? input.autoFixParentRunId ?? null,
                 domainStatus: 'queued',
-                eventType: 'check_attempt_created',
-                checkAttemptDetails: {
-                    batchRunId,
-                    definition: attempt.definition,
+                metadata: {
+                    ...createExecutionProfileSelectionMetadata(input.projectId),
+                    ...(input.automationBoundaryKind ? { automation_boundary_kind: input.automationBoundaryKind } : {}),
+                },
+                sourceReference: input.sourceReference ?? null,
+                links: scopeLinks,
+                eventType: 'check_batch_created',
+                allowedActiveAutomationChildRunId: input.allowedActiveAutomationChildRunId,
+                checkBatchDetails: {
+                    ...checkTarget,
+                    targetLabel: input.targetLabel,
+                    selectedDefinitions: input.selectedDefinitions,
                     initialWorkspaceIdentity: initialIdentity,
-                    rerunOfAttemptRunId: input.rerunAttemptRunIds?.[attempt.definition.id] ?? null,
+                    rerunOfBatchRunId: input.rerunOfBatchRunId,
+                    automationBoundaryPurpose,
+                    purpose: input.autoFixParentRunId ? 'auto_fix' : input.postBuildParentRunId ? 'post_build' : input.automationParentRunId ? 'automation_gate' : 'manual',
+                    causalSourceRunId: input.autoFixOriginBatchRunId ?? input.postBuildParentRunId ?? null,
                 },
             });
-        }
-        const batch = getCheckBatchDetails(input.projectId, batchRunId);
-        for (const attempt of attempts.filter(candidate => candidate.definition.consequence === 'production')) {
-            const expiresAt = new Date(Date.now() + PRODUCTION_CHECK_APPROVAL_TTL_MS).toISOString();
-            const approval = buildProductionCheckAction({
+            for (const attempt of attempts) {
+                transaction.createExecutionRun({
+                    id: attempt.runId,
+                    projectId: input.projectId,
+                    kind: 'check_attempt',
+                    parentRunId: batchRunId,
+                    sourceReference: { kind: 'project', id: input.projectId },
+                    links: scopeLinks,
+                    domainStatus: 'queued',
+                    eventType: 'check_attempt_created',
+                    checkAttemptDetails: {
+                        batchRunId,
+                        definition: attempt.definition,
+                        initialWorkspaceIdentity: initialIdentity,
+                        rerunOfAttemptRunId: input.rerunAttemptRunIds?.[attempt.definition.id] ?? null,
+                    },
+                });
+            }
+            input.onBatchCreated?.(batchRunId);
+        }, emitter);
+        batchExecution = await resolveCheckBatchExecutionEnvironment({
+            project,
+            batchRunId,
+            targetKind: input.targetKind,
+            targetBundleId,
+            cwd: input.cwd,
+        });
+        batchExecutions.set(batchRunId, batchExecution);
+        bindCheckBatchEnvironment({
+            projectId: input.projectId,
+            batchRunId,
+            compatibility: batchExecution.compatibility,
+            environment: batchExecution.environment,
+        });
+        placements = new Map(attempts.map(attempt => {
+            const placement = batchExecution.createAttemptPlacement(attempt.runId);
+            captureCheckAttemptPlacement({ projectId: input.projectId, attemptRunId: attempt.runId, placement });
+            return [attempt.runId, placement];
+        }));
+        withExecutionRunTransaction(transaction => {
+            const batch = getCheckBatchDetails(input.projectId, batchRunId);
+            for (const attempt of attempts.filter(candidate => candidate.definition.consequence === 'production')) {
+                const expiresAt = new Date(Date.now() + PRODUCTION_CHECK_APPROVAL_TTL_MS).toISOString();
+                const placement = placements.get(attempt.runId);
+                const sandboxEnvironment = batchExecution.environment.provider === 'docker_sandbox'
+                    ? {
+                        id: batchExecution.environment.environment_id,
+                        revision: batchExecution.environment.environment_revision,
+                        validation_fingerprint: batchExecution.environment.environment_validation_fingerprint,
+                    }
+                    : null;
+                const approval = buildProductionCheckAction({
+                    projectId: input.projectId,
+                    workspaceCwd: input.cwd,
+                    effectiveCwd: resolveDefinitionCwd(input.cwd, attempt.definition),
+                    definition: attempt.definition,
+                    batch,
+                    workspaceIdentity: initialIdentity,
+                    expiresAt,
+                    launcher: sandboxEnvironment ? 'docker_sandbox_exec' : 'host_shell',
+                    batchEnvironment: sandboxEnvironment,
+                    attemptPlacement: placement,
+                });
+                createdApprovals.push(createApprovalRequestInTransaction({
+                    projectId: input.projectId,
+                    executionRunId: attempt.runId,
+                    action: approval.action,
+                    authority: approval.authority,
+                    expiresAt,
+                }, transaction));
+            }
+            transaction.transitionExecutionRun({
                 projectId: input.projectId,
-                workspaceCwd: input.cwd,
-                effectiveCwd: resolveDefinitionCwd(input.cwd, attempt.definition),
-                definition: attempt.definition,
-                batch,
-                workspaceIdentity: initialIdentity,
-                expiresAt,
+                runId: batchRunId,
+                status: 'running',
+                domainStatus: 'running',
+                eventType: 'check_batch_started',
             });
-            createdApprovals.push(createApprovalRequestInTransaction({
-                projectId: input.projectId,
-                executionRunId: attempt.runId,
-                action: approval.action,
-                authority: approval.authority,
-                expiresAt,
-            }, transaction));
-        }
-        input.onBatchCreated?.(batchRunId);
-        transaction.transitionExecutionRun({
+        }, emitter);
+    }
+    catch (error) {
+        await rollbackUnadmittedBatch({
             projectId: input.projectId,
-            runId: batchRunId,
-            status: 'running',
-            domainStatus: 'running',
-            eventType: 'check_batch_started',
+            batchRunId,
+            attemptRunIds: attempts.map(attempt => attempt.runId),
+            identity: initialIdentity,
+            error,
+            emitter,
         });
-    }, emitter);
+        throw error;
+    }
     for (const approval of createdApprovals) {
         emitApprovalRequestCreated(emitter, approval);
     }
@@ -773,8 +880,12 @@ export const startCheckBatch = async (input, emitter) => withCheckAdmission(asyn
         projectId: input.projectId,
         batchRunId,
         cwd: input.cwd,
-        attempts: ordinaryAttempts,
+        attempts: ordinaryAttempts.map(attempt => ({
+            ...attempt,
+            expectedPlacement: placements.get(attempt.runId),
+        })),
         initialIdentity,
+        batchExecution,
         emitter,
     });
     return getCheckBatchDetails(input.projectId, batchRunId);
@@ -797,7 +908,11 @@ export const rerunCheckBatchAndSchedule = async (input, emitter) => withCheckAdm
     if (initialIdentity.state !== 'available') {
         throw new Error(`Check workspace identity is unavailable: ${initialIdentity.message}`);
     }
-    const currentDefinitions = getProjectCheckDefinitions(getProjectById(input.projectId));
+    const project = getProjectById(input.projectId);
+    if (!project) {
+        throw new Error(`Project ${input.projectId} was not found`);
+    }
+    const currentDefinitions = getProjectCheckDefinitions(project);
     const currentById = new Map(currentDefinitions.map(definition => [definition.id, definition]));
     for (const definitionId of selectedDefinitionIds) {
         const definition = currentById.get(definitionId);
@@ -815,29 +930,76 @@ export const rerunCheckBatchAndSchedule = async (input, emitter) => withCheckAdm
             selection: input.selection,
             availableDefinitions: currentDefinitions,
             initialWorkspaceIdentity: initialIdentity,
+            profileSelectionMetadata: createExecutionProfileSelectionMetadata(input.projectId),
         });
-        const batch = getCheckBatchDetails(input.projectId, result.batchRunId);
-        for (const attempt of result.attempts.filter(candidate => candidate.definition.consequence === 'production')) {
-            const expiresAt = new Date(Date.now() + PRODUCTION_CHECK_APPROVAL_TTL_MS).toISOString();
-            const approval = buildProductionCheckAction({
-                projectId: input.projectId,
-                workspaceCwd: input.cwd,
-                effectiveCwd: resolveDefinitionCwd(input.cwd, attempt.definition),
-                definition: attempt.definition,
-                batch,
-                workspaceIdentity: initialIdentity,
-                expiresAt,
-            });
-            createdApprovals.push(createApprovalRequestInTransaction({
-                projectId: input.projectId,
-                executionRunId: attempt.runId,
-                action: approval.action,
-                authority: approval.authority,
-                expiresAt,
-            }, transaction));
-        }
         return result;
     }, emitter);
+    let batchExecution;
+    let placements;
+    try {
+        batchExecution = await resolveCheckBatchExecutionEnvironment({
+            project,
+            batchRunId: created.batchRunId,
+            targetKind: created.batch.target_kind,
+            targetBundleId: created.batch.target_bundle_id,
+            cwd: input.cwd,
+        });
+        batchExecutions.set(created.batchRunId, batchExecution);
+        bindCheckBatchEnvironment({
+            projectId: input.projectId,
+            batchRunId: created.batchRunId,
+            compatibility: batchExecution.compatibility,
+            environment: batchExecution.environment,
+        });
+        placements = new Map(created.attempts.map(attempt => {
+            const placement = batchExecution.createAttemptPlacement(attempt.runId);
+            captureCheckAttemptPlacement({ projectId: input.projectId, attemptRunId: attempt.runId, placement });
+            return [attempt.runId, placement];
+        }));
+        withExecutionRunTransaction(transaction => {
+            const batch = getCheckBatchDetails(input.projectId, created.batchRunId);
+            for (const attempt of created.attempts.filter(candidate => candidate.definition.consequence === 'production')) {
+                const expiresAt = new Date(Date.now() + PRODUCTION_CHECK_APPROVAL_TTL_MS).toISOString();
+                const sandboxEnvironment = batchExecution.environment.provider === 'docker_sandbox'
+                    ? {
+                        id: batchExecution.environment.environment_id,
+                        revision: batchExecution.environment.environment_revision,
+                        validation_fingerprint: batchExecution.environment.environment_validation_fingerprint,
+                    }
+                    : null;
+                const approval = buildProductionCheckAction({
+                    projectId: input.projectId,
+                    workspaceCwd: input.cwd,
+                    effectiveCwd: resolveDefinitionCwd(input.cwd, attempt.definition),
+                    definition: attempt.definition,
+                    batch,
+                    workspaceIdentity: initialIdentity,
+                    expiresAt,
+                    launcher: sandboxEnvironment ? 'docker_sandbox_exec' : 'host_shell',
+                    batchEnvironment: sandboxEnvironment,
+                    attemptPlacement: placements.get(attempt.runId),
+                });
+                createdApprovals.push(createApprovalRequestInTransaction({
+                    projectId: input.projectId,
+                    executionRunId: attempt.runId,
+                    action: approval.action,
+                    authority: approval.authority,
+                    expiresAt,
+                }, transaction));
+            }
+        }, emitter);
+    }
+    catch (error) {
+        await rollbackUnadmittedBatch({
+            projectId: input.projectId,
+            batchRunId: created.batchRunId,
+            attemptRunIds: created.attempts.map(attempt => attempt.runId),
+            identity: initialIdentity,
+            error,
+            emitter,
+        });
+        throw error;
+    }
     for (const approval of createdApprovals) {
         emitApprovalRequestCreated(emitter, approval);
     }
@@ -846,12 +1008,16 @@ export const rerunCheckBatchAndSchedule = async (input, emitter) => withCheckAdm
         projectId: input.projectId,
         batchRunId: created.batchRunId,
         cwd: input.cwd,
-        attempts: ordinaryAttempts,
+        attempts: ordinaryAttempts.map(attempt => ({
+            ...attempt,
+            expectedPlacement: placements.get(attempt.runId),
+        })),
         initialIdentity,
+        batchExecution,
         emitter,
     });
     return {
-        batch: created.batch,
+        batch: getCheckBatchDetails(input.projectId, created.batchRunId),
         attempts: listCheckAttemptDetails(input.projectId, created.batchRunId),
     };
 });
@@ -927,7 +1093,20 @@ export const resumeProductionCheckApproval = async (projectId, requestId, emitte
         invalidateApprovalRequest({ projectId, requestId, reason: 'check_batch_no_longer_active', emitter });
         return false;
     }
+    if (!batch.batch_environment || !batch.runtime_compatibility || !attempt.placement) {
+        invalidateApprovalRequest({ projectId, requestId, reason: 'check_batch_environment_unavailable', emitter });
+        return false;
+    }
+    const attemptPlacement = attempt.placement;
     const workspaceCwd = request.action.workspace_git.workspace_path;
+    let batchExecution = batchExecutions.get(batch.execution_run_id);
+    try {
+        batchExecution ??= await restoreBatchExecution({ projectId, workspaceCwd, batch, attempt });
+    }
+    catch {
+        invalidateApprovalRequest({ projectId, requestId, reason: 'check_batch_environment_unavailable', emitter });
+        return false;
+    }
     let currentIdentity;
     let currentDefinition;
     try {
@@ -964,6 +1143,9 @@ export const resumeProductionCheckApproval = async (projectId, requestId, emitte
             batch,
             workspaceIdentity: currentIdentity,
             expiresAt: request.expires_at,
+            launcher: request.action.target.launcher ?? 'host_shell',
+            batchEnvironment: request.action.target.batch_environment ?? null,
+            attemptPlacement,
         });
     }
     catch {
@@ -986,8 +1168,10 @@ export const resumeProductionCheckApproval = async (projectId, requestId, emitte
                 definition: currentDefinition,
                 approvalRequestId: requestId,
                 governedProductionEnvironment: request.authority.selected_profile.compatibility === 'governed',
+                expectedPlacement: attemptPlacement,
             }],
         initialIdentity: attempt.initial_workspace_identity,
+        batchExecution,
         emitter,
     });
     return true;
@@ -1003,6 +1187,15 @@ export const finalizeProductionCheckApproval = (projectId, requestId, emitter) =
     }
     aggregateCheckBatch(projectId, attempt.batch_run_id, emitter);
     notifyBatchWaiters(projectId, attempt.batch_run_id);
+    const batch = getCheckBatchDetails(projectId, attempt.batch_run_id);
+    if (batch && ['completed', 'failed', 'cancelled', 'interrupted'].includes(batch.execution_status)) {
+        void releaseBatchExecution(attempt.batch_run_id).catch(error => {
+            console.error('Check batch environment release failed', {
+                batch_run_id: attempt.batch_run_id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
 };
 registerApprovalRequestTerminalHandler((request, emitter) => {
     if (request.action_kind === 'custom_check') {
@@ -1083,6 +1276,9 @@ export const shutdownCheckRunner = async () => {
         }));
     }
     finally {
+        await Promise.all([...batchIds]
+            .filter(batchRunId => !approvalHeldBatchIds.has(batchRunId))
+            .map(releaseBatchExecution));
         for (const batchRunId of batchIds) {
             for (const attempt of durableAttempts.filter(candidate => candidate.batch_run_id === batchRunId)) {
                 forcedAttemptOutcomes.delete(attempt.attempt_run_id);