@fitlab-ai/agent-infra 0.9.10 → 0.9.12

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

@@ -414,8 +414,6 @@ function readProcessingSnapshot(root) {
 export function captureSandboxControlCutoverSnapshot(root) {
     const resolvedRoot = path.resolve(root);
     const manifestPath = path.join(resolvedRoot, 'manifest.json');
-    if (fs.existsSync(manifestPath))
-        readSandboxControlManifestForTransition(manifestPath);
     return {
         root: resolvedRoot,
         manifestRaw: readOptionalRaw(manifestPath),
@@ -430,7 +428,7 @@ export function assertSandboxControlCutoverSnapshot(snapshot) {
         throw new Error('SANDBOX_CONTROL_OWNER_TRANSITION');
     }
 }
-function readSandboxControlManifestValue(manifestPath, allowLegacy) {
+function readSandboxControlManifestValue(manifestPath) {
     if (!regularFile(manifestPath))
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     let manifest;
@@ -445,25 +443,35 @@ function readSandboxControlManifestValue(manifestPath, allowLegacy) {
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
     const candidate = manifest;
-    if (candidate.version !== 4 && candidate.version !== 5) {
-        throw new Error('SANDBOX_CONTROL_MANIFEST_VERSION_INVALID: expected version 5; container-only recreation is required');
+    const expectedKeys = [
+        'branch', 'channelDir', 'container', 'containerIdentity', 'engine', 'generation',
+        'mode', 'processingDir', 'project', 'publicStatusDir', 'repoRoot', 'runtimeDir',
+        'taskId', 'token', 'worktreeRoot'
+    ];
+    if (Object.keys(manifest).sort().join(',') !== expectedKeys.sort().join(',')) {
+        throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
     if (typeof candidate.containerIdentity !== 'object' || candidate.containerIdentity === null
         || Array.isArray(candidate.containerIdentity))
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     const containerIdentity = candidate.containerIdentity;
-    if (typeof candidate.engine !== 'string' || candidate.engine.length === 0
+    if (Object.keys(containerIdentity).sort().join(',') !== 'id,labels'
+        || typeof candidate.engine !== 'string' || candidate.engine.length === 0
         || typeof candidate.repoRoot !== 'string' || typeof candidate.worktreeRoot !== 'string'
         || typeof candidate.project !== 'string' || typeof candidate.container !== 'string'
         || typeof containerIdentity.id !== 'string' || containerIdentity.id.length === 0
         || typeof containerIdentity.labels !== 'object' || containerIdentity.labels === null
         || Array.isArray(containerIdentity.labels)
         || Object.values(containerIdentity.labels).some((value) => typeof value !== 'string')
-        || typeof candidate.branch !== 'string' || !['task-bound', 'branch-only'].includes(candidate.mode ?? '')
+        || typeof candidate.branch !== 'string'
+        || (candidate.mode !== 'task-bound' && candidate.mode !== 'branch-only')
         || (candidate.taskId !== null && typeof candidate.taskId !== 'string')
         || typeof candidate.channelDir !== 'string' || typeof candidate.publicStatusDir !== 'string'
-        || typeof candidate.processingDir !== 'string' || typeof candidate.token !== 'string'
-        || typeof candidate.generation !== 'string')
+        || typeof candidate.processingDir !== 'string' || typeof candidate.runtimeDir !== 'string'
+        || typeof candidate.token !== 'string'
+        || typeof candidate.generation !== 'string'
+        || (candidate.mode === 'task-bound' && (typeof candidate.taskId !== 'string' || candidate.taskId.length === 0))
+        || (candidate.mode === 'branch-only' && candidate.taskId !== null))
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     const root = path.dirname(path.resolve(manifestPath));
     if (path.resolve(candidate.channelDir) !== path.join(root, 'channel')
@@ -471,22 +479,33 @@ function readSandboxControlManifestValue(manifestPath, allowLegacy) {
         || path.resolve(candidate.processingDir) !== path.join(root, 'processing')) {
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
-    if (candidate.version === 4) {
-        if (!allowLegacy) {
-            throw new Error('SANDBOX_CONTROL_MANIFEST_VERSION_INVALID: expected version 5; container-only recreation is required');
-        }
-        return candidate;
-    }
-    if (typeof candidate.runtimeDir !== 'string' || path.resolve(candidate.runtimeDir) !== path.join(root, 'runtime')) {
+    if (path.resolve(candidate.runtimeDir) !== path.join(root, 'runtime')) {
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
-    return candidate;
+    const normalized = {
+        engine: candidate.engine,
+        repoRoot: candidate.repoRoot,
+        worktreeRoot: candidate.worktreeRoot,
+        project: candidate.project,
+        container: candidate.container,
+        containerIdentity: {
+            id: containerIdentity.id,
+            labels: { ...containerIdentity.labels }
+        },
+        branch: candidate.branch,
+        mode: candidate.mode,
+        taskId: candidate.taskId,
+        token: candidate.token,
+        generation: candidate.generation,
+        channelDir: candidate.channelDir,
+        publicStatusDir: candidate.publicStatusDir,
+        processingDir: candidate.processingDir,
+        runtimeDir: candidate.runtimeDir
+    };
+    return normalized;
 }
 export function readSandboxControlManifest(manifestPath) {
-    return readSandboxControlManifestValue(manifestPath, false);
-}
-export function readSandboxControlManifestForTransition(manifestPath) {
-    return readSandboxControlManifestValue(manifestPath, true);
+    return readSandboxControlManifestValue(manifestPath);
 }
 function readBrokerOwner(filePath) {
     if (!fs.existsSync(filePath))
@@ -507,6 +526,18 @@ function readBrokerOwner(filePath) {
         throw new Error('SANDBOX_CONTROL_OWNER_MISMATCH');
     return owner;
 }
+export function assertSandboxControlBrokerOwner(manifest, options = {}) {
+    const root = path.dirname(path.resolve(manifest.publicStatusDir));
+    const owner = readBrokerOwner(path.join(root, 'broker.json'));
+    if (!owner)
+        throw new Error('SANDBOX_CONTROL_OWNER_EVIDENCE_MISSING');
+    if (owner.token !== manifest.token || owner.generation !== manifest.generation) {
+        throw new Error('SANDBOX_CONTROL_OWNER_MISMATCH');
+    }
+    if (!ownerLive(owner, options.identityProbe))
+        throw new Error('SANDBOX_CONTROL_OWNER_LOST');
+    return owner;
+}
 function readStatusOwner(filePath) {
     if (!fs.existsSync(filePath))
         return null;
@@ -641,7 +672,7 @@ export async function quiesceSandboxControlRoot(root, options = {}) {
     markSandboxControlRootQuiescing(resolvedRoot);
     await waitForStartupTransition(resolvedRoot, Math.max(0, forceAt - Date.now()), identityProbe);
     const manifestPath = path.join(resolvedRoot, 'manifest.json');
-    const manifest = fs.existsSync(manifestPath) ? readSandboxControlManifestForTransition(manifestPath) : null;
+    const manifest = fs.existsSync(manifestPath) ? readSandboxControlManifest(manifestPath) : null;
     const broker = readBrokerOwner(path.join(resolvedRoot, 'broker.json'));
     const status = readStatusOwner(path.join(resolvedRoot, 'public', 'status.json'));
     const statusOwner = status ? status.broker : null;
@@ -730,7 +761,7 @@ export async function removeSandboxControlRoot(root, options) {
     if (!stat.isDirectory() || stat.isSymbolicLink())
         throw new Error('SANDBOX_CONTROL_CHANNEL_INVALID');
     const manifestPath = path.join(resolvedRoot, 'manifest.json');
-    const manifest = readSandboxControlManifestForTransition(manifestPath);
+    const manifest = readSandboxControlManifest(manifestPath);
     const inspectContainer = options.inspectContainer
         ?? ((timeoutMs) => inspectSandboxControlContainer(manifest, { timeoutMs }));
     const timeoutMs = options.timeoutMs ?? options.timing?.quiesceDeadlineMs ?? DEFAULT_QUIESCE_TIMEOUT_MS;
@@ -792,7 +823,7 @@ export async function removeSandboxControlRoot(root, options) {
                 : 'SANDBOX_CONTROL_CONTAINER_STILL_EXISTS');
         }
     }
-    const currentManifest = readSandboxControlManifestForTransition(manifestPath);
+    const currentManifest = readSandboxControlManifest(manifestPath);
     if (currentManifest.token !== manifest.token || currentManifest.generation !== manifest.generation
         || !isSandboxControlRootQuiescing(resolvedRoot)) {
         throw new Error('SANDBOX_CONTROL_OWNER_TRANSITION');

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

@@ -197,6 +197,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
         if (!recoverProcessing(manifest, brokerOwns))
             return;
         while (!signal.aborted) {
+            let settledExecution = null;
             if (!brokerOwns())
                 break;
             let current;
@@ -255,22 +256,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
             if (active?.settled) {
                 if (!brokerOwns())
                     break;
-                if (active.result) {
-                    if (!brokerOwns())
-                        break;
-                    writeResponse(manifest, {
-                        version: 2, id: active.request.id, phase: 'completed', exitCode: active.result.exitCode,
-                        stdout: active.result.stdout, stderr: active.result.stderr, error: null
-                    });
-                }
-                else {
-                    if (!brokerOwns())
-                        break;
-                    writeResponse(manifest, unknown(active.request.id));
-                }
-                if (!brokerOwns())
-                    break;
-                fs.rmSync(path.join(manifest.processingDir, active.request.id), { recursive: true, force: true });
+                settledExecution = active;
                 active = null;
             }
             let reasonCode = null;
@@ -313,6 +299,22 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                 appendSandboxControlAudit(manifest, 'broker-state', { state, reasonCode, requestId: active?.request.id ?? null });
                 lastState = stateKey;
             }
+            if (settledExecution) {
+                if (!brokerOwns())
+                    break;
+                if (settledExecution.result) {
+                    writeResponse(manifest, {
+                        version: 2, id: settledExecution.request.id, phase: 'completed', exitCode: settledExecution.result.exitCode,
+                        stdout: settledExecution.result.stdout, stderr: settledExecution.result.stderr, error: null
+                    });
+                }
+                else {
+                    writeResponse(manifest, unknown(settledExecution.request.id));
+                }
+                if (!brokerOwns())
+                    break;
+                fs.rmSync(path.join(manifest.processingDir, settledExecution.request.id), { recursive: true, force: true });
+            }
             let retiring = false;
             for (const name of fs.readdirSync(requestsDir).sort()) {
                 if (!/^[a-f0-9-]{16,64}\.json$/.test(name))

package/dist/lib/sandbox/mounts.js

@@ -2,7 +2,8 @@ import path from 'node:path';
 import { shareBranchDir, shareCommonDir, shellConfigDirCandidates, worktreeDirCandidates } from './constants.js';
 import { sandboxWorkspaceViewStatePaths } from './workspace-view.js';
 export function sandboxCoreBindMounts(config, branch, overrides) {
-    const taskBound = Boolean(overrides.taskSource && overrides.taskId);
+    const taskSources = overrides.taskSources ?? [];
+    const taskBound = Boolean(taskSources.length > 0 && overrides.taskId);
     const workspaceMounts = sandboxWorkspaceViewStatePaths(overrides.workspaceViewRoot).map(({ state, hostPath }) => taskBound && state === 'active'
         ? {
             hostPaths: [path.join(hostPath, '.short-ids.json')],
@@ -26,7 +27,7 @@ export function sandboxCoreBindMounts(config, branch, overrides) {
     ];
     if (taskBound) {
         mounts.push({
-            hostPaths: [overrides.taskSource],
+            hostPaths: taskSources,
             containerPath: path.posix.join('/workspace/.agents/workspace/active', overrides.taskId),
             readOnly: false
         });

package/dist/lib/sandbox/recovery.js

@@ -9,6 +9,7 @@ import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
 import { toEnginePath } from './engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from './mounts.js';
 import { assertSandboxTaskSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
+import { resolveTaskWorkspace } from './task-resolver.js';
 import { parseSandboxWorkspaceIdentity, sameSandboxWorkspaceIdentity } from './workspace-identity.js';
 import { inspectWorktree } from './worktree-safety.js';
 import { commandForEngine, runEngine, runOkEngine, runProbe, runVerboseEngine } from './shell.js';
@@ -407,6 +408,66 @@ function sourceCandidates(engine, hostPath) {
     }
     return [...new Set(candidates.map((candidate) => normalizeMountSource(engine, candidate)))];
 }
+function recoveryTaskSources(repoRoot, taskId) {
+    const activePath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const completedPath = path.join(repoRoot, '.agents', 'workspace', 'completed', taskId);
+    if (fs.existsSync(activePath) && !fs.existsSync(completedPath)) {
+        const source = assertSandboxTaskSource(repoRoot, taskId);
+        return { mountPaths: [source], accessiblePaths: [source] };
+    }
+    const task = resolveTaskWorkspace(taskId, repoRoot);
+    if (task.state === 'active') {
+        const source = assertSandboxTaskSource(repoRoot, taskId);
+        return { mountPaths: [source], accessiblePaths: [source] };
+    }
+    if (task.state !== 'completed') {
+        throw new Error(`SANDBOX_TASK_SOURCE_STATE_UNSUPPORTED: task ${taskId} is ${task.state}`);
+    }
+    const completedRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace', 'completed'));
+    const completedSource = fs.realpathSync.native(path.dirname(task.taskMd));
+    if (path.dirname(completedSource) !== completedRoot) {
+        throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${completedSource} is not under completed workspace`);
+    }
+    const historicalActivePath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const mountPaths = [completedSource, historicalActivePath];
+    if (fs.existsSync(historicalActivePath)) {
+        try {
+            mountPaths[1] = fs.realpathSync.native(historicalActivePath);
+        }
+        catch {
+            // Keep the exact historical path as a candidate; the current completed
+            // source remains the only source that must still be accessible.
+        }
+    }
+    return { mountPaths, accessiblePaths: [completedSource] };
+}
+function startCompletedSandboxContainer(params) {
+    const taskSources = recoveryTaskSources(params.config.repoRoot, params.taskId);
+    const completedSource = taskSources.accessiblePaths[0];
+    const activeRoot = path.join(params.config.repoRoot, '.agents', 'workspace', 'active');
+    const historicalSource = path.join(activeRoot, params.taskId);
+    fs.mkdirSync(activeRoot, { recursive: true });
+    try {
+        fs.lstatSync(historicalSource);
+        throw new Error(`SANDBOX_COMPLETED_SOURCE_CONFLICT: historical task source already exists at ${historicalSource}`);
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT'))
+            throw error;
+    }
+    fs.symlinkSync(completedSource, historicalSource, process.platform === 'win32' ? 'junction' : 'dir');
+    try {
+        params.start(params.engine, params.container);
+    }
+    finally {
+        const temporarySource = fs.lstatSync(historicalSource);
+        const resolvedSource = fs.realpathSync.native(historicalSource);
+        if (!temporarySource.isSymbolicLink() || resolvedSource !== completedSource) {
+            throw new Error(`SANDBOX_COMPLETED_SOURCE_CHANGED: refusing to remove unexpected path at ${historicalSource}`);
+        }
+        fs.unlinkSync(historicalSource);
+    }
+}
 function sameHostSource(left, right) {
     try {
         const leftStat = fs.statSync(left, { bigint: true });
@@ -440,21 +501,29 @@ function expectedMounts(params) {
         container: params.container,
         identity: params.workspace
     });
+    const taskSources = params.workspace.mode === 'task-bound'
+        ? recoveryTaskSources(config.repoRoot, params.workspace.taskId)
+        : null;
+    const taskId = params.workspace.mode === 'task-bound' ? params.workspace.taskId : null;
     const core = sandboxCoreBindMounts(config, branch, {
         workspaceViewRoot: view.root,
         controlDir: control.channelDir,
         controlStatusDir: control.statusDir,
-        ...(params.workspace.mode === 'task-bound'
-            ? {
+        ...(taskSources === null
+            ? {}
+            : {
                 runtimeDir: control.runtimeDir,
-                taskSource: assertSandboxTaskSource(config.repoRoot, params.workspace.taskId),
-                taskId: params.workspace.taskId
-            }
-            : {})
+                taskSources: taskSources.mountPaths,
+                taskId: taskId
+            })
     }).map((mount) => ({
         path: mount.containerPath,
         expectedType: 'bind',
         hostPaths: mount.hostPaths,
+        ...(taskSources !== null && taskId !== null
+            && mount.containerPath === `/workspace/.agents/workspace/active/${taskId}`
+            ? { sourceAccessiblePaths: taskSources.accessiblePaths }
+            : {}),
         expectedRW: !mount.readOnly
     }));
     const live = tools.flatMap((tool) => (tool.hostLiveMounts ?? []).flatMap(({ hostPath, containerSubpath }) => {
@@ -469,9 +538,7 @@ function expectedMounts(params) {
             }];
     }));
     const persistentTools = tools
-        .filter((tool) => !tool.tmpfs
-        && (config.agentClientSource === 'canonical'
-            || actualMounts.has(tool.containerMount)))
+        .filter((tool) => !tool.tmpfs)
         .map((tool) => ({
         path: tool.containerMount,
         expectedType: 'bind',
@@ -577,13 +644,10 @@ export function collectSandboxRecoverySnapshot(params) {
         taskId: sandboxTaskIdLabel(params.config)
     });
     const selectedToolIds = new Set(tools.map((tool) => tool.id));
-    const enforceCanonicalPlan = params.config.agentClientSource === 'canonical';
-    const unexpectedCapabilityMounts = enforceCanonicalPlan
-        ? capabilityPlan.cleanupInventory
-            .filter((tool) => isAgentClientId(tool.id) && !selectedToolIds.has(tool.id))
-            .map((tool) => tool.containerMount)
-            .filter((mountPath) => mountsByDestination.has(mountPath))
-        : [];
+    const unexpectedCapabilityMounts = capabilityPlan.cleanupInventory
+        .filter((tool) => isAgentClientId(tool.id) && !selectedToolIds.has(tool.id))
+        .map((tool) => tool.containerMount)
+        .filter((mountPath) => mountsByDestination.has(mountPath));
     const mountSnapshots = expectedMounts({
         config: params.config,
         branch: params.branch,
@@ -616,7 +680,7 @@ export function collectSandboxRecoverySnapshot(params) {
             sourceAccessible: expected.expectedType === 'tmpfs'
                 ? true
                 : matchedHostPath !== undefined
-                    && hostSourceAccessible(matchedHostPath, expected.expectedRW)
+                    && (expected.sourceAccessiblePaths ?? [matchedHostPath]).some((hostPath) => hostSourceAccessible(hostPath, expected.expectedRW))
         };
     });
     return {
@@ -636,9 +700,7 @@ export function collectSandboxRecoverySnapshot(params) {
         identityOk: typeof inspection.Id === 'string' && inspection.Id.length > 0
             && branchLabel === params.branch
             && sameSandboxWorkspaceIdentity(containerWorkspace, workspace),
-        runtimeCapabilityOk: enforceCanonicalPlan
-            ? labels[sandboxRuntimeCapabilityLabel(params.config)] === capabilityPlan.runtimeSignature
-            : undefined,
+        runtimeCapabilityOk: labels[sandboxRuntimeCapabilityLabel(params.config)] === capabilityPlan.runtimeSignature,
         unexpectedCapabilityMounts,
         mounts: mountSnapshots,
         tmpfs,
@@ -813,11 +875,22 @@ export async function ensureSandboxReady(params) {
                 workspace: params.workspace ?? { mode: 'branch-only' }
             });
         }
-        if (params.forceRecreate) {
+        if (params.forceRecreate || (params.reentry === 'completed' && params.allowRecreate)) {
             throw new Error('Explicit container recreation requested.');
         }
         if (!params.row.running) {
-            startFn(params.engine, params.row.name);
+            if (params.reentry === 'completed' && params.workspace?.mode === 'task-bound') {
+                startCompletedSandboxContainer({
+                    config: params.config,
+                    engine: params.engine,
+                    container: params.row.name,
+                    taskId: params.workspace.taskId,
+                    start: startFn
+                });
+            }
+            else {
+                startFn(params.engine, params.row.name);
+            }
             const initial = assess({
                 config: params.config,
                 engine: params.engine,
@@ -930,6 +1003,34 @@ export async function ensureSandboxReady(params) {
     catch (error) {
         failure = error instanceof Error ? error : new Error(String(error));
     }
+    if (params.reentry === 'completed') {
+        if (params.workspace?.mode !== 'task-bound') {
+            throw new Error('SANDBOX_COMPLETED_REENTRY_INVALID: completed re-entry requires a task-bound workspace');
+        }
+        const taskId = params.workspace.taskId;
+        const commandChain = [
+            `docker exec -it ${params.row.name} bash /usr/local/bin/sandbox-tmux-entry`,
+            `ai sandbox rm ${taskId}`,
+            `ai sandbox create ${params.branch}`
+        ];
+        const code = params.allowRecreate || params.forceRecreate
+            ? 'SANDBOX_COMPLETED_RECREATE_UNSUPPORTED'
+            : 'SANDBOX_COMPLETED_REENTRY_FAILED';
+        const lead = code === 'SANDBOX_COMPLETED_RECREATE_UNSUPPORTED'
+            ? 'Completed sandbox replacement is unsupported; the existing container was not replaced.'
+            : 'Completed sandbox recovery failed; the existing container was not replaced.';
+        throw new Error([
+            `${code}: ${lead}`,
+            `Task: ${taskId}; container: ${params.row.name}; 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.',
+            'It may remove the worktree, local branch, tool/shell state, and branch share:',
+            `  ${commandChain[1]}`,
+            `  ${commandChain[2]}`,
+            `Details: ${failure.message}`
+        ].join('\n'));
+    }
     const dataBoundary = 'The existing container writable layer, ordinary /tmp data, processes, tmux sessions, and RAM state may be lost by replacement; worktree and host-managed sandbox data are preserved.';
     const recoveryTarget = params.workspace?.mode === 'task-bound'
         ? params.workspace.taskId

package/dist/lib/sandbox/workspace-identity.js

@@ -79,6 +79,20 @@ export function resolveSandboxTarget(requestedRef, repoRoot) {
     }
     return { requestedRef, branch: requestedRef, workspace: { mode: 'branch-only' } };
 }
+export function resolveSandboxReentryContext(params) {
+    if (params.target.workspace.mode !== 'branch-only'
+        || params.containerWorkspace.mode !== 'task-bound') {
+        return { workspace: params.target.workspace, reentry: 'standard' };
+    }
+    const task = resolveTaskWorkspace(params.containerWorkspace.taskId, params.repoRoot);
+    if (task.state !== 'completed' || task.branch !== params.target.branch) {
+        return { workspace: params.target.workspace, reentry: 'standard' };
+    }
+    return {
+        workspace: { mode: 'task-bound', taskId: task.taskId },
+        reentry: 'completed'
+    };
+}
 export function resolveSandboxCleanupTarget(requestedRef, repoRoot, options = {}) {
     if (isRemovedHashShortIdInput(requestedRef)) {
         throw new Error(`Invalid task short id '${requestedRef}': task short ids must use bare digits`);

package/dist/lib/sandbox/workspace-view.js

@@ -171,14 +171,12 @@ export function materializeSandboxControl(params) {
     const token = randomBytes(32).toString('hex');
     const generation = randomBytes(16).toString('hex');
     const repoRoot = fs.realpathSync.native(params.repoRoot);
-    const manifest = {
-        version: 5,
+    const manifestDraft = {
         engine: params.engine ?? 'docker',
         repoRoot,
         worktreeRoot: fs.realpathSync.native(params.worktreeRoot),
         project: params.project,
         container: params.container,
-        containerIdentity: { id: '', labels: {} },
         branch: params.branch,
         mode: params.identity.mode,
         taskId: params.identity.mode === 'task-bound' ? params.identity.taskId : null,
@@ -189,16 +187,16 @@ export function materializeSandboxControl(params) {
         processingDir,
         runtimeDir
     };
-    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest)}\n`, { mode: 0o600 });
-    return { root, channelDir, statusDir, runtimeDir, manifestPath, token, generation };
+    return { root, channelDir, statusDir, runtimeDir, manifestPath, manifestDraft, token, generation };
 }
 export function finalizeSandboxControlManifest(setup, identity) {
     if (!identity.engine || !identity.id)
         throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
-    const manifest = JSON.parse(fs.readFileSync(setup.manifestPath, 'utf8'));
-    manifest.version = 5;
-    manifest.engine = identity.engine;
-    manifest.containerIdentity = { id: identity.id, labels: { ...identity.labels } };
+    const manifest = {
+        ...setup.manifestDraft,
+        engine: identity.engine,
+        containerIdentity: { id: identity.id, labels: { ...identity.labels } }
+    };
     const temporary = `${setup.manifestPath}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
     try {
         fs.writeFileSync(temporary, `${JSON.stringify(manifest)}\n`, { mode: 0o600, flag: 'wx' });
@@ -207,5 +205,6 @@ export function finalizeSandboxControlManifest(setup, identity) {
     finally {
         fs.rmSync(temporary, { force: true });
     }
+    return manifest;
 }
 //# sourceMappingURL=workspace-view.js.map