@fitlab-ai/agent-infra 0.11.10 → 0.11.11

package/dist/lib/platform/verification-sync.js

@@ -457,7 +457,7 @@ function checkTaskCommentContent(context, remoteData, shared) {
     return shared.failResult(CHECK_TYPE, buildCommentContentMismatchMessage("task", context.issueNumber, expectedBody, commentBody), "check_failed");
 }
 function checkPrTypeLabel(context, remoteData, shared) {
-    if (!context.audit.enabled || !context.hasTriage || !context.prNumber || !remoteData.prLabels) {
+    if (!context.audit.enabled || !context.hasTriage || !context.prIdentity || remoteData.prLabels === undefined || remoteData.prLabels === null) {
         return infoResult('PR type-label audit is not applicable because the required PR metadata or capability is unavailable');
     }
     const expectedLabel = mapTaskTypeToLabel(context.task.metadata.type);
@@ -465,12 +465,12 @@ function checkPrTypeLabel(context, remoteData, shared) {
         return infoResult('PR type-label audit is not applicable because the task type has no label mapping');
     }
     if (remoteData.prLabels.includes(expectedLabel)) {
-        return shared.passResult(CHECK_TYPE, `PR #${context.prNumber} has expected type label '${expectedLabel}'`);
+        return shared.passResult(CHECK_TYPE, `${pullRequestLabel(context)} has expected type label '${expectedLabel}'`);
     }
-    return shared.failResult(CHECK_TYPE, `Expected type label '${expectedLabel}' not found on PR #${context.prNumber}`, "check_failed");
+    return shared.failResult(CHECK_TYPE, `Expected type label '${expectedLabel}' not found on ${pullRequestLabel(context)}`, "check_failed");
 }
 function checkInLabelsMatchPr(context, remoteData, shared) {
-    if (!context.audit.enabled || !context.hasTriage || !context.prNumber || !remoteData.prLabels) {
+    if (!context.audit.enabled || !context.hasTriage || !context.prIdentity || remoteData.prLabels === undefined || remoteData.prLabels === null) {
         return infoResult('PR in: label audit is not applicable because the required PR metadata or capability is unavailable');
     }
     const issueInLabels = extractLabelNames(remoteData.issue.labels)
@@ -480,9 +480,12 @@ function checkInLabelsMatchPr(context, remoteData, shared) {
         .filter((label) => label.startsWith("in:"))
         .sort();
     if (arraysEqual(issueInLabels, prInLabels)) {
-        return shared.passResult(CHECK_TYPE, `PR #${context.prNumber} in: labels match Issue #${context.issueNumber}`);
+        return shared.passResult(CHECK_TYPE, `${pullRequestLabel(context)} in: labels match Issue #${context.issueNumber}`);
     }
-    return shared.failResult(CHECK_TYPE, `in: labels mismatch — PR #${context.prNumber} has [${formatLabelList(prInLabels)}], Issue #${context.issueNumber} has [${formatLabelList(issueInLabels)}]`, "check_failed");
+    return shared.failResult(CHECK_TYPE, `in: labels mismatch — ${pullRequestLabel(context)} has [${formatLabelList(prInLabels)}], Issue #${context.issueNumber} has [${formatLabelList(issueInLabels)}]`, "check_failed");
+}
+function pullRequestLabel(context) {
+    return context.prNumber ? `PR #${context.prNumber}` : 'Pull request';
 }
 function checkInLabelsComputed(context, remoteData, shared) {
     if (!context.audit.enabled || !context.hasTriage) {
@@ -574,13 +577,13 @@ function checkIssueFields(context, remoteData, shared) {
     return shared.passResult(CHECK_TYPE, `Issue #${context.issueNumber} fields match task metadata`);
 }
 function checkPrAssignee(context, remoteData, shared) {
-    if (!context.audit.enabled || !context.hasPush || !context.prNumber) {
+    if (!context.audit.enabled || !context.hasPush || !context.prIdentity || remoteData.prAssignees === undefined || remoteData.prAssignees === null) {
         return infoResult('PR assignee audit is not applicable because it is disabled or required PR metadata/capability is unavailable');
     }
-    if (!remoteData.prAssignees || remoteData.prAssignees.length === 0) {
-        return shared.failResult(CHECK_TYPE, `PR #${context.prNumber} has no assignee`, "check_failed");
+    if (remoteData.prAssignees.length === 0) {
+        return shared.failResult(CHECK_TYPE, `${pullRequestLabel(context)} has no assignee`, "check_failed");
     }
-    return shared.passResult(CHECK_TYPE, `PR #${context.prNumber} has an assignee`);
+    return shared.passResult(CHECK_TYPE, `${pullRequestLabel(context)} has an assignee`);
 }
 function checkMilestone(context, remoteData, shared) {
     if (!context.hasTriage) {
@@ -589,16 +592,16 @@ function checkMilestone(context, remoteData, shared) {
     if (!remoteData.issue?.milestone?.title) {
         return shared.failResult(CHECK_TYPE, `Issue #${context.issueNumber} has no milestone set`, "check_failed");
     }
-    if (context.prNumber && remoteData.prMilestone !== undefined && !remoteData.prMilestone?.title) {
-        return shared.failResult(CHECK_TYPE, `PR #${context.prNumber} has no milestone set`, "check_failed");
+    if (context.prIdentity && remoteData.prMilestone !== undefined && !remoteData.prMilestone?.title) {
+        return shared.failResult(CHECK_TYPE, `${pullRequestLabel(context)} has no milestone set`, "check_failed");
     }
     if (context.audit.requireSpecificMilestone) {
         const issueTitle = remoteData.issue.milestone.title;
         if (VERSION_LINE_REGEX.test(issueTitle)) {
             return shared.failResult(CHECK_TYPE, `Issue #${context.issueNumber} milestone '${issueTitle}' is a release line; narrow to a specific version (e.g. ${issueTitle.replace(/\.x$/, ".N")}) before continuing`, "check_failed");
         }
-        if (context.prNumber && remoteData.prMilestone?.title && VERSION_LINE_REGEX.test(remoteData.prMilestone.title)) {
-            return shared.failResult(CHECK_TYPE, `PR #${context.prNumber} milestone '${remoteData.prMilestone.title}' is a release line; narrow to a specific version before continuing`, "check_failed");
+        if (context.prIdentity && remoteData.prMilestone?.title && VERSION_LINE_REGEX.test(remoteData.prMilestone.title)) {
+            return shared.failResult(CHECK_TYPE, `${pullRequestLabel(context)} milestone '${remoteData.prMilestone.title}' is a release line; narrow to a specific version before continuing`, "check_failed");
         }
     }
     return shared.passResult(CHECK_TYPE, `Issue #${context.issueNumber} milestone satisfies the configured policy`);

package/dist/lib/sandbox/commands/create.js

@@ -672,7 +672,7 @@ function readProjectInitCommandDigest(controlRoot) {
 function writeProjectInitCommandDigest(controlRoot, commandSha256) {
     atomicWriteJson(path.join(controlRoot, 'project-init.json'), { version: 1, commandSha256 });
 }
-export async function create(args, { runProjectInitCommand = true } = {}) {
+export async function create(args, { runProjectInitCommand = true, workspace: workspaceOverride } = {}) {
     const { values, positionals } = parseArgs({
         args,
         allowPositionals: true,
@@ -696,7 +696,13 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
     validateSelinuxDisableEnv();
     const config = loadConfig();
     const [branchOrTaskId = '', base] = positionals;
-    const target = resolveSandboxTarget(branchOrTaskId, config.repoRoot);
+    const resolvedTarget = resolveSandboxTarget(branchOrTaskId, config.repoRoot);
+    const workspace = workspaceOverride?.mode === 'task-bound'
+        && resolvedTarget.workspace.mode === 'task-bound'
+        && workspaceOverride.taskId === resolvedTarget.workspace.taskId
+        ? resolvedTarget.workspace
+        : workspaceOverride ?? resolvedTarget.workspace;
+    const target = { ...resolvedTarget, workspace };
     const branch = target.branch;
     assertValidBranchName(branch);
     const effectiveConfig = {
@@ -866,6 +872,9 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
                 task: async () => {
                     for (const { tool, dir } of effectiveResolvedTools) {
                         fs.mkdirSync(dir, { recursive: true });
+                        for (const { hostSubdir } of tool.hostStateMounts ?? []) {
+                            fs.mkdirSync(path.join(dir, hostSubdir), { recursive: true });
+                        }
                         for (const { hostPath, sandboxName } of tool.hostPreSeedFiles ?? []) {
                             const destination = path.join(dir, sandboxName);
                             if (fs.existsSync(hostPath) && !fs.existsSync(destination)) {
@@ -1105,6 +1114,10 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
                                 '-v',
                                 volumeArg(engine, hostPath, path.posix.join(tool.containerMount, containerSubpath))
                             ]));
+                            const hostStateMountVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) => (tool.hostStateMounts ?? []).flatMap(({ hostSubdir, containerSubpath }) => [
+                                '-v',
+                                volumeArg(engine, path.join(dir, hostSubdir), path.posix.join(tool.containerMount, containerSubpath))
+                            ]));
                             fs.mkdirSync(shareCommon, { recursive: true });
                             fs.mkdirSync(shareBranch, { recursive: true });
                             fs.mkdirSync(clipboardHostDir(effectiveConfig.home), { recursive: true, mode: 0o700 });
@@ -1133,6 +1146,8 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
                                     `${sandboxBranchLabel(effectiveConfig)}=${branch}`,
                                     '--label',
                                     `${sandboxWorkspaceModeLabel(effectiveConfig)}=${target.workspace.mode}`,
+                                    '-e',
+                                    'AGENT_INFRA_SANDBOX=1',
                                     ...(target.workspace.mode === 'task-bound'
                                         ? [
                                             '--label',
@@ -1163,6 +1178,7 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
                                     ...tmpfsArgs,
                                     ...tmpfsSeedPlan.flatMap(({ volumeArgs }) => volumeArgs),
                                     ...liveMountVolumes,
+                                    ...hostStateMountVolumes,
                                     ...envFile.dockerArgs,
                                     ...tzFlags,
                                     '-w',

package/dist/lib/sandbox/commands/enter.js

@@ -8,15 +8,16 @@ import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.js';
 import { redactCommandError } from '../redaction.js';
 import { runInteractiveWithClipboardBridge } from '../clipboard/bridge.js';
 import { detectHostTimezone } from '../host-timezone.js';
-import { fetchSandboxRows, selectSandboxContainer, } from './list-running.js';
-import { resolveSandboxReentryContext, resolveSandboxTarget } from '../workspace-identity.js';
+import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer, } from './list-running.js';
+import { resolveSandboxTarget } from '../workspace-identity.js';
 const USAGE = `Usage: ai sandbox exec [--recreate] <branch | TASK-id | N> [cmd...]
 
 N references an active task short id from
 .agents/workspace/active/.short-ids.json. They resolve only via that
 registry — they do not reference a container's row position in
-'ai sandbox ls' output. --recreate is a host recovery flag only before the
-target; the same token after the target is passed to the container command.`;
+'ai sandbox ls' output. --recreate rebuilds the matched container while
+preserving its task or branch identity. The same token after the target is
+passed to the container command.`;
 const TMUX_ENTRY_PATH = '/usr/local/bin/sandbox-tmux-entry';
 // Terminal-detection variables that interactive TUIs (e.g. claude-code)
 // inspect to enable progressive enhancements such as the kitty keyboard
@@ -78,41 +79,54 @@ export async function enter(args) {
     const config = loadConfig();
     const engine = detectEngine(config);
     const parsed = parseEnterArgs(args);
-    const target = resolveSandboxTarget(parsed.target, config.repoRoot);
-    const branch = target.branch;
-    assertValidBranchName(branch);
+    const fullTaskId = /^TASK-\d{8}-\d{6}$/.test(parsed.target);
+    const target = fullTaskId ? null : resolveSandboxTarget(parsed.target, config.repoRoot);
+    const branch = target?.branch ?? '';
+    if (branch)
+        assertValidBranchName(branch);
     const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config), {
         mode: sandboxWorkspaceModeLabel(config),
         taskId: sandboxTaskIdLabel(config)
     });
-    const found = selectSandboxContainer([...running, ...nonRunning], containerNameCandidates(config, branch));
-    if (!found) {
-        throw new Error(`No sandbox found for branch '${branch}'. Run 'ai sandbox create ${branch}' to create one.`);
+    const rows = [...running, ...nonRunning];
+    const found = fullTaskId
+        ? rows.find((row) => row.taskId === parsed.target)
+        : rows.find((row) => row.branch === branch)
+            ?? selectSandboxContainer(rows, containerNameCandidates(config, branch));
+    if (!found)
+        throw new Error(`No sandbox found for '${parsed.target}'.`);
+    const sandboxBranch = found.branch || branch;
+    if (sandboxBranch)
+        assertValidBranchName(sandboxBranch);
+    if (target?.workspace.mode === 'task-bound' && found.taskId !== target.workspace.taskId) {
+        throw new Error(`Sandbox task mismatch for short id '${parsed.target}'.`);
     }
-    const containerWorkspace = found.workspaceMode === 'task-bound' && found.taskId
+    const workspace = found.workspaceMode === 'task-bound' && found.taskId
         ? { mode: 'task-bound', taskId: found.taskId }
-        : found.workspaceMode === 'branch-only'
-            ? { mode: 'branch-only' }
-            : { mode: 'legacy-invalid' };
-    const reentry = resolveSandboxReentryContext({
-        target,
-        containerWorkspace,
-        repoRoot: config.repoRoot
-    });
-    const ready = await ensureSandboxReady({
-        config,
-        engine,
-        branch,
-        workspace: reentry.workspace,
-        reentry: reentry.reentry,
-        row: found,
-        allowRecreate: parsed.recreate,
-        recreate: async () => {
-            const { create } = await import('./create.js');
-            await create([target.requestedRef, '--no-refresh'], { runProjectInitCommand: false });
-        }
-    });
-    const container = ready.container;
+        : { mode: 'branch-only' };
+    let container = found.name;
+    if (parsed.recreate) {
+        const ready = await ensureSandboxReady({
+            config,
+            engine,
+            branch: sandboxBranch,
+            workspace,
+            row: found,
+            allowRecreate: true,
+            forceRecreate: true,
+            recreate: async () => {
+                const { create } = await import('./create.js');
+                await create([sandboxBranch, '--no-refresh'], {
+                    runProjectInitCommand: false,
+                    workspace
+                });
+            }
+        });
+        container = ready.container;
+    }
+    else if (!found.running) {
+        startSandboxContainer(engine, found.name);
+    }
     const cmd = parsed.command;
     const capabilityPlan = createSandboxCapabilityPlan(config);
     const enterHookResults = await runSandboxHooks({

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

@@ -1,5 +1,4 @@
 import fs from 'node:fs';
-import { hasTaskBoundMarker } from '../../internal/task-operation-registry.js';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { SANDBOX_CONTROL_ADMISSION_WINDOW_MS, SANDBOX_CONTROL_MAX_BYTES, SANDBOX_CONTROL_STATUS_STALE_MS, isSandboxControlFamily } from './protocol.js';
@@ -8,6 +7,9 @@ import { readSandboxControlPayload, readSandboxControlStatus } from './state.js'
 import { accessSandboxTaskView, taskViewFromStatus } from './task-view.js';
 import { readSandboxControlIdentitySentinel } from './identity-sentinel.js';
 import { configuredShortIdLength, resolveShortIdReadOnly } from '../../task/short-id.js';
+import { hasTaskBoundMarker, isSandbox } from '../environment.js';
+import { loadConfig } from '../config.js';
+import { recoverSandboxControlFromHost } from './host-recovery.js';
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
 const SANDBOX_TASK_FINALIZATION_RECOVERY_BUDGET_MS = 5 * 60_000;
 export class SandboxControlClientError extends Error {
@@ -98,7 +100,7 @@ function parseResponse(raw, id, accepted = false) {
     }
     return response;
 }
-function readPublishedResponse(raw, id, channelDir, accepted = false) {
+function readPublishedResponse(raw, id, channelDir, accepted, generation) {
     const response = parseResponse(raw, id, accepted);
     if (response.outputState !== 'available')
         return response;
@@ -112,6 +114,7 @@ function readPublishedResponse(raw, id, channelDir, accepted = false) {
     }
     if (!response.payload || response.payload.version !== payload.version
         || response.payload.id !== payload.id || response.payload.generation !== payload.generation
+        || payload.generation !== generation
         || response.payload.stdoutBytes !== payload.stdoutBytes || response.payload.stderrBytes !== payload.stderrBytes
         || response.payload.stdoutSha256 !== payload.stdoutSha256 || response.payload.stderrSha256 !== payload.stderrSha256) {
         clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker payload reference is invalid', false, true, id);
@@ -216,7 +219,7 @@ function exchangeSandboxControl(request, params) {
             try {
                 // The request-specific terminal proves the broker claimed the request; preserve recovery evidence if marker cleanup won the race.
                 accepted = true;
-                response = readPublishedResponse(raw, request.id, channelDir, accepted);
+                response = readPublishedResponse(raw, request.id, channelDir, accepted, request.generation);
                 malformedResponseRaw = null;
             }
             catch (error) {
@@ -264,7 +267,40 @@ export function recoverSandboxControl(requestId, params = {}) {
     if (!/^[a-f0-9-]{16,64}$/u.test(requestId)) {
         clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'request id is invalid', false, true);
     }
-    const channelDir = params.channelDir ?? process.env.AGENT_INFRA_CONTROL_DIR ?? '/run/agent-infra/control';
+    try {
+        if (!isSandbox()) {
+            const config = loadConfig();
+            const response = recoverSandboxControlFromHost(requestId, {
+                managedRoot: path.join(config.controlBase, config.project),
+                timeoutMs: params.timeoutMs
+            });
+            if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
+                clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'recovery evidence is unavailable; inspect domain state before retrying', false, true, requestId);
+            }
+            return response;
+        }
+        const channelDir = process.env.AGENT_INFRA_CONTROL_DIR;
+        const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
+        const identity = readSandboxControlIdentitySentinel(statusDir);
+        return recoverSandboxControlFromChannel(requestId, {
+            channelDir, generation: identity.generation, timeoutMs: params.timeoutMs
+        });
+    }
+    catch (error) {
+        if (error instanceof SandboxControlClientError)
+            throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        const code = /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'SANDBOX_CONTROL_RECOVERY_INVALID';
+        clientError(code, 'sandbox control recovery evidence is invalid or unavailable', false, true, requestId);
+    }
+}
+// Low-level channel reader for control integration tests and internal callers
+// that already hold a manifest-bound channel path.
+export function recoverSandboxControlFromChannel(requestId, params) {
+    if (!/^[a-f0-9-]{16,64}$/u.test(requestId)) {
+        clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'request id is invalid', false, true);
+    }
+    const { channelDir } = params;
     const responsePath = path.join(channelDir, 'responses', `${requestId}.json`);
     const deadline = Date.now() + (params.timeoutMs ?? 30_000);
     let accepted = false;
@@ -287,7 +323,7 @@ export function recoverSandboxControl(requestId, params = {}) {
             try {
                 // The request-specific terminal proves the broker claimed the request; preserve recovery evidence if marker cleanup won the race.
                 accepted = true;
-                response = readPublishedResponse(raw, requestId, channelDir, accepted);
+                response = readPublishedResponse(raw, requestId, channelDir, accepted, params.generation);
                 malformedResponseRaw = null;
             }
             catch (error) {
@@ -338,7 +374,7 @@ export function requestSandboxControl(params) {
     const auth = authority(params);
     const issuedAt = Date.now();
     const request = {
-        version: 3, id: randomUUID(), ...auth, issuedAt,
+        version: 4, id: randomUUID(), ...auth, issuedAt,
         expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
         family: params.family, args: params.args,
         controllerProcess: null,
@@ -353,9 +389,8 @@ export function requestSandboxTaskFinalization(params) {
     const auth = authority(params);
     const issuedAt = Date.now();
     const id = randomUUID();
-    const handoffSha256 = (params.prepareHandoff ?? (() => '0'.repeat(64)))({ generation: auth.generation, requestId: id });
     const request = {
-        version: 3,
+        version: 4,
         id,
         ...auth,
         issuedAt,
@@ -363,7 +398,6 @@ export function requestSandboxTaskFinalization(params) {
         family: 'task-finalization',
         operation: 'complete',
         agent,
-        handoffSha256,
         args: [],
         controllerProcess: null,
         controllerProof: null
@@ -391,7 +425,7 @@ export function recoverAcceptedTaskFinalization(requestId, params, recover = rec
         if (timeoutMs <= 0)
             break;
         try {
-            const response = recover(requestId, { channelDir: params.channelDir, timeoutMs });
+            const response = recover(requestId, { timeoutMs });
             if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
                 continue;
             return response;
@@ -504,7 +538,7 @@ function requestCodexController(params) {
     const auth = authority(params);
     const issuedAt = Date.now();
     const request = {
-        version: 3,
+        version: 4,
         id: randomUUID(),
         ...auth,
         issuedAt,
@@ -551,7 +585,7 @@ export function requestSandboxTaskCreate(params) {
     const auth = authority(params);
     const issuedAt = Date.now();
     const request = {
-        version: 3, id: randomUUID(), ...auth, issuedAt,
+        version: 4, id: randomUUID(), ...auth, issuedAt,
         expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
         family: 'task-create', candidate: params.candidate,
         controllerProcess: null,

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

@@ -2,7 +2,6 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
 import { getProcessStartTime } from '../../server/process-state.js';
 import { createTask, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../../task/create-service.js';
 import { applyTaskFinalization } from '../../task/finalization.js';
@@ -15,10 +14,6 @@ import { createSandboxExecutorExecutionContext, dispatchTaskControlOperation, pa
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest } from './lifecycle.js';
 import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.js';
 import { closeCodexControllerRegistration, CodexControllerRegistrationError, openCodexControllerRegistration, resolveCodexControllerBinding } from './controller-registration.js';
-import { shareBranchDir } from '../constants.js';
-function handoffDirectory(manifest) {
-    return shareBranchDir({ shareBase: path.join(homedir(), '.agent-infra', 'share', manifest.project) }, manifest.branch);
-}
 function sameBrokerOwner(left, right) {
     return left.version === right.version
         && left.pid === right.pid
@@ -233,7 +228,7 @@ function finalizationResult(result) {
 async function executeRequestInner(manifest, manifestPath, request, options = {}) {
     if (request.family === 'task-create') {
         try {
-            const result = await createTask(request.candidate, { repoRoot: manifest.repoRoot });
+            const result = await (options.createTask ?? createTask)(request.candidate, { repoRoot: manifest.repoRoot });
             return taskCreateExecutionResult(projectTaskCreateResult(result, {
                 requestId: request.id,
                 accepted: true,
@@ -304,7 +299,7 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
         const parsed = parseTaskControlOperation('task-finalization', [manifest.taskId, 'complete', '--agent', request.agent]);
         if (parsed.family !== 'task-finalization')
             throw new Error('SANDBOX_CONTROL_FINALIZATION_OPERATION_INVALID');
-        const operation = { ...parsed, request: { ...parsed.request, handoffSha256: request.handoffSha256 } };
+        const operation = parsed;
         const result = dispatchTaskControlOperation(createSandboxExecutorExecutionContext({
             repoRoot: manifest.repoRoot,
             worktreeRoot: manifest.worktreeRoot,
@@ -312,8 +307,7 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             taskId: manifest.taskId,
             generation: manifest.generation,
             manifestPath,
-            requestId: request.id,
-            handoffDirectory: handoffDirectory(manifest)
+            requestId: request.id
         }), operation);
         return finalizationResult(await result);
     }
@@ -334,8 +328,7 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
         taskId: manifest.taskId,
         generation: manifest.generation,
         manifestPath,
-        requestId: request.id,
-        handoffDirectory: handoffDirectory(manifest)
+        requestId: request.id
     });
     const format = (value) => {
         const result = value;