@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/sandbox/control/server.js

@@ -6,7 +6,7 @@ import { getProcessStartTime } from '../../server/process-state.js';
 import { assertGitWorktreeBinding } from '../../git/worktree-identity.js';
 import { controlError, DEFAULT_SANDBOX_CONTROL_TIMING, SANDBOX_CONTROL_MAX_RESPONSE_BYTES, SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES } from './protocol.js';
 import { prepareSandboxControlExecution } from './executor.js';
-import { atomicWriteJsonNoReplace, createSandboxControlPayload, cleanupStaleSandboxControlLease, executionPath, readJsonFile, readActiveLease, readExecution, readSandboxControlPayload, readSandboxControlResultEvidence, readSandboxControlTerminalResult, createSandboxControlTerminalResult, sandboxControlEncodedJsonBytes, sandboxControlGenerationUsage, sanitizeSandboxControlOutput, sanitizeSandboxControlResult, payloadPath, writeSandboxControlPayload, writeSandboxControlReservation, writeSandboxControlResultEvidence, writeSandboxControlTerminalResult, appendSandboxControlAudit, terminateSandboxControlExecution, writeSandboxControlStatus, readSandboxControlStatus } from './state.js';
+import { atomicWriteJsonNoReplace, createSandboxControlPayload, cleanupStaleSandboxControlLease, executionPath, readJsonFile, readActiveLease, readExecution, readSandboxControlPayload, readSandboxControlResultEvidence, readSandboxControlTerminalResult, createSandboxControlTerminalResult, sandboxControlEncodedJsonBytes, sandboxControlGenerationUsage, sanitizeSandboxControlOutput, sanitizeSandboxControlResult, payloadPath, writeSandboxControlPayload, writeSandboxControlReservation, writeSandboxControlResultEvidence, writeSandboxControlTerminalResult, terminateSandboxControlExecution, writeSandboxControlStatus, readSandboxControlStatus } from './state.js';
 import { validateSandboxControlRequest } from './protocol.js';
 import { requestAuditFields, resultAuditFields, appendCriticalAudit, appendDiagnosticAudit, createSandboxControlAuditContext, writeSandboxControlTransition, readSandboxControlTransition } from './audit.js';
 import { parseTaskControlOperation } from '../../task/control-authority.js';
@@ -15,11 +15,11 @@ import { readLifecycleJournalEvidence } from '../../task/lifecycle.js';
 import { resolveTaskRef } from '../../task/resolve-ref.js';
 import { loadShortIdByTaskId } from '../../task/short-id.js';
 import { inspectSandboxControlContainer } from './container-identity.js';
-import { acquireSandboxControlBrokerStartup, garbageCollectSandboxControlRoot, isSandboxControlRootQuiescing, readSandboxControlManifest } from './lifecycle.js';
+import { acquireSandboxControlBrokerStartup, isSandboxControlRootQuiescing, readSandboxControlManifest } from './lifecycle.js';
 import { nextSandboxControlBackoff } from './timing.js';
 import { readTaskFinalizationReceipt } from '../../task/finalization.js';
 import { validateSandboxControlIdentity } from './identity-sentinel.js';
-import { mergeSandboxTaskView, taskViewForManifest } from './task-view.js';
+import { mergeSandboxTaskView, taskViewForManifest, } from './task-view.js';
 import { taskCreateOutputUnavailableResult } from '../../task/create-service.js';
 function appendBrokerAudit(manifest, event, fields = {}) {
     appendDiagnosticAudit(manifest, event, { source: 'broker', ...fields });
@@ -183,7 +183,7 @@ function taskCreateDomainEvidence(manifest, output) {
         return { consistent: false };
     }
 }
-async function readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payloadOutput) {
+async function readRecoveryDomain(manifest, request, operation, terminalResult, payloadOutput) {
     if (!operation)
         return { domain: null };
     const taskRef = 'args' in request ? request.args[0] ?? null : manifest.taskId;
@@ -192,9 +192,6 @@ async function readRecoveryDomain(manifest, manifestPath, request, operation, te
         return { domain: null };
     }
     if (operation.family === 'task-lifecycle') {
-        if (operation.intent === 'recover-started') {
-            return { domain: null };
-        }
         if (!taskRef || !terminalResult.targetState)
             return { domain: null };
         const journal = readLifecycleJournalEvidence(manifest.repoRoot, taskRef);
@@ -229,7 +226,7 @@ function readCommittedCriticalPhases(manifest, requestId) {
         }
     });
 }
-export async function recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult) {
+export async function recoveryResponse(manifest, request, evidence, payload, terminalResult) {
     const operationName = recoveryOperationKey(request);
     const operation = operationName ? findSandboxControlRecoveryOperation(request.family, operationName) : null;
     if (!operation)
@@ -241,7 +238,7 @@ export async function recoveryResponse(manifest, manifestPath, request, evidence
         if (JSON.stringify(payloadTerminal) !== JSON.stringify(terminalResult))
             return unknown(request.id);
     }
-    const recovery = await readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
+    const recovery = await readRecoveryDomain(manifest, request, operation, terminalResult, payload?.stdout ?? null);
     const binding = operationRecoveryBinding(request.id, manifest.generation, manifest.taskId, request.family, operationName);
     const decision = classifySandboxControlRecovery({
         operation,
@@ -260,7 +257,7 @@ export async function recoveryResponse(manifest, manifestPath, request, evidence
         return null;
     return genericRecoveryResponse(request, evidence.exitCode, payload);
 }
-async function terminalMatchesEvidence(manifest, request, response, evidence, payload, payloadInvalid, terminalResult) {
+async function terminalMatchesEvidence(request, response, evidence, payload, payloadInvalid) {
     if (response.version !== 2 || response.id !== request.id || response.phase !== 'completed'
         || response.exitCode !== evidence.exitCode || response.error !== null) {
         return { valid: false, payloadReferenced: false };
@@ -296,7 +293,7 @@ async function terminalMatchesEvidence(manifest, request, response, evidence, pa
 }
 function publishExecutionResult(manifest, request, result, brokerOwns) {
     const normalized = sanitizeSandboxControlResult(manifest, result);
-    const terminalResult = writeSandboxControlTerminalResult(manifest, {
+    writeSandboxControlTerminalResult(manifest, {
         id: request.id,
         family: request.family,
         operation: operationKey(request)
@@ -406,7 +403,7 @@ function assertCurrentSandboxControlIdentity(manifest, manifestPath) {
         throw new Error(`SANDBOX_CONTROL_IDENTITY_${result.state.replaceAll('-', '_').toUpperCase()}`);
     }
 }
-async function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
+async function recoverProcessing(manifest, brokerOwns) {
     for (const entry of fs.readdirSync(manifest.processingDir, { withFileTypes: true })) {
         if (!entry.isDirectory() || !/^[a-f0-9-]{16,64}$/.test(entry.name))
             continue;
@@ -526,7 +523,7 @@ async function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
             if (terminal && request && resultEvidence) {
                 if (!terminalResult && request.family !== 'task-create')
                     continue;
-                const reconciliation = await terminalMatchesEvidence(manifest, request, existingTerminalResponse, resultEvidence, payload, payloadInvalid, terminalResult);
+                const reconciliation = await terminalMatchesEvidence(request, existingTerminalResponse, resultEvidence, payload, payloadInvalid);
                 if (!reconciliation.valid)
                     continue;
                 terminalReconciled = true;
@@ -554,7 +551,7 @@ async function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
                     return false;
                 if (!resultEvidence || !request || payloadInvalid)
                     continue;
-                const recovered = await recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult);
+                const recovered = await recoveryResponse(manifest, request, resultEvidence, payload, terminalResult);
                 if (!recovered)
                     continue;
                 writeSandboxControlResponse(manifest, recovered);
@@ -704,7 +701,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
             pid: broker.pid,
             brokerId: broker.brokerId
         });
-        if (!await recoverProcessing(manifest, manifestPath, broker, brokerOwns))
+        if (!await recoverProcessing(manifest, brokerOwns))
             return;
         try {
             const published = readSandboxControlStatus(manifest.publicStatusDir);
@@ -756,33 +753,16 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                     containerBackoffMs = timing.parkedBindingInitialMs;
                     nextContainerHeartbeatAt = Date.now() + timing.containerHeartbeatMs;
                 }
-                else if (observation.state === 'unknown') {
-                    containerReasonCode = 'SANDBOX_CONTROL_CONTAINER_UNKNOWN';
-                    appendDiagnosticAudit(manifest, 'container-heartbeat-unknown', { reason: observation.reason });
+                else {
+                    const missing = observation.state === 'absent';
+                    containerReasonCode = missing ? 'SANDBOX_CONTROL_CONTAINER_ABSENT' : 'SANDBOX_CONTROL_CONTAINER_UNKNOWN';
+                    appendDiagnosticAudit(manifest, missing ? 'container-heartbeat-absent' : 'container-heartbeat-unknown', {
+                        reason: observation.state === 'unknown' ? observation.reason : 'recorded container was not found'
+                    });
                     const backoff = nextSandboxControlBackoff(containerBackoffMs, timing.slowCheckMs);
                     nextContainerHeartbeatAt = Date.now() + backoff.delayMs;
                     containerBackoffMs = backoff.nextDelayMs;
                 }
-                else {
-                    try {
-                        await garbageCollectSandboxControlRoot(root, {
-                            timeoutMs: timing.quiesceDeadlineMs,
-                            inspectContainer: (timeoutMs) => inspectContainer(manifest),
-                            selfOwner: broker
-                        });
-                        active = null;
-                        return;
-                    }
-                    catch (error) {
-                        if (!brokerOwns())
-                            break;
-                        containerReasonCode = 'SANDBOX_CONTROL_CONTAINER_ABSENT_GC_FAILED';
-                        appendDiagnosticAudit(manifest, 'container-gc-failed', { reason: controlError(error).code });
-                        const backoff = nextSandboxControlBackoff(containerBackoffMs, timing.slowCheckMs);
-                        nextContainerHeartbeatAt = Date.now() + backoff.delayMs;
-                        containerBackoffMs = backoff.nextDelayMs;
-                    }
-                }
             }
             if (active?.settled) {
                 if (!brokerOwns())

package/dist/lib/sandbox/control/state.js

@@ -1,4 +1,3 @@
-import { isCompletionEvidence } from '../../task/orchestration.js';
 import { parseControlOutput } from '../../task/control-recovery.js';
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
@@ -79,9 +78,6 @@ export function terminalResultPath(manifest, requestId) {
 }
 export function createSandboxControlTerminalResult(manifest, request, output) {
     const nested = parseControlOutput(output) ?? {};
-    const run = nested.run && typeof nested.run === 'object' && !Array.isArray(nested.run)
-        ? nested.run : null;
-    const rawCompletion = nested.completionEvidence ?? run?.completionEvidence;
     const operation = request.operation ?? (typeof nested.intent === 'string' ? nested.intent : null) ?? '';
     return {
         version: 1,
@@ -91,8 +87,7 @@ export function createSandboxControlTerminalResult(manifest, request, output) {
         intentDigest: createHash('sha256').update(`${request.family}\0${operation}`, 'utf8').digest('hex'),
         targetState: typeof nested.targetState === 'string' ? nested.targetState : null,
         status: typeof nested.status === 'string' ? nested.status : 'completed',
-        changed: typeof nested.changed === 'boolean' ? nested.changed : null,
-        completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null
+        changed: typeof nested.changed === 'boolean' ? nested.changed : null
     };
 }
 export function writeSandboxControlTerminalResult(manifest, request, output) {
@@ -120,9 +115,6 @@ export function readSandboxControlTerminalResult(filePath) {
         || (value.changed !== null && typeof value.changed !== 'boolean')) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }
-    if (value.completionEvidence !== null && !isCompletionEvidence(value.completionEvidence)) {
-        throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
-    }
     if (value.changed === undefined) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }

package/dist/lib/sandbox/dockerfile.js

@@ -91,10 +91,4 @@ export function prepareDockerfile(config, image = EMPTY_IMAGE_CONTRIBUTION) {
         }
     };
 }
-export function composeDockerfile(config, image = EMPTY_IMAGE_CONTRIBUTION) {
-    const content = dockerfileContent(config, image);
-    const tempPath = path.join(os.tmpdir(), `${config.project}-sandbox.Dockerfile`);
-    fs.writeFileSync(tempPath, content, 'utf8');
-    return tempPath;
-}
 //# sourceMappingURL=dockerfile.js.map

package/dist/lib/sandbox/engine.js

@@ -131,20 +131,6 @@ export async function ensureDocker(config, onMessage, dependencies = {}) {
     ensureBuildKit(engine, dependencies.runOkEngineFn ?? runOkEngine);
     adapter.syncResources(effectiveConfig, onMessage, fns, { vmJustStarted });
 }
-export function isVmManaged(config = {}, dependencies = {}) {
-    try {
-        const engine = detectEngine(config, dependencies);
-        return isManagedEngine(engine);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : '';
-        if (message.startsWith('sandbox: platform "')
-            || / is not supported on [^.]+\. Supported engines on [^:]+: none\./.test(message)) {
-            return false;
-        }
-        throw error;
-    }
-}
 export function isManagedEngine(engine) {
     try {
         return getAdapter(engine).managed;

package/dist/lib/sandbox/engines/docker-exact-discovery.js

@@ -1,5 +1,4 @@
 import { commandForEngine, runProbe } from '../shell.js';
-import { commandForSandboxAuthority } from './authority.js';
 const FULL_CONTAINER_ID = /^[a-f0-9]{64}$/u;
 function outputText(value) {
     return typeof value === 'string' ? value : value?.toString('utf8') ?? '';
@@ -16,9 +15,7 @@ function buildExactContainerInspectArgs(id) {
     return ['container', 'inspect', '--format', '{{json .}}', id];
 }
 function runDockerProbe(engine, args, options) {
-    const command = options.authority
-        ? commandForSandboxAuthority(options.authority, 'docker', args)
-        : commandForEngine(engine, 'docker', args);
+    const command = commandForEngine(engine, 'docker', args);
     return (options.probe ?? runProbe)(command.cmd, command.args, options.timeoutMs === undefined ? {} : { timeout: options.timeoutMs });
 }
 function parseExactList(stdout, expectedId) {

package/dist/lib/sandbox/engines/wsl2-paths.js

@@ -5,9 +5,6 @@ const UNC_PATH_PATTERN = /^(?:\\\\|\/\/)[^\\/]+[\\/][^\\/]+/;
 export function hostJoin(basePath, ...segments) {
     return basePath.startsWith('/') ? path.posix.join(basePath, ...segments) : path.join(basePath, ...segments);
 }
-export function isWindowsDrivePath(value) {
-    return typeof value === 'string' && WINDOWS_DRIVE_PATH_PATTERN.test(value);
-}
 export function isUncPath(value) {
     return typeof value === 'string' && UNC_PATH_PATTERN.test(value);
 }

package/dist/lib/sandbox/recovery.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { nodeEntryArgs } from './control/executor.js';
-import { containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel, worktreeDirCandidates } from './constants.js';
+import { containerName, containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel, worktreeDirCandidates } from './constants.js';
 import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
 import { toEnginePath } from './engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from './mounts.js';
@@ -18,7 +18,7 @@ import { commandForEngine, runEngine, runOkEngine, runProbe, runVerboseEngine }
 import { declaredTmpfsSeedEntries, resolveTools, toolConfigDirCandidates } from './tools.js';
 import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from './commands/list-running.js';
 import { getProcessIdentityState, getProcessStartTime, removePidFileIfMatches } from '../server/process-state.js';
-import { acquireSandboxControlBrokerStartup, garbageCollectSandboxControlRoot, isSandboxControlRootQuiescing, readSandboxControlManifest } from './control/lifecycle.js';
+import { acquireSandboxControlBrokerStartup, isSandboxControlRootQuiescing, readSandboxControlManifest } from './control/lifecycle.js';
 import { readSandboxControlStatus } from './control/state.js';
 import { validateSandboxControlIdentity } from './control/identity-sentinel.js';
 import { appendDiagnosticAudit as appendControlDiagnosticAudit } from './control/audit.js';
@@ -198,9 +198,6 @@ async function ensureSandboxControlBroker(params) {
         throw new Error(`SANDBOX_CONTROL_CONTAINER_UNKNOWN: ${containerObservation.reason}`);
     }
     if (containerObservation.state === 'absent') {
-        await garbageCollectSandboxControlRoot(control.root, {
-            inspectContainer: (timeoutMs) => inspectSandboxControlContainer(validatedManifest, { timeoutMs })
-        });
         throw new Error('SANDBOX_CONTROL_CONTAINER_ABSENT: recreate the sandbox container before broker recovery');
     }
     const brokerPath = path.join(control.root, 'broker.json');
@@ -916,6 +913,7 @@ export async function ensureSandboxReady(params) {
     const deps = params.deps;
     const startFn = deps?.start ?? startSandboxContainer;
     const warnings = [];
+    const container = params.row?.name ?? containerName(params.config, params.branch);
     let failure = null;
     try {
         if (deps?.ensureControlBroker) {
@@ -924,11 +922,11 @@ export async function ensureSandboxReady(params) {
         else {
             await ensureSandboxControlBroker({
                 config: params.config,
-                container: params.row.name,
+                container: container,
                 workspace: params.workspace ?? { mode: 'branch-only' }
             });
         }
-        if (params.forceRecreate || (params.reentry === 'completed' && params.allowRecreate)) {
+        if (!params.row || params.forceRecreate || (params.reentry === 'completed' && params.allowRecreate)) {
             throw new Error('Explicit container recreation requested.');
         }
         if (!params.row.running) {
@@ -936,7 +934,7 @@ export async function ensureSandboxReady(params) {
             if (params.reentry === 'completed' && params.workspace?.mode === 'task-bound') {
                 const control = sandboxControlPaths({
                     base: params.config.controlBase, project: params.config.project,
-                    container: params.row.name, identity: params.workspace
+                    container: container, identity: params.workspace
                 });
                 const manifest = readSandboxControlManifest(control.manifestPath);
                 if (manifest.taskId !== params.workspace.taskId || manifest.branch !== params.branch) {
@@ -946,20 +944,20 @@ export async function ensureSandboxReady(params) {
                 startCompletedSandboxContainer({
                     config: params.config,
                     engine: params.engine,
-                    container: params.row.name,
+                    container: container,
                     taskId: params.workspace.taskId,
                     start: startFn
                 });
             }
             else {
-                startFn(params.engine, params.row.name);
+                startFn(params.engine, container);
             }
             const initial = assess({
                 config: params.config,
                 engine: params.engine,
                 branch: params.branch,
                 workspace: params.workspace,
-                container: params.row.name,
+                container: container,
                 deps
             });
             if (initial.findings.some((finding) => finding.repairKind === 'hard-failure')) {
@@ -968,13 +966,13 @@ export async function ensureSandboxReady(params) {
             const tools = resolveTools(params.config);
             prepareTmpfsMounts({
                 engine: params.engine,
-                container: params.row.name,
+                container: container,
                 mountPaths: tools.filter((tool) => tool.tmpfs).map((tool) => tool.containerMount),
                 deps
             });
             hydrateTmpfsSeedEntries({
                 engine: params.engine,
-                container: params.row.name,
+                container: container,
                 entries: mountedSeeds(initial.snapshot),
                 replace: true,
                 deps
@@ -984,13 +982,13 @@ export async function ensureSandboxReady(params) {
                 engine: params.engine,
                 branch: params.branch,
                 workspace: params.workspace,
-                container: params.row.name,
+                container: container,
                 deps
             });
             if (!final.findings.some((finding) => finding.repairKind === 'hard-failure')) {
                 repairFindings({
                     engine: params.engine,
-                    container: params.row.name,
+                    container: container,
                     findings: final.findings,
                     deps
                 });
@@ -999,7 +997,7 @@ export async function ensureSandboxReady(params) {
                     engine: params.engine,
                     branch: params.branch,
                     workspace: params.workspace,
-                    container: params.row.name,
+                    container: container,
                     deps
                 });
             }
@@ -1015,18 +1013,18 @@ export async function ensureSandboxReady(params) {
                 publishCompletedReentry(manifest, evidence);
                 await waitForCompletedReentry(manifest, evidence);
             }
-            return { container: params.row.name, path: 'recovered', warnings };
+            return { container: container, path: 'recovered', warnings };
         }
         const initial = assess({
             config: params.config,
             engine: params.engine,
             branch: params.branch,
             workspace: params.workspace,
-            container: params.row.name,
+            container: container,
             deps
         });
         if (initial.findings.length === 0) {
-            return { container: params.row.name, path: 'healthy', warnings };
+            return { container: container, path: 'healthy', warnings };
         }
         if (initial.findings.some((finding) => finding.repairKind === 'hard-failure')) {
             throw new Error(describeFindings(initial.findings));
@@ -1036,7 +1034,7 @@ export async function ensureSandboxReady(params) {
         if (permissionFindings.length > 0) {
             repairFindings({
                 engine: params.engine,
-                container: params.row.name,
+                container: container,
                 findings: permissionFindings,
                 deps
             });
@@ -1045,7 +1043,7 @@ export async function ensureSandboxReady(params) {
                 engine: params.engine,
                 branch: params.branch,
                 workspace: params.workspace,
-                container: params.row.name,
+                container: container,
                 deps
             });
             if (current.findings.some((finding) => finding.repairKind === 'hard-failure'
@@ -1055,7 +1053,7 @@ export async function ensureSandboxReady(params) {
         }
         repairFindings({
             engine: params.engine,
-            container: params.row.name,
+            container: container,
             findings: current.findings,
             deps
         });
@@ -1064,13 +1062,13 @@ export async function ensureSandboxReady(params) {
             engine: params.engine,
             branch: params.branch,
             workspace: params.workspace,
-            container: params.row.name,
+            container: container,
             deps
         });
         if (final.findings.length > 0) {
             throw new Error(describeFindings(final.findings));
         }
-        return { container: params.row.name, path: 'recovered', warnings };
+        return { container: container, path: 'recovered', warnings };
     }
     catch (error) {
         failure = error instanceof Error ? error : new Error(String(error));
@@ -1081,7 +1079,7 @@ export async function ensureSandboxReady(params) {
         }
         const taskId = params.workspace.taskId;
         const commandChain = [
-            `docker exec -it ${params.row.name} bash /usr/local/bin/sandbox-tmux-entry`,
+            `docker exec -it ${container} bash /usr/local/bin/sandbox-tmux-entry`,
             `ai sandbox rm ${taskId}`,
             `ai sandbox create ${params.branch}`
         ];
@@ -1093,7 +1091,7 @@ export async function ensureSandboxReady(params) {
             : 'Completed sandbox recovery failed; the existing container was not replaced.';
         throw new Error([
             `${code}: ${lead}`,
-            `Task: ${taskId}; container: ${params.row.name}; branch: ${params.branch}.`,
+            `Task: ${taskId}; container: ${container}; branch: ${params.branch}.`,
             'To preserve the current container state, enter it manually with:',
             `  ${commandChain[0]}`,
             'If you intentionally want a replacement, the following is the full interactive sandbox cleanup, not a container-only delete.',