@fitlab-ai/agent-infra 0.11.11 → 0.11.13

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

@@ -18,47 +18,18 @@ 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 { readCodexControllerRegistration } from './controller-registration.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 === 'codex-controller')
-        return request.command;
+    if (request.family === 'agent-client')
+        return request.operation;
     if (request.family !== 'task-lifecycle')
         return null;
     try {
@@ -217,51 +188,12 @@ function taskCreateDomainEvidence(manifest, output) {
         return { consistent: false };
     }
 }
-function controllerDomainEvidence(manifest, manifestPath, request, output) {
-    if (!output || output.error !== null || typeof output.status !== 'string')
-        return { consistent: false };
-    try {
-        const registration = readCodexControllerRegistration(manifestPath);
-        if (request.family !== 'codex-controller')
-            return { consistent: false };
-        if (request.command === 'open') {
-            const lease = output.lease && typeof output.lease === 'object' && !Array.isArray(output.lease)
-                ? output.lease : null;
-            return {
-                consistent: output.status === 'opened' && output.changed === true
-                    && lease?.taskId === registration.taskId
-                    && lease.controlGeneration === registration.controlGeneration
-                    && lease.controllerInstanceDigest === registration.controllerInstanceDigest
-                    && registration.taskId === manifest.taskId
-                    && registration.controlGeneration === manifest.generation
-            };
-        }
-        if (request.command === 'verify') {
-            const binding = output.binding && typeof output.binding === 'object' && !Array.isArray(output.binding)
-                ? output.binding : null;
-            return {
-                consistent: output.status === 'verified' && output.changed === false
-                    && binding?.taskId === registration.taskId
-                    && binding.controlGeneration === registration.controlGeneration
-                    && binding.controllerInstanceDigest === registration.controllerInstanceDigest
-            };
-        }
-        return { consistent: false };
-    }
-    catch (error) {
-        return { consistent: request.family === 'codex-controller' && request.command === 'close'
-                && error.code === 'CODEX_SANDBOX_CONTROLLER_REGISTRATION_MISSING'
-                && output?.status === 'closed' && typeof output.changed === 'boolean' };
-    }
-}
 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 !== 'codex-controller') {
+    if (!taskRef && operation.family !== 'task-create' && operation.family !== 'agent-client') {
         return { domain: null };
     }
     if (operation.family === 'task-lifecycle') {
@@ -289,8 +221,13 @@ async function readRecoveryDomain(manifest, manifestPath, request, operation, te
     if (operation.family === 'task-create') {
         return { domain: taskCreateDomainEvidence(manifest, output) };
     }
-    if (operation.family === 'codex-controller') {
-        return { domain: controllerDomainEvidence(manifest, manifestPath, request, output) };
+    if (operation.family === 'agent-client' && request.family === 'agent-client') {
+        return { domain: recoverAgentClientOperation({
+                request,
+                manifest,
+                manifestPath,
+                stdout: payloadOutput
+            }) };
     }
     return { domain: null };
 }
@@ -509,6 +446,8 @@ async function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
                 request = validateSandboxControlRequest(rawRequest, manifest, {
                     now: typeof rawRequest.issuedAt === 'number' ? rawRequest.issuedAt : undefined
                 });
+                if (request.family === 'agent-client')
+                    validateAgentClientOperation(request, manifest);
             }
             catch {
                 // Missing or malformed request evidence remains fail-closed below.
@@ -760,6 +699,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',
@@ -866,11 +807,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())
@@ -948,228 +884,232 @@ 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);
-                    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);
+                        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),
-                            ...resultAuditFields(execution.result),
+                            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
+                            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;
-                    }
-                    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);
@@ -1191,11 +1131,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/mounts.js

@@ -38,11 +38,19 @@ export function sandboxCoreBindMounts(config, branch, overrides) {
         ...workspaceMounts,
     ];
     if (taskBound) {
+        const taskMountPath = path.posix.join('/workspace/.agents/workspace/active', overrides.taskId);
         mounts.push({
             hostPaths: taskSources,
-            containerPath: path.posix.join('/workspace/.agents/workspace/active', overrides.taskId),
+            containerPath: taskMountPath,
             readOnly: false
         });
+        if (overrides.completedTaskSource) {
+            mounts.push({
+                hostPaths: [overrides.completedTaskSource],
+                containerPath: path.posix.join('/workspace/.agents/workspace/completed', overrides.taskId),
+                readOnly: false
+            });
+        }
     }
     mounts.push({
         hostPaths: [shareCommonDir(config)],