@straiffi/archon 1.8.20 → 1.8.22

package/dist/server/lib/buildExecutionEnvironment.js

@@ -1,14 +1,18 @@
 import db from '../db.js';
 import { ExecutionEnvironmentFailure, } from './executionEnvironment.js';
-import { QUALIFIED_DOCKER_SANDBOX_TEMPLATES, QUALIFIED_SBX_VERSION, } from './dockerSandboxExecutionEnvironment.js';
+import { QUALIFIED_DOCKER_SANDBOX_TEMPLATES, QUALIFIED_SBX_VERSION, DockerSandboxNetworkRollbackFailure, proveScopedDestinationAccess, removeScopedRulesBestEffort, } from './dockerSandboxExecutionEnvironment.js';
 import { createDockerSandboxExecutionProvider } from './dockerSandboxExecutionProvider.js';
 import { createDockerSandboxOpencodeSessionOperations } from './dockerSandboxOpencodeSessionOperations.js';
 import { defaultDockerSandboxEnvironmentDependencies, dockerSandboxRunner, ensureDockerSandboxRuntimeReady, reconnectAndInspectDockerSandbox, resolveExpectedDockerSandboxIdentity, stopAndVerifyDockerSandbox, } from './dockerSandboxEnvironmentOperations.js';
 import { ExecutionEnvironmentRouteError, currentExecutionEnvironmentValidationFingerprint, prepareAndValidateExecutionEnvironmentForTarget, validateExecutionEnvironmentForTarget, } from './executionEnvironmentValidationOperations.js';
 import { validateExecutionEnvironmentSkills } from './executionEnvironmentValidation.js';
-import { acquireExecutionEnvironmentLease, captureExecutionEnvironmentPlacement, getExecutionEnvironment, getExecutionEnvironmentBindingForRun, listExecutionEnvironments, releaseExecutionEnvironmentLease, transitionExecutionEnvironment, } from './executionEnvironments.js';
+import { acquireExecutionEnvironmentLease, appendExecutionEnvironmentEvent, captureExecutionEnvironmentPlacement, getExecutionEnvironment, getExecutionEnvironmentBindingForRun, listExecutionEnvironments, releaseExecutionEnvironmentLease, transitionExecutionEnvironment, } from './executionEnvironments.js';
 import { hostExecutionEnvironment } from './hostExecutionEnvironment.js';
 import { getModelProvider, normalizeModelId } from './models.js';
+import { createExecutionRunAuthority, persistExecutionRunAuthority, resolveEnvironmentCredentialEvidence, resolveExecutionRunProfile, } from './executionRunAuthority.js';
+import { fingerprintCredentialRequirements } from './executionProfiles.js';
+import { normalizeExecutionEnvironmentDestinations } from './executionEnvironmentLifecycle.js';
+import { createDockerSandboxLauncherEnvironment, createGovernedHostRuntimeEnvironment, createHostLauncherEnvironment, createLegacyHostRuntimeEnvironment, createProviderManagedRuntimeEnvironment, } from './workspaceProcessEnvironment.js';
 export class BuildExecutionEnvironmentFailure extends Error {
     code;
     remediation;
@@ -26,7 +30,7 @@ const describePreparationFailure = (error) => {
     return '';
 };
 const getLatestValidation = (projectId, environmentId, agent, provider) => db.prepare(`
-    SELECT run.status, run.domain_status, run.metadata_json
+    SELECT run.id, run.status, run.domain_status, run.metadata_json
     FROM execution_environment_run_bindings binding
     JOIN execution_runs run ON run.id = binding.execution_run_id AND run.project_id = binding.project_id
     WHERE binding.project_id = ? AND binding.environment_id = ?
@@ -82,7 +86,45 @@ const validationProvider = (row) => {
         return null;
     }
 };
-const findExecutionEnvironment = (project, agent, target, pinnedEnvironmentId, pinnedEnvironmentRevision, pinnedEnvironmentValidationFingerprint) => {
+const getValidationCredentialCapability = (projectId, environmentId, validationRunId) => {
+    const row = db.prepare(`
+    SELECT metadata_json
+    FROM execution_environment_events
+    WHERE project_id = ? AND environment_id = ?
+      AND event_type = 'environment_validation_completed'
+      AND json_extract(metadata_json, '$.executionRunId') = ?
+    ORDER BY sequence DESC
+    LIMIT 1
+  `).get(projectId, environmentId, validationRunId);
+    try {
+        const metadata = row?.metadata_json ? JSON.parse(row.metadata_json) : null;
+        const validation = metadata?.validation && typeof metadata.validation === 'object'
+            ? metadata.validation
+            : null;
+        const agent = validation?.agent && typeof validation.agent === 'object'
+            ? validation.agent
+            : null;
+        const value = validation?.credentialCapability ?? agent?.credentialCapability;
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return null;
+        }
+        const capability = value;
+        if ((capability.execution_provider !== 'host' && capability.execution_provider !== 'docker_sandbox')
+            || (capability.agent !== 'opencode' && capability.agent !== 'claude')
+            || capability.workload !== 'build'
+            || typeof capability.satisfies_requested_protection !== 'boolean'
+            || !capability.inventory
+            || !capability.destination
+            || typeof capability.classification !== 'string') {
+            return null;
+        }
+        return capability;
+    }
+    catch {
+        return null;
+    }
+};
+const findExecutionEnvironment = (project, agent, target, profileRevision, pinnedEnvironmentId, pinnedEnvironmentRevision, pinnedEnvironmentValidationFingerprint) => {
     const fingerprint = currentExecutionEnvironmentValidationFingerprint(agent);
     return listExecutionEnvironments(project.id).find(candidate => ((!pinnedEnvironmentId || candidate.id === pinnedEnvironmentId)
         && (pinnedEnvironmentRevision === undefined || candidate.environment_revision === pinnedEnvironmentRevision)
@@ -95,19 +137,24 @@ const findExecutionEnvironment = (project, agent, target, pinnedEnvironmentId, p
         && candidate.target_key === target.identity.key
         && candidate.target_workspace_path === target.workspacePath
         && candidate.environment_validation_fingerprint === fingerprint
+        && (candidate.execution_profile_fingerprint === profileRevision.fingerprint
+            || (profileRevision.revision === 0 && candidate.execution_profile_fingerprint == null))
+        && (candidate.credential_requirements_fingerprint === fingerprintCredentialRequirements(profileRevision.profile.credential_requirements)
+            || (profileRevision.revision === 0 && candidate.credential_requirements_fingerprint == null))
+        && candidate.retirement_requested_at == null
         && candidate.template_identity === QUALIFIED_DOCKER_SANDBOX_TEMPLATES[agent]
         && candidate.agent_identity === agent
         && candidate.compatible_agents.length === 1
         && candidate.compatible_agents[0] === agent
         && ['ready', 'running', 'stopped'].includes(candidate.lifecycle_state))) ?? null;
 };
-const resolveValidatedEnvironment = (project, agent, target, model, pinnedEnvironmentId, pinnedEnvironmentRevision, pinnedEnvironmentValidationFingerprint) => {
+const resolveValidatedEnvironment = (project, agent, target, model, profileRevision, pinnedEnvironmentId, pinnedEnvironmentRevision, pinnedEnvironmentValidationFingerprint) => {
     const requestedModel = agent === 'opencode' ? normalizeModelId(model) : null;
     const requestedProvider = agent === 'opencode' ? getModelProvider(requestedModel) : 'anthropic';
     if (agent === 'opencode' && !requestedProvider) {
         throw new BuildExecutionEnvironmentFailure('validation_provider_missing', 'OpenCode Build requires a model with a provider before a Docker Sandbox can be used.', 'Choose a provider-backed OpenCode model for this ticket, then retry Build.');
     }
-    const environment = findExecutionEnvironment(project, agent, target, pinnedEnvironmentId, pinnedEnvironmentRevision, pinnedEnvironmentValidationFingerprint);
+    const environment = findExecutionEnvironment(project, agent, target, profileRevision, pinnedEnvironmentId, pinnedEnvironmentRevision, pinnedEnvironmentValidationFingerprint);
     if (!environment) {
         throw new BuildExecutionEnvironmentFailure('environment_missing', 'No validated Docker Sandbox matches this exact Build target and agent.', `Select this target and validate its ${agent} Docker Sandbox before starting Build.`);
     }
@@ -136,6 +183,7 @@ const validateBuildProvider = async (input) => {
         target: input.target,
         initiatedBy: 'automation',
         signal: input.signal,
+        profileRevision: input.profileRevision,
     }, {
         adapter: input.dependencies.adapter,
         runtimeController: input.dependencies.runtimeController,
@@ -145,7 +193,7 @@ const validateBuildProvider = async (input) => {
         throw new BuildExecutionEnvironmentFailure('validation_stale', 'The Docker Sandbox could not validate the exact Build provider and target.', `Resolve ${input.agent} authentication and provider access, validate the exact target, then retry Build.`);
     }
 };
-const createAuthority = (environment, agent) => ({
+const createAuthority = (environment, agent, credentialEvidence) => ({
     schema_version: 1,
     provider: 'docker_sandbox',
     provider_version: environment.provider_version,
@@ -158,10 +206,13 @@ const createAuthority = (environment, agent) => ({
         workspace_path: environment.target_workspace_path,
     },
     capabilities: environment.capabilities,
-    degradation_reasons: environment.workspace_mode === 'direct' ? ['direct_workspace_writable'] : [],
+    degradation_reasons: [
+        ...(environment.workspace_mode === 'direct' ? ['direct_workspace_writable'] : []),
+        ...credentialEvidence.degradation_reasons,
+    ],
     agent,
-    authentication_mode: 'validated_guest',
-    credential_delivery: 'sandbox_template',
+    authentication_mode: credentialEvidence.authentication_mode,
+    credential_delivery: credentialEvidence.credential_delivery,
 });
 const parsePlacement = (value) => {
     if (!value) {
@@ -287,68 +338,171 @@ export const recordBuildExecutionProvider = (projectId, executionRunId, provider
     }
 };
 export const resolveBuildExecutionEnvironment = async (input) => {
-    if (input.project.build_execution_provider !== 'docker_sandbox') {
-        return { provider: hostExecutionEnvironment, environment: null, authority: null, release: async () => { } };
+    const profileRevision = resolveExecutionRunProfile(input.project, input.executionRunId);
+    const selectedProvider = profileRevision.profile.provider_preference;
+    const hasPinnedEnvironmentLineage = input.pinnedEnvironmentId !== undefined
+        || input.pinnedEnvironmentRevision !== undefined
+        || input.pinnedEnvironmentValidationFingerprint !== undefined;
+    if (hasPinnedEnvironmentLineage
+        && (selectedProvider !== 'docker_sandbox'
+            || !input.pinnedEnvironmentId
+            || input.pinnedEnvironmentRevision === undefined
+            || !input.pinnedEnvironmentValidationFingerprint)) {
+        throw new BuildExecutionEnvironmentFailure('environment_identity_invalid', 'The historical Docker Sandbox lineage is incomplete or conflicts with the selected execution profile.', 'Retry as a fresh Build instead of resuming this historical provider session.');
+    }
+    const modelProvider = input.agent === 'opencode' ? getModelProvider(input.model) || null : 'anthropic';
+    const resolveHostEnvironment = (fallback) => {
+        const runAuthority = createExecutionRunAuthority({
+            profileRevision,
+            provider: 'host',
+            agent: input.agent,
+            modelProvider,
+            target: input.target,
+            environment: null,
+            fallback: fallback ? { used: true, from: fallback.from, reason: fallback.reason } : undefined,
+        });
+        persistExecutionRunAuthority({
+            projectId: input.project.id,
+            executionRunId: input.executionRunId,
+            profileRevision,
+            authority: runAuthority,
+        });
+        if (fallback) {
+            recordBuildExecutionProvider(input.project.id, input.executionRunId, 'host');
+        }
+        return {
+            provider: hostExecutionEnvironment,
+            environment: null,
+            authority: null,
+            runAuthority,
+            launcherEnvironment: createHostLauncherEnvironment(),
+            runtimeEnvironment: profileRevision.profile.compatibility === 'legacy_host'
+                ? createLegacyHostRuntimeEnvironment(input.target.workspacePath, { PWD: input.target.workspacePath })
+                : createGovernedHostRuntimeEnvironment(input.target.workspacePath, { PWD: input.target.workspacePath }),
+            release: async () => { },
+        };
+    };
+    if (selectedProvider !== 'docker_sandbox') {
+        return resolveHostEnvironment();
     }
     const dependencies = input.dependencies ?? defaultDockerSandboxEnvironmentDependencies;
-    let environment;
-    try {
-        environment = resolveValidatedEnvironment(input.project, input.agent, input.target, input.model ?? null, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
-    }
-    catch (error) {
-        if (error instanceof BuildExecutionEnvironmentFailure
-            && error.code === 'environment_missing'
-            && !input.pinnedEnvironmentId) {
-            const requestedProvider = input.agent === 'opencode' ? getModelProvider(input.model) : 'anthropic';
-            try {
-                await prepareAndValidateExecutionEnvironmentForTarget({
-                    projectId: input.project.id,
-                    agent: input.agent,
-                    provider: requestedProvider,
-                    model: input.agent === 'opencode' ? normalizeModelId(input.model) || null : null,
-                    target: input.target,
-                    initiatedBy: 'automation',
-                    signal: input.signal,
-                }, {
-                    adapter: dependencies.adapter,
-                    runtimeController: dependencies.runtimeController,
-                    runner: dependencies.runner,
-                });
-            }
-            catch (preparationError) {
-                throw new BuildExecutionEnvironmentFailure('validation_stale', `The exact ticket Build target could not be prepared for Docker Sandbox execution.${describePreparationFailure(preparationError)}`, 'Review the reported Docker Sandbox preparation failure, resolve it, then retry Build.', { cause: preparationError });
-            }
-            environment = resolveValidatedEnvironment(input.project, input.agent, input.target, input.model ?? null, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
+    const applicableRequirements = profileRevision.profile.credential_requirements.filter(requirement => (requirement.agent === input.agent && requirement.model_provider === modelProvider));
+    const canFallback = profileRevision.profile.fallback === 'explicit_host'
+        && !hasPinnedEnvironmentLineage
+        && profileRevision.profile.isolation === 'host_process_allowed'
+        && applicableRequirements.every(requirement => requirement.required_protection === 'legacy_host_inheritance');
+    const resolveFallback = (error) => {
+        if (input.signal?.aborted) {
+            throw input.signal.reason instanceof Error
+                ? input.signal.reason
+                : new Error('Docker Sandbox Build preparation was cancelled');
         }
-        else if (!shouldRetryValidation(error)) {
+        if (!canFallback) {
             throw error;
         }
-        else {
-            const candidate = findExecutionEnvironment(input.project, input.agent, input.target, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
-            if (!candidate) {
-                throw error;
+        const reason = error instanceof BuildExecutionEnvironmentFailure ? error.code : 'docker_preparation_failed';
+        return resolveHostEnvironment({ from: 'docker_sandbox', reason });
+    };
+    let environment;
+    let validatedDuringResolution = false;
+    try {
+        try {
+            environment = resolveValidatedEnvironment(input.project, input.agent, input.target, input.model ?? null, profileRevision, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
+        }
+        catch (error) {
+            if (error instanceof BuildExecutionEnvironmentFailure
+                && error.code === 'environment_missing'
+                && !input.pinnedEnvironmentId) {
+                const requestedProvider = input.agent === 'opencode' ? getModelProvider(input.model) : 'anthropic';
+                try {
+                    await prepareAndValidateExecutionEnvironmentForTarget({
+                        projectId: input.project.id,
+                        agent: input.agent,
+                        provider: requestedProvider,
+                        model: input.agent === 'opencode' ? normalizeModelId(input.model) || null : null,
+                        target: input.target,
+                        initiatedBy: 'automation',
+                        signal: input.signal,
+                        profileRevision,
+                    }, {
+                        adapter: dependencies.adapter,
+                        runtimeController: dependencies.runtimeController,
+                        runner: dependencies.runner,
+                    });
+                    validatedDuringResolution = true;
+                }
+                catch (preparationError) {
+                    throw new BuildExecutionEnvironmentFailure('validation_stale', `The exact ticket Build target could not be prepared for Docker Sandbox execution.${describePreparationFailure(preparationError)}`, 'Review the reported Docker Sandbox preparation failure, resolve it, then retry Build.', { cause: preparationError });
+                }
+                environment = resolveValidatedEnvironment(input.project, input.agent, input.target, input.model ?? null, profileRevision, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
             }
-            try {
-                await validateBuildProvider({
-                    project: input.project,
-                    environment: candidate,
-                    agent: input.agent,
-                    model: input.model ?? null,
-                    target: input.target,
-                    signal: input.signal,
-                    dependencies,
-                });
+            else if (!shouldRetryValidation(error)) {
+                throw error;
             }
-            catch (validationError) {
-                if (validationError instanceof BuildExecutionEnvironmentFailure) {
-                    throw validationError;
+            else {
+                const candidate = findExecutionEnvironment(input.project, input.agent, input.target, profileRevision, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
+                if (!candidate) {
+                    throw error;
+                }
+                try {
+                    await validateBuildProvider({
+                        project: input.project,
+                        environment: candidate,
+                        agent: input.agent,
+                        model: input.model ?? null,
+                        target: input.target,
+                        signal: input.signal,
+                        dependencies,
+                        profileRevision,
+                    });
+                    validatedDuringResolution = true;
+                }
+                catch (validationError) {
+                    if (validationError instanceof BuildExecutionEnvironmentFailure) {
+                        throw validationError;
+                    }
+                    throw new BuildExecutionEnvironmentFailure('validation_stale', 'The Docker Sandbox provider preflight failed before Build could start.', `Resolve ${input.agent} authentication and provider access, then retry Build.`, { cause: validationError });
                 }
-                throw new BuildExecutionEnvironmentFailure('validation_stale', 'The Docker Sandbox provider preflight failed before Build could start.', `Resolve ${input.agent} authentication and provider access, then retry Build.`, { cause: validationError });
+                environment = resolveValidatedEnvironment(input.project, input.agent, input.target, input.model ?? null, profileRevision, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
             }
-            environment = resolveValidatedEnvironment(input.project, input.agent, input.target, input.model ?? null, input.pinnedEnvironmentId, input.pinnedEnvironmentRevision, input.pinnedEnvironmentValidationFingerprint);
         }
     }
-    const authority = createAuthority(environment, input.agent);
+    catch (error) {
+        return resolveFallback(error);
+    }
+    if (hasPinnedEnvironmentLineage
+        && (environment.id !== input.pinnedEnvironmentId
+            || environment.environment_revision !== input.pinnedEnvironmentRevision
+            || environment.environment_validation_fingerprint !== input.pinnedEnvironmentValidationFingerprint)) {
+        throw new BuildExecutionEnvironmentFailure('environment_identity_invalid', 'The resolved Docker Sandbox does not match the historical environment lineage.', 'Restore the exact historical environment or retry as a fresh Build.');
+    }
+    if (!validatedDuringResolution) {
+        try {
+            await validateBuildProvider({
+                project: input.project,
+                environment,
+                agent: input.agent,
+                model: input.model ?? null,
+                target: input.target,
+                signal: input.signal,
+                dependencies,
+                profileRevision,
+            });
+        }
+        catch (error) {
+            return resolveFallback(new BuildExecutionEnvironmentFailure('validation_stale', 'The Docker Sandbox provider preflight could not refresh credential and destination evidence before Build.', `Resolve ${input.agent} authentication and provider access, then retry Build.`, { cause: error }));
+        }
+    }
+    const validation = getLatestValidation(input.project.id, environment.id, input.agent, modelProvider);
+    const credentialCapability = validation
+        ? getValidationCredentialCapability(input.project.id, environment.id, validation.id)
+        : null;
+    const authority = createAuthority(environment, input.agent, resolveEnvironmentCredentialEvidence({
+        profileRevision,
+        agent: input.agent,
+        modelProvider,
+        credentialCapability,
+    }));
     try {
         acquireExecutionEnvironmentLease({
             projectId: input.project.id,
@@ -358,7 +512,7 @@ export const resolveBuildExecutionEnvironment = async (input) => {
         });
     }
     catch (error) {
-        throw new BuildExecutionEnvironmentFailure('environment_leased', 'The selected Docker Sandbox is already leased by another run.', 'Wait for the active Build or reconciliation to release the environment.', { cause: error });
+        return resolveFallback(new BuildExecutionEnvironmentFailure('environment_leased', 'The selected Docker Sandbox is already leased by another run.', 'Wait for the active Build or reconciliation to release the environment.', { cause: error }));
     }
     let released = false;
     const release = async () => {
@@ -421,6 +575,12 @@ export const resolveBuildExecutionEnvironment = async (input) => {
         released = true;
     };
     input.onLeaseAcquired?.(release);
+    const resolveFallbackAfterLease = async (error) => {
+        if (!input.signal?.aborted) {
+            await release();
+        }
+        return resolveFallback(error);
+    };
     try {
         await ensureDockerSandboxRuntimeReady(dependencies, input.signal);
         await reconnectAndInspectDockerSandbox(environment, dependencies, input.signal);
@@ -442,9 +602,81 @@ export const resolveBuildExecutionEnvironment = async (input) => {
             },
             metadata: { executionRunId: input.executionRunId },
         });
-        throw new BuildExecutionEnvironmentFailure('runtime_unavailable', 'The required Docker Sandbox runtime or exact persisted sandbox is unavailable.', 'Restore Docker Sandbox readiness and retry; Archon will not fall back to host execution.', { cause: error });
+        return resolveFallbackAfterLease(new BuildExecutionEnvironmentFailure('runtime_unavailable', 'The required Docker Sandbox runtime or exact persisted sandbox is unavailable.', 'Restore Docker Sandbox readiness and retry Build.', { cause: error }));
     }
     const expected = resolveExpectedDockerSandboxIdentity(environment);
+    const requestedNetwork = profileRevision.profile.network;
+    const networkDestinations = requestedNetwork.mode === 'allowlist'
+        ? normalizeExecutionEnvironmentDestinations(requestedNetwork.destinations)
+        : [];
+    let networkEvidence = {
+        observed_global_posture: 'unknown',
+        destination_decisions: [],
+    };
+    const appendNetworkRuleOwnership = (appliedRuleIds) => {
+        if (appliedRuleIds.length === 0) {
+            return;
+        }
+        appendExecutionEnvironmentEvent({
+            projectId: input.project.id,
+            environmentId: environment.id,
+            eventType: 'environment_network_rules_applied',
+            fromState: environment.lifecycle_state,
+            toState: environment.lifecycle_state,
+            message: 'Archon applied scoped network rules for the requested allowlist destinations.',
+            metadata: {
+                sandboxName: expected.name,
+                executionRunId: input.executionRunId,
+                appliedRuleIds,
+            },
+        });
+    };
+    const rollbackUnpersistedRules = async (appliedRuleIds, cause) => {
+        const failures = await removeScopedRulesBestEffort(dependencies.adapter, expected.name, appliedRuleIds);
+        if (failures.length === 0) {
+            return null;
+        }
+        return new DockerSandboxNetworkRollbackFailure(expected.name, appliedRuleIds, appliedRuleIds.filter(ruleId => !failures.some(failure => failure.ruleId === ruleId)), failures, cause);
+    };
+    if (networkDestinations.length > 0) {
+        try {
+            const proof = await proveScopedDestinationAccess(dependencies.adapter, expected.name, networkDestinations);
+            try {
+                appendNetworkRuleOwnership(proof.appliedRuleIds);
+            }
+            catch (persistenceError) {
+                throw await rollbackUnpersistedRules(proof.appliedRuleIds, persistenceError) ?? persistenceError;
+            }
+            const decidedAt = new Date().toISOString();
+            networkEvidence = {
+                observed_global_posture: 'unknown',
+                destination_decisions: Object.values(proof.checks).map(check => ({
+                    target: check.target,
+                    decision: check.decision,
+                    evaluated_rule_id: check.evaluatedRuleId,
+                    decided_at: decidedAt,
+                })),
+            };
+        }
+        catch (error) {
+            let networkFailure = error;
+            if (error instanceof DockerSandboxNetworkRollbackFailure && error.remainingRuleIds.length > 0) {
+                try {
+                    appendNetworkRuleOwnership(error.remainingRuleIds);
+                }
+                catch (persistenceError) {
+                    networkFailure = await rollbackUnpersistedRules(error.remainingRuleIds, persistenceError)
+                        ?? (error.cause ?? error);
+                }
+            }
+            if (input.signal?.aborted) {
+                throw input.signal.reason instanceof Error
+                    ? input.signal.reason
+                    : new Error('Docker Sandbox network policy reconciliation was cancelled');
+            }
+            return resolveFallbackAfterLease(new BuildExecutionEnvironmentFailure('network_enforcement_unproven', `The Docker Sandbox could not prove scoped allowlist access for every requested destination: ${networkFailure instanceof Error ? networkFailure.message : 'policy check failed.'}`, 'Restore the sandbox network policy for the requested destinations, then retry Build.', { cause: networkFailure }));
+        }
+    }
     let skillCheck = null;
     try {
         skillCheck = await validateExecutionEnvironmentSkills(dependencies.adapter, expected, input.skills ?? [], { signal: input.signal });
@@ -455,12 +687,56 @@ export const resolveBuildExecutionEnvironment = async (input) => {
                 ? input.signal.reason
                 : new Error('Docker Sandbox skill verification was cancelled');
         }
-        throw new BuildExecutionEnvironmentFailure('skills_unavailable', 'The exact Docker Sandbox target could not verify the selected OpenCode skills.', 'Restore sandbox skill discovery, then retry Build.', { cause: error });
+        return resolveFallbackAfterLease(new BuildExecutionEnvironmentFailure('skills_unavailable', 'The exact Docker Sandbox target could not verify the selected OpenCode skills.', 'Restore sandbox skill discovery, then retry Build.', { cause: error }));
     }
     if (skillCheck && skillCheck.state !== 'passed') {
         const missingSkills = skillCheck.details?.missingSkills ?? input.skills ?? [];
         const skillSummary = missingSkills.length > 0 ? ` Missing skills: ${missingSkills.join(', ')}.` : '';
-        throw new BuildExecutionEnvironmentFailure('skills_unavailable', `The exact Docker Sandbox target does not provide all selected OpenCode skills.${skillSummary}`, 'Import the selected skills into the sandbox target or remove them from the ticket, then retry Build.');
+        return resolveFallbackAfterLease(new BuildExecutionEnvironmentFailure('skills_unavailable', `The exact Docker Sandbox target does not provide all selected OpenCode skills.${skillSummary}`, 'Import the selected skills into the sandbox target or remove them from the ticket, then retry Build.'));
+    }
+    let observedGlobalPosture;
+    try {
+        observedGlobalPosture = await dependencies.adapter.inspectGlobalNetworkPosture({ signal: input.signal });
+    }
+    catch (error) {
+        if (input.signal?.aborted) {
+            throw input.signal.reason instanceof Error
+                ? input.signal.reason
+                : new Error('Docker Sandbox network posture observation was cancelled');
+        }
+        observedGlobalPosture = 'unknown';
+    }
+    networkEvidence = {
+        ...networkEvidence,
+        observed_global_posture: observedGlobalPosture,
+    };
+    let runAuthority;
+    try {
+        runAuthority = createExecutionRunAuthority({
+            profileRevision,
+            provider: 'docker_sandbox',
+            agent: input.agent,
+            modelProvider,
+            target: input.target,
+            environment,
+            credentialCapability,
+            networkEvidence,
+        });
+    }
+    catch (error) {
+        return resolveFallbackAfterLease(error);
+    }
+    try {
+        persistExecutionRunAuthority({
+            projectId: input.project.id,
+            executionRunId: input.executionRunId,
+            profileRevision,
+            authority: runAuthority,
+        });
+    }
+    catch (error) {
+        await release();
+        throw error;
     }
     const baseProvider = await createDockerSandboxExecutionProvider({
         adapter: dependencies.adapter,
@@ -530,6 +806,14 @@ export const resolveBuildExecutionEnvironment = async (input) => {
             return { ...handle, placementIdentity, placementFailure };
         },
     };
-    return { provider, environment, authority, release };
+    return {
+        provider,
+        environment,
+        authority,
+        runAuthority,
+        launcherEnvironment: createDockerSandboxLauncherEnvironment(),
+        runtimeEnvironment: createProviderManagedRuntimeEnvironment(),
+        release,
+    };
 };
 //# sourceMappingURL=buildExecutionEnvironment.js.map