@fitlab-ai/agent-infra 0.11.12 → 0.11.14

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

@@ -18,49 +18,15 @@ import { inspectSandboxControlContainer } from './container-identity.js';
 import { acquireSandboxControlBrokerStartup, garbageCollectSandboxControlRoot, isSandboxControlRootQuiescing, readSandboxControlManifest } from './lifecycle.js';
 import { nextSandboxControlBackoff } from './timing.js';
 import { readTaskFinalizationReceipt } from '../../task/finalization.js';
-import { recoverAgentClientOperation, validateAgentClientOperation } from './agent-operation.js';
 import { validateSandboxControlIdentity } from './identity-sentinel.js';
-import { mergeSandboxTaskView, taskViewAfterFinalization, taskViewForManifest } from './task-view.js';
+import { mergeSandboxTaskView, taskViewForManifest } from './task-view.js';
 import { taskCreateOutputUnavailableResult } from '../../task/create-service.js';
-async function taskViewForFinalizationResult(manifest, request, result) {
-    if (request.family !== 'task-finalization' || result?.exitCode !== 0 || !manifest.taskId)
-        return null;
-    let receipt = null;
-    for (let attempt = 0; attempt < 100 && !receipt; attempt += 1) {
-        try {
-            receipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId);
-        }
-        catch {
-            // A missing or temporarily moving task directory is retried before publishing completion.
-        }
-        if (!receipt)
-            await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    const finalized = taskViewAfterFinalization({
-        taskId: manifest.taskId,
-        generation: manifest.generation,
-        requestId: request.id,
-        receipt
-    });
-    if (finalized.state === 'unknown')
-        return finalized;
-    const canonical = taskViewForManifest({ ...manifest, receipt });
-    return canonical.state === 'current' && canonical.observedSource === 'completed'
-        ? canonical
-        : finalized;
-}
 function appendBrokerAudit(manifest, event, fields = {}) {
     appendDiagnosticAudit(manifest, event, { source: 'broker', ...fields });
 }
 function operationKey(request) {
-    if (request.family === 'task-finalization')
-        return request.operation;
     if (request.family === 'task-create')
         return 'create';
-    if (request.family === 'agent-client')
-        return request.operation;
-    if (request.family !== 'task-lifecycle')
-        return null;
     try {
         const operation = parseTaskControlOperation(request.family, request.args);
         return operation.family === 'task-lifecycle' ? operation.request.intent : null;
@@ -220,11 +186,9 @@ function taskCreateDomainEvidence(manifest, output) {
 async function readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payloadOutput) {
     if (!operation)
         return { domain: null };
-    const taskRef = request.family === 'task-finalization'
-        ? manifest.taskId
-        : 'args' in request ? request.args[0] ?? null : manifest.taskId;
+    const taskRef = 'args' in request ? request.args[0] ?? null : manifest.taskId;
     const output = parseControlOutput(payloadOutput);
-    if (!taskRef && operation.family !== 'task-create' && operation.family !== 'agent-client') {
+    if (!taskRef && operation.family !== 'task-create') {
         return { domain: null };
     }
     if (operation.family === 'task-lifecycle') {
@@ -252,14 +216,6 @@ async function readRecoveryDomain(manifest, manifestPath, request, operation, te
     if (operation.family === 'task-create') {
         return { domain: taskCreateDomainEvidence(manifest, output) };
     }
-    if (operation.family === 'agent-client' && request.family === 'agent-client') {
-        return { domain: recoverAgentClientOperation({
-                request,
-                manifest,
-                manifestPath,
-                stdout: payloadOutput
-            }) };
-    }
     return { domain: null };
 }
 function readCommittedCriticalPhases(manifest, requestId) {
@@ -474,11 +430,7 @@ async function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
             let terminalReconciled = false;
             try {
                 const rawRequest = JSON.parse(fs.readFileSync(path.join(processingDirectory, 'request.json'), 'utf8'));
-                request = validateSandboxControlRequest(rawRequest, manifest, {
-                    now: typeof rawRequest.issuedAt === 'number' ? rawRequest.issuedAt : undefined
-                });
-                if (request.family === 'agent-client')
-                    validateAgentClientOperation(request, manifest);
+                request = validateSandboxControlRequest(rawRequest, manifest);
             }
             catch {
                 // Missing or malformed request evidence remains fail-closed below.
@@ -730,6 +682,8 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
     try {
         if (!brokerOwns())
             return;
+        if (isSandboxControlRootQuiescing(root))
+            return;
         if (taskView.state === 'current' && taskView.observedSource === 'completed') {
             // Recheck durable re-entry evidence before publishing a trusted startup view.
             const unverified = { ...taskView, state: 'unknown',
@@ -836,11 +790,6 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                 settledExecution = active;
                 active = null;
             }
-            const finalizationView = settledExecution
-                ? await taskViewForFinalizationResult(manifest, settledExecution.request, settledExecution.result)
-                : null;
-            if (finalizationView)
-                taskView = finalizationView;
             let reasonCode = null;
             try {
                 if (!brokerOwns())
@@ -918,224 +867,230 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                 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))
-                    continue;
-                const id = name.slice(0, -5);
-                const source = path.join(requestsDir, name);
-                let claimed = null;
-                let validatedRequest = null;
-                let prepared = null;
-                try {
-                    if (!brokerOwns()) {
-                        retiring = true;
-                        break;
-                    }
-                    claimed = claimRequest(manifest, source, id);
-                    appendBrokerAudit(manifest, 'request-claimed', {
-                        requestId: id,
-                        requestSourcePath: source,
-                        requestClaimedPath: claimed,
-                        requestProcessingDir: path.dirname(claimed)
-                    });
-                    if (!brokerOwns()) {
-                        retiring = true;
-                        break;
-                    }
-                    consumeRequest(consumedDir, id);
-                    if (!brokerOwns()) {
-                        retiring = true;
-                        break;
-                    }
-                    if (reasonCode)
-                        throw new Error(reasonCode);
-                    if (active)
-                        throw new Error('SANDBOX_CONTROL_BUSY');
-                    const request = validateSandboxControlRequest(JSON.parse(fs.readFileSync(claimed, 'utf8')), manifest);
-                    if (request.family === 'agent-client')
-                        validateAgentClientOperation(request, manifest);
-                    validatedRequest = request;
-                    criticalRequestPhase(manifest, request, 'validated', 'in-progress');
-                    appendBrokerAudit(manifest, 'request-validated', {
-                        ...requestAuditFields(manifest, request),
-                        requestPath: claimed
-                    });
-                    if (bindingCheck(manifest))
-                        throw new Error('SANDBOX_WORKTREE_BINDING_LOST');
-                    if (readActiveLease(manifest))
-                        throw new Error('SANDBOX_CONTROL_HANDOFF_ACTIVE');
-                    criticalRequestPhase(manifest, request, 'gated', 'in-progress');
-                    appendBrokerAudit(manifest, 'request-gates-passed', {
-                        ...requestAuditFields(manifest, request),
-                        requestPath: claimed,
-                        bindingChecked: true,
-                        handoffLeaseChecked: true
-                    });
-                    criticalRequestPhase(manifest, request, 'reserved', 'in-progress');
-                    writeSandboxControlReservation(manifest, request.id, sandboxControlGenerationUsage(manifest));
-                    appendBrokerAudit(manifest, 'executor-reservation-written', {
-                        ...requestAuditFields(manifest, request),
-                        requestPath: claimed,
-                        executionPath: executionPath(manifest, request.id)
-                    });
-                    appendBrokerAudit(manifest, 'executor-prepare-start', {
-                        ...requestAuditFields(manifest, request),
-                        requestPath: claimed,
-                        executorCwd: manifest.repoRoot,
-                        executorEntry: options.internalCliPath ?? process.argv[1] ?? null
-                    });
-                    prepared = await prepareExecution({
-                        manifest, manifestPath, request, requestPath: claimed,
-                        internalCliPath: options.internalCliPath ?? process.argv[1]
-                    });
-                    const preparedExecution = prepared;
-                    if (!preparedExecution)
-                        throw new Error('SANDBOX_CONTROL_EXECUTION_PREPARE_INVALID');
-                    criticalRequestPhase(manifest, request, 'prepared', 'in-progress', `${preparedExecution.execution.child.pid}`);
-                    appendBrokerAudit(manifest, 'executor-prepared', {
-                        ...requestAuditFields(manifest, request),
-                        requestPath: claimed,
-                        executorCwd: manifest.repoRoot,
-                        childPid: preparedExecution.execution.child.pid,
-                        childStartTime: preparedExecution.execution.child.startTime,
-                        childProcessGroupId: preparedExecution.execution.child.processGroupId,
-                        executionPath: executionPath(manifest, request.id)
-                    });
-                    const execution = {
-                        request, prepared: preparedExecution, result: null,
-                        resultEvidenceWritten: false, failure: null, settled: false
-                    };
-                    active = execution;
-                    preparedExecution.completion.then((result) => {
-                        execution.result = sanitizeSandboxControlResult(manifest, result);
-                        appendBrokerAudit(manifest, 'executor-completed', {
+            const quiescing = isSandboxControlRootQuiescing(root);
+            if (quiescing && !active)
+                break;
+            if (!quiescing)
+                for (const name of fs.readdirSync(requestsDir).sort()) {
+                    if (!/^[a-f0-9-]{16,64}\.json$/.test(name))
+                        continue;
+                    const id = name.slice(0, -5);
+                    const source = path.join(requestsDir, name);
+                    let claimed = null;
+                    let validatedRequest = null;
+                    let prepared = null;
+                    try {
+                        if (isSandboxControlRootQuiescing(root)) {
+                            retiring = true;
+                            break;
+                        }
+                        if (!brokerOwns()) {
+                            retiring = true;
+                            break;
+                        }
+                        claimed = claimRequest(manifest, source, id);
+                        appendBrokerAudit(manifest, 'request-claimed', {
+                            requestId: id,
+                            requestSourcePath: source,
+                            requestClaimedPath: claimed,
+                            requestProcessingDir: path.dirname(claimed)
+                        });
+                        if (!brokerOwns()) {
+                            retiring = true;
+                            break;
+                        }
+                        consumeRequest(consumedDir, id);
+                        if (!brokerOwns()) {
+                            retiring = true;
+                            break;
+                        }
+                        if (reasonCode)
+                            throw new Error(reasonCode);
+                        if (active)
+                            throw new Error('SANDBOX_CONTROL_BUSY');
+                        const request = validateSandboxControlRequest(JSON.parse(fs.readFileSync(claimed, 'utf8')), manifest);
+                        validatedRequest = request;
+                        criticalRequestPhase(manifest, request, 'validated', 'in-progress');
+                        appendBrokerAudit(manifest, 'request-validated', {
+                            ...requestAuditFields(manifest, request),
+                            requestPath: claimed
+                        });
+                        if (bindingCheck(manifest))
+                            throw new Error('SANDBOX_WORKTREE_BINDING_LOST');
+                        if (readActiveLease(manifest))
+                            throw new Error('SANDBOX_CONTROL_HANDOFF_ACTIVE');
+                        criticalRequestPhase(manifest, request, 'gated', 'in-progress');
+                        appendBrokerAudit(manifest, 'request-gates-passed', {
+                            ...requestAuditFields(manifest, request),
+                            requestPath: claimed,
+                            bindingChecked: true,
+                            handoffLeaseChecked: true
+                        });
+                        criticalRequestPhase(manifest, request, 'reserved', 'in-progress');
+                        writeSandboxControlReservation(manifest, request.id, sandboxControlGenerationUsage(manifest));
+                        appendBrokerAudit(manifest, 'executor-reservation-written', {
+                            ...requestAuditFields(manifest, request),
+                            requestPath: claimed,
+                            executionPath: executionPath(manifest, request.id)
+                        });
+                        appendBrokerAudit(manifest, 'executor-prepare-start', {
+                            ...requestAuditFields(manifest, request),
+                            requestPath: claimed,
+                            executorCwd: manifest.repoRoot,
+                            executorEntry: options.internalCliPath ?? process.argv[1] ?? null
+                        });
+                        prepared = await prepareExecution({
+                            manifest, manifestPath, request, requestPath: claimed,
+                            internalCliPath: options.internalCliPath ?? process.argv[1]
+                        });
+                        const preparedExecution = prepared;
+                        if (!preparedExecution)
+                            throw new Error('SANDBOX_CONTROL_EXECUTION_PREPARE_INVALID');
+                        criticalRequestPhase(manifest, request, 'prepared', 'in-progress', `${preparedExecution.execution.child.pid}`);
+                        appendBrokerAudit(manifest, 'executor-prepared', {
                             ...requestAuditFields(manifest, request),
-                            ...resultAuditFields(execution.result),
+                            requestPath: claimed,
+                            executorCwd: manifest.repoRoot,
                             childPid: preparedExecution.execution.child.pid,
-                            childStartTime: preparedExecution.execution.child.startTime
+                            childStartTime: preparedExecution.execution.child.startTime,
+                            childProcessGroupId: preparedExecution.execution.child.processGroupId,
+                            executionPath: executionPath(manifest, request.id)
                         });
-                        try {
-                            writeSandboxControlResultEvidence(manifest, request.id, execution.result);
-                            execution.resultEvidenceWritten = true;
-                            execution.settled = true;
-                            appendBrokerAudit(manifest, 'executor-result-evidence-written', {
+                        const execution = {
+                            request, prepared: preparedExecution, result: null,
+                            resultEvidenceWritten: false, failure: null, settled: false
+                        };
+                        active = execution;
+                        preparedExecution.completion.then((result) => {
+                            execution.result = sanitizeSandboxControlResult(manifest, result);
+                            appendBrokerAudit(manifest, 'executor-completed', {
                                 ...requestAuditFields(manifest, request),
-                                resultPath: path.join(manifest.processingDir, request.id, 'result.json'),
-                                ...resultAuditFields(execution.result)
+                                ...resultAuditFields(execution.result),
+                                childPid: preparedExecution.execution.child.pid,
+                                childStartTime: preparedExecution.execution.child.startTime
                             });
-                        }
-                        catch (error) {
+                            try {
+                                writeSandboxControlResultEvidence(manifest, request.id, execution.result);
+                                execution.resultEvidenceWritten = true;
+                                execution.settled = true;
+                                appendBrokerAudit(manifest, 'executor-result-evidence-written', {
+                                    ...requestAuditFields(manifest, request),
+                                    resultPath: path.join(manifest.processingDir, request.id, 'result.json'),
+                                    ...resultAuditFields(execution.result)
+                                });
+                            }
+                            catch (error) {
+                                execution.failure = error;
+                                appendBrokerAudit(manifest, 'executor-result-evidence-failed', {
+                                    ...requestAuditFields(manifest, request),
+                                    errorType: error instanceof Error ? error.name : typeof error,
+                                });
+                            }
+                        }, (error) => {
                             execution.failure = error;
-                            appendBrokerAudit(manifest, 'executor-result-evidence-failed', {
+                            execution.settled = true;
+                            appendBrokerAudit(manifest, 'executor-failed', {
                                 ...requestAuditFields(manifest, request),
+                                childPid: preparedExecution.execution.child.pid,
+                                childStartTime: preparedExecution.execution.child.startTime,
                                 errorType: error instanceof Error ? error.name : typeof error,
                             });
-                        }
-                    }, (error) => {
-                        execution.failure = error;
-                        execution.settled = true;
-                        appendBrokerAudit(manifest, 'executor-failed', {
-                            ...requestAuditFields(manifest, request),
-                            childPid: preparedExecution.execution.child.pid,
-                            childStartTime: preparedExecution.execution.child.startTime,
-                            errorType: error instanceof Error ? error.name : typeof error,
                         });
-                    });
-                    if (!brokerOwns()) {
-                        prepared.terminate(false);
-                        active = null;
-                        retiring = true;
-                        continue;
-                    }
-                    criticalRequestPhase(manifest, request, 'accepted-authorized', 'in-progress');
-                    writeAcceptedResponse(manifest, {
-                        version: 2, id, phase: 'accepted', exitCode: null, stdout: '', stderr: '', error: null
-                    });
-                    writeSandboxControlTransition(manifest, { requestId: request.id, phase: 'accepted-committed' });
-                    appendBrokerAudit(manifest, 'request-accepted', {
-                        ...requestAuditFields(manifest, request),
-                        acceptedPath: acceptedResponsePath(manifest, id),
-                        executionPhase: 'prepared'
-                    });
-                    if (!brokerOwns()) {
-                        prepared.terminate(false);
-                        active = null;
-                        retiring = true;
-                        break;
-                    }
-                    try {
-                        criticalRequestPhase(manifest, request, 'start-authorized', 'in-progress', `${prepared.execution.child.pid}`);
-                        appendBrokerAudit(manifest, 'executor-start', {
-                            ...requestAuditFields(manifest, request),
-                            childPid: prepared.execution.child.pid,
-                            childStartTime: prepared.execution.child.startTime,
-                            executionPath: executionPath(manifest, request.id)
+                        if (!brokerOwns()) {
+                            prepared.terminate(false);
+                            active = null;
+                            retiring = true;
+                            continue;
+                        }
+                        criticalRequestPhase(manifest, request, 'accepted-authorized', 'in-progress');
+                        writeAcceptedResponse(manifest, {
+                            version: 2, id, phase: 'accepted', exitCode: null, stdout: '', stderr: '', error: null
                         });
-                        prepared.start(brokerOwns);
-                    }
-                    catch (error) {
-                        appendBrokerAudit(manifest, 'executor-start-failed', {
+                        writeSandboxControlTransition(manifest, { requestId: request.id, phase: 'accepted-committed' });
+                        appendBrokerAudit(manifest, 'request-accepted', {
                             ...requestAuditFields(manifest, request),
-                            errorType: error instanceof Error ? error.name : typeof error,
+                            acceptedPath: acceptedResponsePath(manifest, id),
+                            executionPhase: 'prepared'
                         });
-                        const owned = brokerOwns();
-                        prepared.terminate(owned);
-                        if (!owned || !brokerOwns()) {
+                        if (!brokerOwns()) {
+                            prepared.terminate(false);
                             active = null;
                             retiring = true;
                             break;
                         }
-                        writeSandboxControlResponse(manifest, unknown(id));
-                        if (!brokerOwns()) {
+                        try {
+                            criticalRequestPhase(manifest, request, 'start-authorized', 'in-progress', `${prepared.execution.child.pid}`);
+                            appendBrokerAudit(manifest, 'executor-start', {
+                                ...requestAuditFields(manifest, request),
+                                childPid: prepared.execution.child.pid,
+                                childStartTime: prepared.execution.child.startTime,
+                                executionPath: executionPath(manifest, request.id)
+                            });
+                            prepared.start(brokerOwns);
+                        }
+                        catch (error) {
+                            appendBrokerAudit(manifest, 'executor-start-failed', {
+                                ...requestAuditFields(manifest, request),
+                                errorType: error instanceof Error ? error.name : typeof error,
+                            });
+                            const owned = brokerOwns();
+                            prepared.terminate(owned);
+                            if (!owned || !brokerOwns()) {
+                                active = null;
+                                retiring = true;
+                                break;
+                            }
+                            writeSandboxControlResponse(manifest, unknown(id));
+                            if (!brokerOwns()) {
+                                active = null;
+                                retiring = true;
+                                break;
+                            }
+                            removeAcceptedResponse(manifest, id);
+                            fs.rmSync(path.join(manifest.processingDir, id), { recursive: true, force: true });
+                            active = null;
+                            claimed = null;
+                            if (!brokerOwns()) {
+                                retiring = true;
+                                break;
+                            }
+                            appendBrokerAudit(manifest, 'executor-gate-failed', { requestId: id });
+                            continue;
+                        }
+                    }
+                    catch (error) {
+                        if (prepared) {
+                            try {
+                                prepared.terminate(brokerOwns());
+                            }
+                            catch { /* cleanup is best effort after a failed admission */ }
+                            prepared = null;
                             active = null;
+                        }
+                        if (!brokerOwns()) {
                             retiring = true;
                             break;
                         }
-                        removeAcceptedResponse(manifest, id);
-                        fs.rmSync(path.join(manifest.processingDir, id), { recursive: true, force: true });
-                        active = null;
-                        claimed = null;
+                        const detail = controlError(error);
+                        appendBrokerAudit(manifest, 'request-rejected', {
+                            requestId: id,
+                            requestFamily: validatedRequest?.family ?? null,
+                            sandboxTaskId: manifest.taskId,
+                            requestPath: claimed,
+                            errorCode: detail.code,
+                            errorRetryable: detail.retryable,
+                            errorType: error instanceof Error ? error.name : typeof error,
+                        });
+                        writeSandboxControlResponse(manifest, rejected(id, error));
                         if (!brokerOwns()) {
                             retiring = true;
                             break;
                         }
-                        appendBrokerAudit(manifest, 'executor-gate-failed', { requestId: id });
-                        continue;
-                    }
-                }
-                catch (error) {
-                    if (prepared) {
-                        try {
-                            prepared.terminate(brokerOwns());
-                        }
-                        catch { /* cleanup is best effort after a failed admission */ }
-                        prepared = null;
-                        active = null;
-                    }
-                    if (!brokerOwns()) {
-                        retiring = true;
-                        break;
-                    }
-                    const detail = controlError(error);
-                    appendBrokerAudit(manifest, 'request-rejected', {
-                        requestId: id,
-                        requestFamily: validatedRequest?.family ?? null,
-                        sandboxTaskId: manifest.taskId,
-                        requestPath: claimed,
-                        errorCode: detail.code,
-                        errorRetryable: detail.retryable,
-                        errorType: error instanceof Error ? error.name : typeof error,
-                    });
-                    writeSandboxControlResponse(manifest, rejected(id, error));
-                    if (!brokerOwns()) {
-                        retiring = true;
-                        break;
+                        removeAcceptedResponse(manifest, id);
+                        if (claimed)
+                            fs.rmSync(path.dirname(claimed), { recursive: true, force: true });
                     }
-                    removeAcceptedResponse(manifest, id);
-                    if (claimed)
-                        fs.rmSync(path.dirname(claimed), { recursive: true, force: true });
                 }
-            }
             if (retiring || !brokerOwns())
                 break;
             await delay(timing.controlTickMs);
@@ -1157,11 +1112,6 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                 }
             }
             if (owned && active.result && active.resultEvidenceWritten) {
-                const finalizationView = await taskViewForFinalizationResult(manifest, active.request, active.result);
-                if (finalizationView) {
-                    taskView = finalizationView;
-                    writeSandboxControlStatus(manifest, broker, 'healthy', null, null, Date.now(), taskView);
-                }
                 if (publishExecutionResult(manifest, active.request, active.result, brokerOwns)) {
                     if (brokerOwns()) {
                         removeAcceptedResponse(manifest, active.request.id);

package/dist/lib/sandbox/control/task-view.js

@@ -130,19 +130,6 @@ export function projectSandboxTaskView(input) {
         reasonCode: receipt ? 'SANDBOX_TASK_VIEW_SOURCE_UNCONFIRMED' : 'SANDBOX_TASK_VIEW_EVIDENCE_UNAVAILABLE'
     };
 }
-export function taskViewAfterFinalization(params) {
-    const receipt = receiptIdentity(params.receipt, params.generation, params.requestId);
-    if (!receipt) {
-        return {
-            state: 'unknown', taskId: params.taskId, observedSource: 'unknown', receipt: null,
-            reasonCode: 'SANDBOX_TASK_VIEW_RECEIPT_INVALID'
-        };
-    }
-    return {
-        state: 'finalized-stale', taskId: params.taskId, observedSource: 'active', receipt,
-        reasonCode: 'SANDBOX_TASK_VIEW_FINALIZED'
-    };
-}
 export function mergeSandboxTaskView(canonical, previous) {
     if (previous.state !== 'finalized-stale' && previous.state !== 'unknown')
         return canonical;

package/dist/lib/sandbox/environment.js

@@ -5,14 +5,13 @@ export const SANDBOX_CONTROL_STATUS_MOUNT = '/run/agent-infra/control-status';
 const TASK_MARKER_KEYS = [
     'AGENT_INFRA_SANDBOX',
     'AGENT_INFRA_TASK_ID',
-    'AGENT_INFRA_CONTROL_TOKEN',
     'AGENT_INFRA_CONTROL_GENERATION',
     'AGENT_INFRA_CONTROL_DIR',
+    'AGENT_INFRA_CONTROL_ROOT_DIR',
     'AGENT_INFRA_CONTROL_STATUS_DIR',
     'AGENT_INFRA_RUNTIME_DIR'
 ];
 const TASK_CONTROL_MARKER_KEYS = [
-    'AGENT_INFRA_CONTROL_TOKEN',
     'AGENT_INFRA_CONTROL_GENERATION',
     'AGENT_INFRA_CONTROL_DIR',
     'AGENT_INFRA_CONTROL_STATUS_DIR'
@@ -77,7 +76,6 @@ export function hasSandboxControlMarker(env = process.env) {
 export function resolveSandboxControlTransport(env = process.env, options = {}) {
     const markerState = sandboxTaskMarkerState(env);
     const hasAnyMarker = markerState !== 'none'
-        || Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING)
         || Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST);
     const fixedStatusDir = options.statusMountPath ?? SANDBOX_CONTROL_STATUS_MOUNT;
     const fixedStatusProbe = path.isAbsolute(fixedStatusDir)
@@ -98,6 +96,10 @@ export function resolveSandboxControlTransport(env = process.env, options = {})
     if (!hasCompleteConfig) {
         return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
     }
+    if (markerState === 'task-bound'
+        && (!env.AGENT_INFRA_CONTROL_ROOT_DIR || !path.isAbsolute(env.AGENT_INFRA_CONTROL_ROOT_DIR))) {
+        return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
+    }
     const configuredStatusDir = env.AGENT_INFRA_CONTROL_STATUS_DIR;
     const configuredStatusProbe = configuredStatusDir && path.isAbsolute(configuredStatusDir)
         ? nativeDirectoryProbe(configuredStatusDir) : 'absent';
@@ -108,7 +110,7 @@ export function resolveSandboxControlTransport(env = process.env, options = {})
         ? configuredStatusProbe === 'present' ? configuredStatusDir : null
         : fixedStatusMounted ? fixedStatusDir : null;
     const statusMounted = statusDir !== null;
-    if (env.AGENT_INFRA_EXECUTOR_MANIFEST || env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING) {
+    if (env.AGENT_INFRA_EXECUTOR_MANIFEST) {
         return { kind: 'fail-closed', reasonCode: 'TASK_CONTROL_TRANSPORT_INVALID' };
     }
     const taskBound = Boolean(env.AGENT_INFRA_TASK_ID);
@@ -124,9 +126,6 @@ export function resolveSandboxControlTransport(env = process.env, options = {})
                     ? 'SANDBOX_CONTROL_IDENTITY_MISSING'
                     : 'SANDBOX_CONTROL_IDENTITY_MALFORMED' };
         }
-        if (sentinel.generation !== env.AGENT_INFRA_CONTROL_GENERATION) {
-            return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_GENERATION_MISMATCH' };
-        }
         if (sentinel.controlRootId !== env.AGENT_INFRA_CONTROL_ROOT_ID) {
             return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_ROOT_ID_MISMATCH' };
         }
@@ -134,7 +133,7 @@ export function resolveSandboxControlTransport(env = process.env, options = {})
             && (sentinel.taskId !== env.AGENT_INFRA_TASK_ID || !runtime)) {
             return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH' };
         }
-        if (sentinel.mode === 'branch-only' && (taskBound || runtime)) {
+        if (sentinel.mode === 'branch-only' && (taskBound || runtime || Boolean(env.AGENT_INFRA_CONTROL_ROOT_DIR))) {
             return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH' };
         }
         return { kind: options.localWorkflow ? 'sandbox-local' : 'broker-client', reasonCode: null };