@straiffi/archon 1.8.22 → 1.10.0

package/dist/server/lib/dockerSandboxExecutionEnvironment.js

@@ -6,38 +6,20 @@ import { promisify } from 'node:util';
 import { networkDestinationTarget } from './executionEnvironmentLifecycle.js';
 import { requireExecutionCapabilities } from './executionEnvironmentLifecycle.js';
 import { assertExactSandboxNetworkAllowlist, applyScopedNetworkRules as applyScopedSandboxNetworkRules, checkDestinationAccess as checkSandboxDestinationAccess, inspectGlobalNetworkPosture as inspectSandboxGlobalNetworkPosture, inspectSandboxNetworkRules as inspectScopedSandboxNetworkRules, removeScopedNetworkRules as removeScopedSandboxNetworkRules, } from './dockerSandboxNetworkPolicy.js';
+import { RECOMMENDED_DOCKER_SANDBOX_RELEASE, inspectDockerSandboxRelease, isDockerSandboxReleaseHostQualified, resolveDockerSandboxReleaseProfile, } from './dockerSandboxReleaseProfiles.js';
 export const DOCKER_SANDBOX_PROVIDER = 'docker_sandbox';
-export const QUALIFIED_SBX_VERSION = '0.38.0';
-export const QUALIFIED_SBX_BUILD = 'c022b14634c4bea846ca12870d1d5e97d5868b54';
-export const DOCKER_SANDBOX_ADAPTER_CONTRACT_VERSION = '5';
+export const QUALIFIED_SBX_VERSION = RECOMMENDED_DOCKER_SANDBOX_RELEASE.version;
+export const QUALIFIED_SBX_BUILD = RECOMMENDED_DOCKER_SANDBOX_RELEASE.acceptedBuilds[0];
+export const DOCKER_SANDBOX_ADAPTER_CONTRACT_VERSION = RECOMMENDED_DOCKER_SANDBOX_RELEASE.adapterContractVersion;
 export const DOCKER_SANDBOX_MAX_NAME_BYTES = 63;
-export const QUALIFIED_DOCKER_SANDBOX_TEMPLATES = {
-    opencode: 'docker.io/docker/sandbox-templates:opencode',
-    claude: 'docker.io/docker/sandbox-templates:claude-code',
-};
+export const QUALIFIED_DOCKER_SANDBOX_TEMPLATES = RECOMMENDED_DOCKER_SANDBOX_RELEASE.templates;
 const DEFAULT_TIMEOUT_MS = 15_000;
 const DEFAULT_OUTPUT_LIMIT_BYTES = 256 * 1024;
 const SANDBOX_NAME_HASH_LENGTH = 16;
-const MINIMUM_MACOS_MAJOR = 14;
 const KVM_DEVICE_PATH = '/dev/kvm';
 const execFile = promisify(execFileCallback);
-const QUALIFIED_DOCKER_SANDBOX_HOSTS = [
-    { platform: 'linux', architecture: 'x64' },
-    { platform: 'darwin', architecture: 'arm64' },
-];
-export const isQualifiedDockerSandboxHost = (platform, architecture) => QUALIFIED_DOCKER_SANDBOX_HOSTS.some(host => host.platform === platform && host.architecture === architecture);
-export const dockerSandboxExecutionEnvironmentCapabilities = {
-    isolation: 'microvm',
-    directWritableWorkspace: 'supported',
-    transparentHeadlessStreams: 'supported',
-    credentialBrokering: 'supported',
-    enforcedNetworkAllowlist: 'unknown',
-    persistentEnvironments: 'supported',
-    resourceIsolation: 'unknown',
-    nestedContainers: 'unsupported',
-    publishedPorts: 'unsupported',
-    resourceControls: 'unsupported',
-};
+export const isQualifiedDockerSandboxHost = (platform, architecture) => isDockerSandboxReleaseHostQualified(RECOMMENDED_DOCKER_SANDBOX_RELEASE, platform, architecture);
+export const dockerSandboxExecutionEnvironmentCapabilities = RECOMMENDED_DOCKER_SANDBOX_RELEASE.capabilities;
 export const deriveDockerSandboxGlobalNetworkPosture = (readiness) => readiness.observations.some(observation => (observation.code === 'network_policy' && observation.state === 'ready'))
     ? 'restrictive'
     : 'unobserved';
@@ -45,9 +27,12 @@ export const deriveDockerSandboxExecutionEnvironmentCapabilities = (posture) =>
     ...dockerSandboxExecutionEnvironmentCapabilities,
     enforcedNetworkAllowlist: posture === 'restrictive' ? 'supported' : 'unknown',
 });
-export const dockerSandboxExecutionEnvironmentObservation = (posture = 'unobserved') => ({
-    providerVersion: QUALIFIED_SBX_VERSION,
-    capabilities: deriveDockerSandboxExecutionEnvironmentCapabilities(posture),
+export const dockerSandboxExecutionEnvironmentObservation = (posture = 'unobserved', profile = RECOMMENDED_DOCKER_SANDBOX_RELEASE) => ({
+    providerVersion: profile.version,
+    capabilities: {
+        ...profile.capabilities,
+        enforcedNetworkAllowlist: posture === 'restrictive' ? 'supported' : 'unknown',
+    },
     degradationReasons: posture === 'restrictive'
         ? []
         : ['The selected direct workspace remains writable from the sandbox.'],
@@ -209,20 +194,31 @@ export const parseJsonObject = (command, output) => {
     }
     return record;
 };
-export const parseQualifiedSbxVersion = (output) => {
+export const parseSbxVersionIdentity = (output) => {
     const match = /^sbx version: v(\d+\.\d+\.\d+) ([0-9a-f]{40})\r?\n?$/.exec(output);
     if (!match) {
         throw new SbxContractFailure('version', 'sbx version output did not match the qualified contract');
     }
-    if (match[1] !== QUALIFIED_SBX_VERSION) {
-        throw new SbxContractFailure('version', `Unsupported sbx version ${match[1]}; Archon requires exactly ${QUALIFIED_SBX_VERSION}`);
-    }
-    if (match[2] !== QUALIFIED_SBX_BUILD) {
-        throw new SbxContractFailure('version', `Unsupported sbx build ${match[2]}; Archon requires exactly ${QUALIFIED_SBX_BUILD}`);
+    return { version: match[1], build: match[2] };
+};
+export const parseQualifiedSbxRelease = (output) => {
+    const identity = parseSbxVersionIdentity(output);
+    const profile = resolveDockerSandboxReleaseProfile(identity.version, identity.build);
+    if (!profile) {
+        const release = inspectDockerSandboxRelease(identity.version, identity.build);
+        throw new SbxContractFailure('version', release.status === 'security_blocked'
+            ? release.reason ?? `Docker Sandbox ${identity.version} is blocked due to a security issue.`
+            : release.reason ?? `Unsupported sbx release ${identity.version} build ${identity.build}`);
     }
-    return match[1];
+    return profile;
+};
+export const parseQualifiedSbxVersion = (output) => {
+    return parseQualifiedSbxRelease(output).version;
 };
-export const parseSbxDiagnostics = (output) => {
+export const parseSbxDiagnostics = (output, profile = RECOMMENDED_DOCKER_SANDBOX_RELEASE) => {
+    if (profile.parserContracts.diagnostics !== 'v0.38.0') {
+        throw new SbxContractFailure('diagnose', `No diagnostics parser is registered for ${profile.id}`);
+    }
     const record = parseJsonObject('diagnose', output);
     if (record.version !== '1.0' || !Array.isArray(record.checks)) {
         throw new SbxContractFailure('diagnose', 'sbx diagnose returned an unsupported schema');
@@ -272,7 +268,10 @@ const QUALIFIED_NETWORK_POLICY_STRING_FIELDS = [
     'layer',
     'status',
 ];
-export const parseSbxNetworkPolicy = (output) => {
+export const parseSbxNetworkPolicy = (output, profile = RECOMMENDED_DOCKER_SANDBOX_RELEASE) => {
+    if (profile.parserContracts.networkPolicy !== 'v0.38.0') {
+        throw new SbxContractFailure('policy list', `No network policy parser is registered for ${profile.id}`);
+    }
     const record = parseJsonObject('policy list', output);
     if (Object.keys(record).some(field => field !== 'rules')
         || !Array.isArray(record.rules)
@@ -336,8 +335,8 @@ const macOsMajorVersion = (version) => {
     const match = /^(\d+)(?:\.|$)/.exec(version);
     return match ? Number(match[1]) : null;
 };
-const probeDockerSandboxPlatformReadiness = async (platform, architecture, options) => {
-    if (!isQualifiedDockerSandboxHost(platform, architecture)) {
+const probeDockerSandboxPlatformReadiness = async (platform, architecture, options, profile) => {
+    if (!isDockerSandboxReleaseHostQualified(profile, platform, architecture)) {
         return {
             code: 'platform',
             state: 'unsupported',
@@ -365,7 +364,7 @@ const probeDockerSandboxPlatformReadiness = async (platform, architecture, optio
             remediation: 'Run macOS Sonoma 14 or later on Apple silicon, then recheck.',
         };
     }
-    if (majorVersion < MINIMUM_MACOS_MAJOR) {
+    if (majorVersion < profile.minimumMacosMajor) {
         return {
             code: 'platform',
             state: 'unsupported',
@@ -464,6 +463,9 @@ export const probeDockerSandboxReadiness = async (runner, options = {}) => {
     const architecture = options.architecture ?? process.arch;
     const observations = [];
     let providerVersion = null;
+    let providerBuild = null;
+    let releaseStatus = null;
+    let releaseProfile = null;
     let versionResult;
     try {
         versionResult = await runner.run(['version'], options);
@@ -473,6 +475,9 @@ export const probeDockerSandboxReadiness = async (runner, options = {}) => {
         if (error instanceof SbxCommandFailure && error.kind === 'missing_cli') {
             return {
                 providerVersion: null,
+                providerBuild: null,
+                releaseStatus: null,
+                recommendedVersion: RECOMMENDED_DOCKER_SANDBOX_RELEASE.version,
                 observations: [
                     { code: 'cli', state: 'not_ready', summary: 'sbx CLI is not installed.', remediation: 'Install the qualified sbx release from Docker.' },
                     ...['version', 'platform', 'virtualization', 'daemon', 'docker_login', 'network_policy', 'opencode_template', 'claude_template']
@@ -486,8 +491,25 @@ export const probeDockerSandboxReadiness = async (runner, options = {}) => {
         if (versionResult.exitCode !== 0) {
             throw new SbxContractFailure('version', `sbx version exited with code ${versionResult.exitCode}`);
         }
-        providerVersion = parseQualifiedSbxVersion(versionResult.stdout);
-        observations.push({ code: 'version', state: 'ready', summary: `sbx ${providerVersion} is qualified.`, remediation: null });
+        const identity = parseSbxVersionIdentity(versionResult.stdout);
+        providerVersion = identity.version;
+        providerBuild = identity.build;
+        const release = inspectDockerSandboxRelease(identity.version, identity.build);
+        releaseStatus = release.status;
+        releaseProfile = release.profile;
+        if (!releaseProfile || release.status === 'security_blocked') {
+            throw new SbxContractFailure('version', release.reason ?? `Docker Sandbox ${identity.version} is unsupported.`);
+        }
+        observations.push({
+            code: 'version',
+            state: 'ready',
+            summary: release.status === 'deprecated'
+                ? `sbx ${providerVersion} is qualified but deprecated.`
+                : `sbx ${providerVersion} is qualified and recommended.`,
+            remediation: release.status === 'deprecated'
+                ? `Upgrade to sbx ${RECOMMENDED_DOCKER_SANDBOX_RELEASE.version}.`
+                : null,
+        });
     }
     catch (error) {
         observations.push({
@@ -497,14 +519,30 @@ export const probeDockerSandboxReadiness = async (runner, options = {}) => {
             remediation: `Install sbx ${QUALIFIED_SBX_VERSION}.`,
         });
     }
-    const platformObservation = await probeDockerSandboxPlatformReadiness(platform, architecture, options);
+    if (!releaseProfile || releaseStatus === 'security_blocked') {
+        observations.push(...['platform', 'virtualization', 'daemon', 'docker_login', 'network_policy', 'opencode_template', 'claude_template']
+            .map(code => ({
+            code,
+            state: 'unknown',
+            summary: 'Not checked because the installed sbx release is not supported.',
+            remediation: null,
+        })));
+        return {
+            providerVersion,
+            providerBuild,
+            releaseStatus: releaseStatus ?? 'unsupported',
+            recommendedVersion: RECOMMENDED_DOCKER_SANDBOX_RELEASE.version,
+            observations,
+        };
+    }
+    const platformObservation = await probeDockerSandboxPlatformReadiness(platform, architecture, options, releaseProfile);
     observations.push(platformObservation);
     observations.push(await probeDockerSandboxVirtualizationReadiness(platform, architecture, platformObservation, options.kvmAccess));
     const diagnose = await runner.run(['diagnose', '--output', 'json'], options);
     if (diagnose.exitCode !== 0 && diagnose.stdout.trim().length === 0) {
         throw new SbxContractFailure('diagnose', 'sbx diagnose failed without structured output');
     }
-    const checks = parseSbxDiagnostics(diagnose.stdout);
+    const checks = parseSbxDiagnostics(diagnose.stdout, releaseProfile);
     observations.push(diagnosticObservation(checks, 'daemon', ['daemon'], 'Daemon readiness was not reported.'));
     observations.push(diagnosticObservation(checks, 'docker_login', ['authentication'], 'Docker login readiness was not reported.'));
     const daemonReady = observations.some(observation => observation.code === 'daemon' && observation.state === 'ready');
@@ -521,7 +559,7 @@ export const probeDockerSandboxReadiness = async (runner, options = {}) => {
         }
         else {
             try {
-                const rules = parseSbxNetworkPolicy(policy.stdout);
+                const rules = parseSbxNetworkPolicy(policy.stdout, releaseProfile);
                 const activeGlobalNetworkRules = rules.filter(rule => (rule.scope === 'global'
                     && rule.resourceType === 'network'
                     && rule.status === 'active')).length;
@@ -564,7 +602,13 @@ export const probeDockerSandboxReadiness = async (runner, options = {}) => {
             remediation: 'Review qualified template output before enabling this capability.',
         });
     }
-    return { providerVersion, observations };
+    return {
+        providerVersion,
+        providerBuild,
+        releaseStatus,
+        recommendedVersion: RECOMMENDED_DOCKER_SANDBOX_RELEASE.version,
+        observations,
+    };
 };
 const slug = (value, maximum) => {
     const normalized = value.toLowerCase().replace(/[^a-z0-9.-]+/g, '-').replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '');
@@ -613,7 +657,27 @@ const describeInspectionShape = (record) => {
     const description = fields.map(field => `${field}:${jsonValueKind(record[field])}`).join(', ');
     return description.slice(0, 500);
 };
-export const parseDockerSandboxInspection = (output) => {
+const resolveInspectionTemplate = (image, imageDigest) => {
+    if (imageDigest === undefined) {
+        return image;
+    }
+    if (typeof imageDigest !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(imageDigest)) {
+        throw new SbxContractFailure('inspect', 'sbx inspect returned an unrecognized image digest');
+    }
+    const digestSeparator = image.indexOf('@');
+    const tagSeparator = image.lastIndexOf(':');
+    const pathSeparator = image.lastIndexOf('/');
+    const repository = digestSeparator >= 0
+        ? image.slice(0, digestSeparator)
+        : tagSeparator > pathSeparator
+            ? image.slice(0, tagSeparator)
+            : image;
+    return `${repository}@${imageDigest}`;
+};
+export const parseDockerSandboxInspection = (output, profile = RECOMMENDED_DOCKER_SANDBOX_RELEASE) => {
+    if (profile.parserContracts.inspection !== 'v0.38.0') {
+        throw new SbxContractFailure('inspect', `No inspection parser is registered for ${profile.id}`);
+    }
     const record = parseJsonObject('inspect', output);
     const fields = Object.keys(record).sort();
     const workspace = record.workspace;
@@ -633,7 +697,7 @@ export const parseDockerSandboxInspection = (output) => {
         agent: record.agent,
         state: record.state,
         workspacePath: workspace,
-        template: record.image,
+        template: resolveInspectionTemplate(record.image, record.image_digest),
     };
 };
 const assertInspectionMatches = (expected, observed) => {
@@ -653,12 +717,22 @@ export const requireSuccessfulCommand = (command, result) => {
         throw new SbxContractFailure(command, exitCodeFailureMessage(command, result));
     }
 };
-const isQualifiedMissingSandboxResult = (result) => (result.args[0] === 'inspect'
-    && typeof result.args[1] === 'string'
-    && result.args[1].length > 0
-    && result.exitCode === 1
-    && result.stdout === ''
-    && result.stderr === `ERROR: sandbox '${result.args[1]}' not found\n`);
+const requireReleaseCommandContract = (profile, contract) => {
+    if (!profile.commandContracts.includes(contract)) {
+        throw new SbxContractFailure(contract, `Docker Sandbox release ${profile.id} does not qualify the ${contract} command`);
+    }
+};
+const isQualifiedMissingSandboxResult = (result, profile) => {
+    if (profile.parserContracts.missingSandbox !== 'v0.38.0') {
+        return false;
+    }
+    return result.args[0] === 'inspect'
+        && typeof result.args[1] === 'string'
+        && result.args[1].length > 0
+        && result.exitCode === 1
+        && result.stdout === ''
+        && result.stderr === `ERROR: sandbox '${result.args[1]}' not found\n`;
+};
 export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) => {
     let qualification = null;
     const waitForQualification = (operation, signal) => {
@@ -673,9 +747,9 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
                 reject(new SbxCommandFailure('cancelled', ['version'], 'sbx version qualification was cancelled'));
             };
             signal.addEventListener('abort', onAbort, { once: true });
-            operation.then(() => {
+            operation.then(profile => {
                 signal.removeEventListener('abort', onAbort);
-                resolve();
+                resolve(profile);
             }, error => {
                 signal.removeEventListener('abort', onAbort);
                 reject(error);
@@ -685,9 +759,6 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
     const ensureQualified = (options) => {
         const platform = qualificationOptions.platform ?? process.platform;
         const architecture = qualificationOptions.architecture ?? process.arch;
-        if (!isQualifiedDockerSandboxHost(platform, architecture)) {
-            throw new SbxContractFailure('platform', `Unsupported sbx platform ${platform}/${architecture}; Archon requires linux/x64 or darwin/arm64`);
-        }
         if (!qualification) {
             const qualificationCommandOptions = {
                 timeoutMs: options.timeoutMs,
@@ -696,7 +767,11 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
             };
             const attempt = runner.run(['version'], qualificationCommandOptions).then(result => {
                 requireSuccessfulCommand('version', result);
-                parseQualifiedSbxVersion(result.stdout);
+                const profile = parseQualifiedSbxRelease(result.stdout);
+                if (!isDockerSandboxReleaseHostQualified(profile, platform, architecture)) {
+                    throw new SbxContractFailure('platform', `Unsupported sbx platform ${platform}/${architecture} for ${profile.version}`);
+                }
+                return profile;
             });
             qualification = attempt.catch(error => {
                 qualification = null;
@@ -706,15 +781,16 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
         return waitForQualification(qualification, options.signal);
     };
     const inspect = async (name, options = {}) => {
-        await ensureQualified(options);
+        const profile = await ensureQualified(options);
+        requireReleaseCommandContract(profile, 'inspect');
         const result = await runner.run(['inspect', name, '--json'], options);
         if (result.exitCode !== 0) {
-            if (isQualifiedMissingSandboxResult(result)) {
+            if (isQualifiedMissingSandboxResult(result, profile)) {
                 return null;
             }
             throw new SbxContractFailure('inspect', exitCodeFailureMessage('inspect', result));
         }
-        return parseDockerSandboxInspection(result.stdout);
+        return parseDockerSandboxInspection(result.stdout, profile);
     };
     const requireExpected = async (expected, options) => {
         const observed = await inspect(expected.name, options);
@@ -725,6 +801,8 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
         return observed;
     };
     const reconnect = async (expected, options = {}) => {
+        const profile = await ensureQualified(options);
+        requireReleaseCommandContract(profile, 'exec');
         let observed = await requireExpected(expected, options);
         if (observed.state === 'stopped') {
             const result = await runner.run(['exec', observed.name, '--', 'true'], options);
@@ -735,6 +813,8 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
     };
     return {
         create: async (request, options = {}) => {
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'create');
             const name = createDockerSandboxName(request.identity);
             const existing = await inspect(name, options);
             const expected = { name, agent: request.agent, workspacePath: request.workspacePath, template: request.template };
@@ -751,11 +831,15 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
         inspect,
         reconnect,
         exec: async (expected, command, args, options = {}) => {
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'exec');
             await requireExpected(expected, options);
             const workdir = options.cwd === undefined ? [] : ['--workdir', options.cwd];
             return runner.run(['exec', ...workdir, expected.name, '--', command, ...args], options);
         },
         stop: async (expected, options = {}) => {
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'stop');
             let observed = await requireExpected(expected, options);
             if (observed.state === 'running') {
                 requireSuccessfulCommand('stop', await runner.run(['stop', expected.name], options));
@@ -766,28 +850,35 @@ export const createDockerSandboxAdapter = (runner, qualificationOptions = {}) =>
             }
         },
         remove: async (expected, options = {}) => {
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'remove');
             await requireExpected(expected, options);
             requireSuccessfulCommand('rm', await runner.run(['rm', '--force', expected.name], options));
         },
         applyScopedNetworkRules: async (sandboxName, resources, options = {}) => {
-            await ensureQualified(options);
-            return applyScopedSandboxNetworkRules(runner, sandboxName, resources, options);
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'policy-allow');
+            return applyScopedSandboxNetworkRules(runner, sandboxName, resources, options, profile);
         },
         inspectSandboxNetworkRules: async (sandboxName, options = {}) => {
-            await ensureQualified(options);
-            return inspectScopedSandboxNetworkRules(runner, sandboxName, options);
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'policy-list');
+            return inspectScopedSandboxNetworkRules(runner, sandboxName, options, profile);
         },
         inspectGlobalNetworkPosture: async (options = {}) => {
-            await ensureQualified(options);
-            return inspectSandboxGlobalNetworkPosture(runner, options);
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'policy-list');
+            return inspectSandboxGlobalNetworkPosture(runner, options, profile);
         },
         checkDestinationAccess: async (sandboxName, target, options = {}) => {
-            await ensureQualified(options);
-            return checkSandboxDestinationAccess(runner, sandboxName, target, options);
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'policy-check');
+            return checkSandboxDestinationAccess(runner, sandboxName, target, options, profile);
         },
         removeScopedNetworkRules: async (sandboxName, ruleIds, options = {}) => {
-            await ensureQualified(options);
-            return removeScopedSandboxNetworkRules(runner, sandboxName, ruleIds, options);
+            const profile = await ensureQualified(options);
+            requireReleaseCommandContract(profile, 'policy-remove');
+            return removeScopedSandboxNetworkRules(runner, sandboxName, ruleIds, options, profile);
         },
     };
 };
@@ -879,6 +970,7 @@ export const removeScopedRulesBestEffort = async (adapter, sandboxName, ownedRul
     return failures;
 };
 export const createDockerSandboxExecutionEnvironmentLifecycle = (dependencies) => {
+    const releaseProfile = dependencies.releaseProfile ?? RECOMMENDED_DOCKER_SANDBOX_RELEASE;
     const appliedNetworkPolicies = new Map();
     const inspect = async (environment, options = {}) => {
         const expected = dependencies.resolveExpected(environment);
@@ -925,7 +1017,7 @@ export const createDockerSandboxExecutionEnvironmentLifecycle = (dependencies) =
     };
     return {
         prepare: async (request) => {
-            requireExecutionCapabilities(DOCKER_SANDBOX_PROVIDER, dockerSandboxExecutionEnvironmentObservation(), request.requiredCapabilities);
+            requireExecutionCapabilities(DOCKER_SANDBOX_PROVIDER, dockerSandboxExecutionEnvironmentObservation('unobserved', releaseProfile), request.requiredCapabilities);
             if (!request.persistent) {
                 throw new SbxContractFailure('create', 'Docker Sandbox lifecycle requires persistent environments');
             }
@@ -941,7 +1033,7 @@ export const createDockerSandboxExecutionEnvironmentLifecycle = (dependencies) =
             return {
                 id: preparation.id,
                 provider: DOCKER_SANDBOX_PROVIDER,
-                providerVersion: QUALIFIED_SBX_VERSION,
+                providerVersion: releaseProfile.version,
                 externalId: sandbox.name,
                 target: request.target,
                 state: 'ready',