@fitlab-ai/agent-infra 0.11.12 → 0.11.13

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

@@ -1,6 +1,5 @@
 import { createHash } from 'node:crypto';
 import { validateTaskCreateCandidate } from '../../task/create.js';
-import { normalizeAgentToken } from '../../agent-clients/tokens.js';
 import { isAgentClientId } from '../../agent-clients/types.js';
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
 export const SANDBOX_CONTROL_MAX_LOGICAL_RECORDS = 1024;
@@ -11,7 +10,7 @@ export const SANDBOX_CONTROL_ADMISSION_WINDOW_MS = 2_000;
 export const SANDBOX_CONTROL_STATUS_INTERVAL_MS = 250;
 export const SANDBOX_CONTROL_STATUS_STALE_MS = 1_500;
 export const SANDBOX_CONTROL_FUTURE_SKEW_MS = 1_000;
-export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-finalization', 'task-create', 'agent-client'];
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-create', 'agent-client'];
 export const DEFAULT_SANDBOX_CONTROL_TIMING = Object.freeze({
     controlTickMs: 250,
     parkedBindingInitialMs: 1_000,
@@ -151,31 +150,21 @@ export function validateSandboxControlRequest(value, manifest, options = {}) {
         }
         return request;
     }
-    if (request.family === 'task-finalization') {
-        const expected = ['agent', 'args', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'operation', 'token', 'version'];
-        if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
-            || request.operation !== 'complete'
-            || !Array.isArray(request.args) || request.args.length !== 0
-            || typeof request.agent !== 'string' || normalizeAgentToken(request.agent) !== request.agent) {
-            fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-finalization request schema or authorization is invalid');
-        }
-        if (manifest.mode !== 'task-bound' || !manifest.taskId) {
-            fail('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot finalize tasks');
-        }
-        return request;
-    }
     const expected = ['args', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
     if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
         || !Array.isArray(request.args) || !request.args.every((arg) => typeof arg === 'string')) {
         fail('SANDBOX_CONTROL_REQUEST_INVALID', 'request schema or authorization is invalid');
     }
+    if (request.args[1] === 'complete') {
+        fail('SANDBOX_CONTROL_COMMAND_DENIED', 'complete must use task-finalization');
+    }
     if (manifest.mode !== 'task-bound' || !manifest.taskId) {
         fail('SANDBOX_CONTROL_BRANCH_ONLY', "branch-only sandboxes cannot coordinate tasks; return to the host and run 'ai sandbox start --recreate <task-ref-or-correct-branch>'");
     }
     return request;
 }
 export function bindSandboxControlTask(request, taskId) {
-    if (request.family === 'task-create' || request.family === 'agent-client' || request.family === 'task-finalization') {
+    if (request.family === 'task-create' || request.family === 'agent-client') {
         fail('SANDBOX_CONTROL_REQUEST_INVALID', `${request.family} requests do not bind a current task`);
     }
     if (request.args.length === 0)

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

@@ -20,41 +20,12 @@ 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')
@@ -220,9 +191,7 @@ 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') {
         return { domain: null };
@@ -730,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',
@@ -836,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())
@@ -918,224 +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);
-                    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);
+                        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),
-                            ...resultAuditFields(execution.result),
+                            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
+                            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 +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

@@ -44,6 +44,13 @@ export function sandboxCoreBindMounts(config, branch, overrides) {
             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)],