@fitlab-ai/agent-infra 0.11.2 → 0.11.4

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

@@ -1,5 +1,3 @@
-import { finalizationTerminalResponse } from './finalization-response.js';
-import { isDeepStrictEqual } from 'node:util';
 import { completedReentryView } from './completed-reentry.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -13,10 +11,6 @@ import { validateSandboxControlRequest } from './protocol.js';
 import { requestAuditFields, resultAuditFields, appendCriticalAudit, appendDiagnosticAudit, createSandboxControlAuditContext, writeSandboxControlTransition, readSandboxControlTransition } from './audit.js';
 import { parseTaskControlOperation } from '../../task/control-authority.js';
 import { parseControlOutput, classifySandboxControlRecovery, findSandboxControlRecoveryOperation, operationRecoveryBinding, SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES } from '../../task/control-recovery.js';
-import { readRun } from '../../task/orchestration.js';
-import { readLifecycleRecoveryDomainEvidence } from '../../task/lifecycle-recovery.js';
-import { captureRepositorySnapshot } from '../../task/workspace-snapshot.js';
-import { parseTypedTaskFrontmatter } from '../../task/frontmatter.js';
 import { readLifecycleJournalEvidence } from '../../task/lifecycle.js';
 import { resolveTaskRef } from '../../task/resolve-ref.js';
 import { loadShortIdByTaskId } from '../../task/short-id.js';
@@ -26,96 +20,34 @@ import { nextSandboxControlBackoff } from './timing.js';
 import { readTaskFinalizationReceipt } from '../../task/finalization.js';
 import { readCodexControllerRegistration } from './controller-registration.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';
-import { consumeLifecycleRecoveryAttestation, issueLifecycleRecoveryAttestation, recoverLifecycleRecoveryOperation } from '../../task/control-authority.js';
-import { createCodexCapabilityStore } from '../../agent-clients/adapters/codex-lifecycle/capability-store.js';
-import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.js';
-function consumeLifecycleAuthorityForResult(manifest, execution) {
-    const authority = execution.lifecycleAuthority?.attestation;
-    if (!authority || execution.result?.exitCode !== 0)
-        return true;
-    try {
-        consumeLifecycleRecoveryAttestation(authority);
-        return true;
-    }
-    catch (error) {
-        appendBrokerAudit(manifest, 'lifecycle-authority-consume-retry', {
-            ...requestAuditFields(manifest, execution.request),
-            errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_CONSUME_FAILED'
-        });
-        return false;
-    }
-}
-function lifecycleAuthorityForRequest(manifest, manifestPath, request) {
-    const selector = request.family === 'task-workflow' || request.family === 'task-orchestration'
-        ? request.authority
-        : undefined;
-    if (!selector)
-        return undefined;
-    let controllerBinding = null;
-    try {
-        const registration = readCodexControllerRegistration(manifestPath);
-        controllerBinding = {
-            instanceDigest: registration.controllerInstanceDigest,
-            controlGeneration: registration.controlGeneration
-        };
-    }
-    catch {
-        // The issuer reports the stable unavailable result; the broker never trusts
-        // a controller binding supplied by the request.
-    }
-    return issueLifecycleRecoveryAttestation(selector, {
-        controllerBinding,
-        capabilityStore: createCodexCapabilityStore(),
-        buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot)
-    });
-}
 function appendBrokerAudit(manifest, event, fields = {}) {
     appendDiagnosticAudit(manifest, event, { source: 'broker', ...fields });
 }
-function operationKey(request, output) {
+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 === 'task-workflow')
-        return request.workflow.operation;
-    if (request.family !== 'task-lifecycle' && request.family !== 'task-orchestration')
+    if (request.family !== 'task-lifecycle')
         return null;
-    if (request.family === 'task-orchestration' && request.args[1] === 'route') {
-        if (!output)
-            return 'route';
-        const result = parseControlOutput(output);
-        return result?.changed === true && result.status === 'completed' ? 'route.clean-completion' : 'route.read';
-    }
     try {
         const operation = parseTaskControlOperation(request.family, request.args);
-        return operation.family === 'task-orchestration' ? operation.intent : operation.request.intent;
+        return operation.family === 'task-lifecycle' ? operation.request.intent : null;
     }
     catch {
         return null;
     }
 }
-function recoveryOperationKey(request, terminalResult, output) {
-    const operation = operationKey(request, output);
-    if (operation !== 'route')
-        return operation;
-    const digest = terminalResult?.intentDigest;
-    for (const candidate of ['route.read', 'route.clean-completion']) {
-        const expected = operationRecoveryBinding(request.id, request.generation, null, request.family, candidate).intentDigest;
-        if (digest === expected)
-            return candidate;
-    }
-    return null;
+function recoveryOperationKey(request) {
+    return operationKey(request);
 }
 function terminalResultMatchesRequest(request, terminalResult) {
     const operation = operationKey(request);
-    const candidates = operation === 'route'
-        ? ['route.read', 'route.clean-completion']
-        : operation ? [operation] : [];
+    const candidates = operation ? [operation] : [];
     return candidates.some((candidate) => createHash('sha256').update(`${request.family}\0${candidate}`, 'utf8').digest('hex') === terminalResult.intentDigest);
 }
 function criticalRequestPhase(manifest, request, phase, outcome, reference) {
@@ -192,48 +124,6 @@ export function writeSandboxControlResponse(manifest, response) {
     }
     return true;
 }
-function finalizationRecoveryResponse(manifest, requestId, exitCode) {
-    if (!manifest.taskId || exitCode !== 0)
-        return { status: 'not-applicable' };
-    let receipt;
-    try {
-        receipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId);
-        if (!receipt || !receipt.controlBinding
-            || receipt.controlBinding.generation !== manifest.generation
-            || receipt.controlBinding.requestId !== requestId)
-            return { status: 'deferred' };
-        const resolved = resolveTaskRef(manifest.taskId, { repoRoot: manifest.repoRoot });
-        if (!resolved.ok || resolved.state !== 'completed' || receipt.lifecycle !== 'done')
-            return { status: 'deferred' };
-    }
-    catch {
-        return { status: 'deferred' };
-    }
-    return { status: 'matched', response: finalizationTerminalResponse(manifest.taskId, requestId, receipt) };
-}
-function publishFinalizationTaskView(manifest, broker, requestId, state, reasonCode, activeRequestId) {
-    let view;
-    try {
-        const resolved = resolveTaskRef(manifest.taskId ?? '', { repoRoot: manifest.repoRoot });
-        const receipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId ?? '');
-        view = resolved.ok && resolved.state === 'completed'
-            ? taskViewAfterFinalization({
-                taskId: manifest.taskId ?? '', generation: manifest.generation, requestId, receipt
-            })
-            : {
-                state: 'unknown', taskId: manifest.taskId, observedSource: 'unknown', receipt: null,
-                reasonCode: 'SANDBOX_TASK_VIEW_SOURCE_UNCONFIRMED'
-            };
-    }
-    catch {
-        view = {
-            state: 'unknown', taskId: manifest.taskId, observedSource: 'unknown', receipt: null,
-            reasonCode: 'SANDBOX_TASK_VIEW_RECEIPT_INVALID'
-        };
-    }
-    writeSandboxControlStatus(manifest, broker, state, reasonCode, activeRequestId, Date.now(), view);
-    return view;
-}
 function payloadReference(payload) {
     return {
         version: payload.version,
@@ -257,7 +147,7 @@ function outputMatchesEvidence(output, bytes, sha256) {
     return Buffer.byteLength(output, 'utf8') === bytes
         && createHash('sha256').update(output, 'utf8').digest('hex') === sha256;
 }
-export function genericRecoveryResponse(request, exitCode, payload, cause = 'recovery', warning = null) {
+export function genericRecoveryResponse(request, exitCode, payload, cause = 'recovery') {
     const outputUnavailable = request.family === 'task-create' && !payload;
     return {
         version: 2,
@@ -265,11 +155,9 @@ export function genericRecoveryResponse(request, exitCode, payload, cause = 'rec
         phase: 'completed',
         exitCode,
         stdout: outputUnavailable ? `${JSON.stringify(taskCreateOutputUnavailableResult(request.id))}\n` : '',
-        stderr: payload ? '' : warning
-            ? `${warning.code}: ${warning.message}\nAction: ${warning.action}\n`
-            : cause === 'publish'
-                ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
-                : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
+        stderr: payload ? '' : cause === 'publish'
+            ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
+            : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
         error: null,
         outputState: payload ? 'available' : 'unavailable',
         payload: payload ? payloadReference(payload) : null
@@ -335,32 +223,10 @@ function controllerDomainEvidence(manifest, manifestPath, request, output) {
                 && output?.status === 'closed' && typeof output.changed === 'boolean' };
     }
 }
-function orchestrationDomainEvidence(operation, terminalResult, output, run) {
-    if (!operation || !output)
-        return { consistent: false };
-    const outputRun = output.run && typeof output.run === 'object' && !Array.isArray(output.run)
-        ? output.run : null;
-    const runMatches = outputRun === null ? run === null : run !== null && JSON.stringify(run) === JSON.stringify(outputRun);
-    if (operation.class === 'read-only') {
-        return {
-            consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
-            snapshotValid: true,
-            status: run?.status ?? terminalResult.status,
-            pendingDelegation: run?.pendingDelegation ?? null
-        };
-    }
-    if (!run || !outputRun)
-        return { consistent: false };
-    return {
-        consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
-        status: run.status,
-        pendingDelegation: run.pendingDelegation
-    };
-}
-function readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payloadOutput) {
+async function readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payloadOutput) {
     if (!operation)
         return { domain: null };
-    const taskRef = request.family === 'task-finalization' || request.family === 'task-workflow'
+    const taskRef = request.family === 'task-finalization'
         ? manifest.taskId
         : 'args' in request ? request.args[0] ?? null : manifest.taskId;
     const output = parseControlOutput(payloadOutput);
@@ -369,21 +235,7 @@ function readRecoveryDomain(manifest, manifestPath, request, operation, terminal
     }
     if (operation.family === 'task-lifecycle') {
         if (operation.intent === 'recover-started') {
-            try {
-                if (!('args' in request))
-                    return { domain: null };
-                const parsed = parseTaskControlOperation('task-lifecycle', request.args);
-                if (parsed.family !== 'task-lifecycle' || parsed.request.intent !== 'recover-started') {
-                    return { domain: null };
-                }
-                return {
-                    domain: readLifecycleRecoveryDomainEvidence(manifest.repoRoot, parsed.request, terminalResult),
-                    journal: readLifecycleJournalEvidence(manifest.repoRoot, taskRef)
-                };
-            }
-            catch {
-                return { domain: null };
-            }
+            return { domain: null };
         }
         if (!taskRef || !terminalResult.targetState)
             return { domain: null };
@@ -403,51 +255,12 @@ function readRecoveryDomain(manifest, manifestPath, request, operation, terminal
             return { domain: { consistent: false }, journal };
         }
     }
-    if (operation.family === 'task-orchestration') {
-        if (!taskRef)
-            return { domain: null };
-        try {
-            const resolved = resolveTaskRef(taskRef, { repoRoot: manifest.repoRoot });
-            if (!resolved.ok)
-                return { domain: { consistent: false } };
-            const run = readRun(resolved.taskDir);
-            if (!run && operation.class !== 'read-only')
-                return { domain: { consistent: false } };
-            if (operation.class === 'route.clean-completion') {
-                const snapshot = captureRepositorySnapshot(manifest.repoRoot);
-                const metadata = parseTypedTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
-                const completion = run?.completionEvidence ?? null;
-                const consistent = run !== null && completion !== null
-                    && terminalResult.completionEvidence !== null
-                    && isDeepStrictEqual(completion, terminalResult.completionEvidence);
-                return {
-                    domain: {
-                        consistent,
-                        status: run?.status ?? null,
-                        pendingDelegation: run?.pendingDelegation ?? null,
-                        completionEvidence: completion,
-                        snapshot,
-                        lastReviewedCommit: metadata.last_reviewed_commit
-                    }
-                };
-            }
-            return { domain: orchestrationDomainEvidence(operation, terminalResult, output, run) };
-        }
-        catch {
-            return { domain: { consistent: false } };
-        }
-    }
     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 === 'task-workflow') {
-        return {
-            domain: { consistent: output?.status === terminalResult.status && output.changed === terminalResult.changed, snapshotValid: true }
-        };
-    }
     return { domain: null };
 }
 function readCommittedCriticalPhases(manifest, requestId) {
@@ -461,8 +274,8 @@ function readCommittedCriticalPhases(manifest, requestId) {
         }
     });
 }
-export function recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult) {
-    const operationName = recoveryOperationKey(request, terminalResult, payload?.stdout);
+export async function recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult) {
+    const operationName = recoveryOperationKey(request);
     const operation = operationName ? findSandboxControlRecoveryOperation(request.family, operationName) : null;
     if (!operation)
         return null;
@@ -473,35 +286,7 @@ export function recoveryResponse(manifest, manifestPath, request, evidence, payl
         if (JSON.stringify(payloadTerminal) !== JSON.stringify(terminalResult))
             return unknown(request.id);
     }
-    const finalization = request.family === 'task-finalization' ? finalizationRecoveryResponse(manifest, request.id, 0) : null;
-    if (evidence.exitCode === 0 && finalization?.status === 'deferred')
-        return null;
-    if (evidence.exitCode === 0 && request.family === 'task-workflow' && request.authority?.phase === 'task-event.completed') {
-        try {
-            const registration = readCodexControllerRegistration(manifestPath);
-            const recovered = recoverLifecycleRecoveryOperation(request.authority, {
-                repoRoot: manifest.repoRoot,
-                capabilityStore: createCodexCapabilityStore(),
-                buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot),
-                controllerBinding: {
-                    instanceDigest: registration.controllerInstanceDigest,
-                    controlGeneration: registration.controlGeneration
-                }
-            });
-            if (recovered.status !== 'committed')
-                return null;
-        }
-        catch (error) {
-            appendBrokerAudit(manifest, 'lifecycle-authority-recovery-failed', {
-                ...requestAuditFields(manifest, request),
-                errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_RECOVERY_FAILED'
-            });
-            return null;
-        }
-    }
-    const recovery = finalization
-        ? { domain: { consistent: finalization.status === 'matched' } }
-        : readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
+    const recovery = await readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
     const binding = operationRecoveryBinding(request.id, manifest.generation, manifest.taskId, request.family, operationName);
     const decision = classifySandboxControlRecovery({
         operation,
@@ -518,23 +303,9 @@ export function recoveryResponse(manifest, manifestPath, request, evidence, payl
         return notExecuted(request.id);
     if (decision.outcome !== 'success' && decision.outcome !== 'failure')
         return null;
-    if (request.family === 'task-finalization' && evidence.exitCode === 0) {
-        if (finalization?.status !== 'matched')
-            return null;
-        return finalization.response ?? null;
-    }
-    return genericRecoveryResponse(request, evidence.exitCode, payload, 'recovery', terminalResult.warning ?? null);
+    return genericRecoveryResponse(request, evidence.exitCode, payload);
 }
-function terminalMatchesEvidence(manifest, manifestPath, request, response, evidence, payload, payloadInvalid, terminalResult) {
-    if (request.family === 'task-finalization' && evidence.exitCode === 0) {
-        if (!terminalResult)
-            return { valid: false, payloadReferenced: false };
-        const expected = recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult);
-        return {
-            valid: expected !== null && JSON.stringify(response) === JSON.stringify(expected),
-            payloadReferenced: false
-        };
-    }
+async function terminalMatchesEvidence(manifest, request, response, evidence, payload, payloadInvalid, terminalResult) {
     if (response.version !== 2 || response.id !== request.id || response.phase !== 'completed'
         || response.exitCode !== evidence.exitCode || response.error !== null) {
         return { valid: false, payloadReferenced: false };
@@ -558,7 +329,7 @@ function terminalMatchesEvidence(manifest, manifestPath, request, response, evid
     if (response.outputState === 'unavailable') {
         const causes = ['recovery', 'publish'];
         const valid = causes.some((cause) => JSON.stringify(response)
-            === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause, terminalResult?.warning ?? null)));
+            === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause)));
         return { valid, payloadReferenced: false };
     }
     return {
@@ -568,58 +339,41 @@ function terminalMatchesEvidence(manifest, manifestPath, request, response, evid
         payloadReferenced: false
     };
 }
-function publishExecutionResult(manifest, request, result, broker, brokerOwns) {
+function publishExecutionResult(manifest, request, result, brokerOwns) {
     const normalized = sanitizeSandboxControlResult(manifest, result);
     const terminalResult = writeSandboxControlTerminalResult(manifest, {
         id: request.id,
         family: request.family,
-        operation: operationKey(request, normalized.stdout)
+        operation: operationKey(request)
     }, normalized.stdout);
     if (fs.existsSync(path.join(manifest.processingDir, request.id, 'transitions'))) {
         criticalRequestPhase(manifest, request, 'completed', normalized.exitCode === 0 ? 'success' : 'failure');
         criticalRequestPhase(manifest, request, 'evidence-written', normalized.exitCode === 0 ? 'success' : 'failure');
         criticalRequestPhase(manifest, request, 'publish-authorized', normalized.exitCode === 0 ? 'success' : 'failure');
     }
-    let terminal = null;
-    if (request.family === 'task-finalization') {
-        const finalization = finalizationRecoveryResponse(manifest, request.id, normalized.exitCode);
-        if (finalization.status === 'deferred')
-            return false;
-        terminal = finalization.response ?? null;
-    }
-    if (!terminal) {
-        const inline = {
-            version: 2, id: request.id, phase: 'completed', exitCode: normalized.exitCode,
-            stdout: normalized.stdout, stderr: normalized.stderr, error: null
-        };
-        if (sandboxControlEncodedJsonBytes(inline) <= SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES) {
-            terminal = inline;
-        }
+    let terminal = {
+        version: 2, id: request.id, phase: 'completed', exitCode: normalized.exitCode,
+        stdout: normalized.stdout, stderr: normalized.stderr, error: null
+    };
+    if (sandboxControlEncodedJsonBytes(terminal) > SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES) {
         let payload = null;
-        if (!terminal) {
-            try {
-                payload = createSandboxControlPayload(manifest, request.id, normalized);
-                const usage = sandboxControlGenerationUsage(manifest);
-                if (usage.bytes + sandboxControlEncodedJsonBytes(payload) <= SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
-                    writeSandboxControlPayload(manifest, request.id, normalized);
-                }
-                else {
-                    payload = null;
-                }
+        try {
+            payload = createSandboxControlPayload(manifest, request.id, normalized);
+            const usage = sandboxControlGenerationUsage(manifest);
+            if (usage.bytes + sandboxControlEncodedJsonBytes(payload) <= SANDBOX_CONTROL_MAX_RESPONSE_BYTES) {
+                writeSandboxControlPayload(manifest, request.id, normalized);
             }
-            catch {
+            else {
                 payload = null;
             }
-            terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish', terminalResult.warning ?? null);
         }
+        catch {
+            payload = null;
+        }
+        terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish');
     }
     if (!brokerOwns())
         return false;
-    if (request.family === 'task-finalization' && normalized.exitCode === 0) {
-        const view = publishFinalizationTaskView(manifest, broker, request.id, 'healthy', null, null);
-        if (view.state === 'unknown')
-            return false;
-    }
     const committed = writeSandboxControlResponse(manifest, terminal);
     if (committed && fs.existsSync(path.join(manifest.processingDir, request.id, 'transitions'))) {
         criticalRequestPhase(manifest, request, 'published-committed', normalized.exitCode === 0 ? 'success' : 'failure');
@@ -697,7 +451,7 @@ function assertCurrentSandboxControlIdentity(manifest, manifestPath) {
         throw new Error(`SANDBOX_CONTROL_IDENTITY_${result.state.replaceAll('-', '_').toUpperCase()}`);
     }
 }
-function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
+async function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
     for (const entry of fs.readdirSync(manifest.processingDir, { withFileTypes: true })) {
         if (!entry.isDirectory() || !/^[a-f0-9-]{16,64}$/.test(entry.name))
             continue;
@@ -819,16 +573,11 @@ function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
             if (terminal && request && resultEvidence) {
                 if (!terminalResult && request.family !== 'task-create')
                     continue;
-                const reconciliation = terminalMatchesEvidence(manifest, manifestPath, request, existingTerminalResponse, resultEvidence, payload, payloadInvalid, terminalResult);
+                const reconciliation = await terminalMatchesEvidence(manifest, request, existingTerminalResponse, resultEvidence, payload, payloadInvalid, terminalResult);
                 if (!reconciliation.valid)
                     continue;
                 terminalReconciled = true;
                 payloadReferenced = reconciliation.payloadReferenced;
-                if (request.family === 'task-finalization' && resultEvidence.exitCode === 0) {
-                    const view = publishFinalizationTaskView(manifest, broker, request.id, 'starting', null, null);
-                    if (view.state === 'unknown')
-                        continue;
-                }
             }
             if (!terminalResult && !terminalReconciled) {
                 if (terminal)
@@ -852,14 +601,9 @@ function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
                     return false;
                 if (!resultEvidence || !request || payloadInvalid)
                     continue;
-                const recovered = recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult);
+                const recovered = await recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult);
                 if (!recovered)
                     continue;
-                if (request.family === 'task-finalization' && resultEvidence.exitCode === 0) {
-                    const view = publishFinalizationTaskView(manifest, broker, request.id, 'starting', null, null);
-                    if (view.state === 'unknown')
-                        continue;
-                }
                 writeSandboxControlResponse(manifest, recovered);
                 const preserveRecoveryEvidence = recovered.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN';
                 if (transitionProtocolActive && !preserveRecoveryEvidence) {
@@ -867,7 +611,7 @@ function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
                 }
                 if (preserveRecoveryEvidence)
                     continue;
-                payloadReferenced = Boolean(payload) && request.family !== 'task-finalization';
+                payloadReferenced = Boolean(payload);
             }
         }
         else {
@@ -961,14 +705,10 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
             startupReceipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId);
         }
         catch {
-            // Preserve malformed receipt evidence as unknown rather than treating it as no receipt.
             startupReceipt = {};
         }
     }
-    let taskView = taskViewForManifest({
-        ...manifest,
-        receipt: startupReceipt
-    });
+    let taskView = taskViewForManifest({ ...manifest, receipt: startupReceipt });
     try {
         const previous = readSandboxControlStatus(manifest.publicStatusDir);
         if (previous.generation === manifest.generation)
@@ -1008,7 +748,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
             pid: broker.pid,
             brokerId: broker.brokerId
         });
-        if (!recoverProcessing(manifest, manifestPath, broker, brokerOwns))
+        if (!await recoverProcessing(manifest, manifestPath, broker, brokerOwns))
             return;
         try {
             const published = readSandboxControlStatus(manifest.publicStatusDir);
@@ -1150,21 +890,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                     break;
                 let terminalCommitted = false;
                 if (settledExecution.result && settledExecution.resultEvidenceWritten) {
-                    if (!consumeLifecycleAuthorityForResult(manifest, settledExecution)) {
-                        active = settledExecution;
-                        continue;
-                    }
-                    terminalCommitted = publishExecutionResult(manifest, settledExecution.request, settledExecution.result, broker, brokerOwns);
-                    if (terminalCommitted && settledExecution.request.family === 'task-finalization') {
-                        try {
-                            const published = readSandboxControlStatus(manifest.publicStatusDir);
-                            if (published.generation === manifest.generation)
-                                taskView = published.taskView;
-                        }
-                        catch {
-                            taskView = { state: 'unknown', taskId: manifest.taskId, observedSource: 'unknown', receipt: null, reasonCode: 'SANDBOX_TASK_VIEW_STATUS_INVALID' };
-                        }
-                    }
+                    terminalCommitted = publishExecutionResult(manifest, settledExecution.request, settledExecution.result, brokerOwns);
                 }
                 else {
                     terminalCommitted = writeSandboxControlResponse(manifest, unknown(settledExecution.request.id));
@@ -1247,14 +973,9 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                         executorCwd: manifest.repoRoot,
                         executorEntry: options.internalCliPath ?? process.argv[1] ?? null
                     });
-                    const lifecycleAuthority = lifecycleAuthorityForRequest(manifest, manifestPath, request);
-                    if (lifecycleAuthority?.status === 'rejected') {
-                        throw Object.assign(new Error(lifecycleAuthority.error?.message ?? 'lifecycle authority was rejected'), { code: lifecycleAuthority.error?.code ?? 'LIFECYCLE_AUTHORITY_REJECTED' });
-                    }
                     prepared = await prepareExecution({
                         manifest, manifestPath, request, requestPath: claimed,
-                        internalCliPath: options.internalCliPath ?? process.argv[1],
-                        ...(lifecycleAuthority ? { lifecycleAuthority } : {})
+                        internalCliPath: options.internalCliPath ?? process.argv[1]
                     });
                     const preparedExecution = prepared;
                     if (!preparedExecution)
@@ -1270,7 +991,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                         executionPath: executionPath(manifest, request.id)
                     });
                     const execution = {
-                        request, prepared: preparedExecution, lifecycleAuthority, result: null,
+                        request, prepared: preparedExecution, result: null,
                         resultEvidenceWritten: false, failure: null, settled: false
                     };
                     active = execution;
@@ -1431,8 +1152,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                 }
             }
             if (owned && active.result && active.resultEvidenceWritten) {
-                if (consumeLifecycleAuthorityForResult(manifest, active)
-                    && publishExecutionResult(manifest, active.request, active.result, broker, brokerOwns)) {
+                if (publishExecutionResult(manifest, active.request, active.result, brokerOwns)) {
                     if (brokerOwns()) {
                         removeAcceptedResponse(manifest, active.request.id);
                         fs.rmSync(path.join(manifest.processingDir, active.request.id), { recursive: true, force: true });
@@ -1441,22 +1161,8 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                 }
             }
             if (active) {
-                const terminationConfirmed = active.prepared.terminate(owned);
-                if (owned && brokerOwns() && active.request.family === 'task-finalization') {
-                    const recovered = finalizationRecoveryResponse(manifest, active.request.id, 0);
-                    const view = recovered.status === 'matched'
-                        ? publishFinalizationTaskView(manifest, broker, active.request.id, 'healthy', null, null)
-                        : null;
-                    if (view?.state !== 'unknown' && recovered.status === 'matched' && recovered.response
-                        && writeSandboxControlResponse(manifest, recovered.response)) {
-                        if (terminationConfirmed && brokerOwns()) {
-                            removeAcceptedResponse(manifest, active.request.id);
-                            fs.rmSync(path.join(manifest.processingDir, active.request.id), { recursive: true, force: true });
-                            active = null;
-                        }
-                    }
-                }
-                if (owned && brokerOwns() && active && active.request.family !== 'task-finalization' && !active.resultEvidenceWritten) {
+                active.prepared.terminate(owned);
+                if (owned && brokerOwns() && active && !active.resultEvidenceWritten) {
                     writeSandboxControlResponse(manifest, unknown(active.request.id));
                 }
             }

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

@@ -1,6 +1,5 @@
 import { isCompletionEvidence } from '../../task/orchestration.js';
 import { parseControlOutput } from '../../task/control-recovery.js';
-import { isRecoveryWarning } from '../../task/recovery-warning.js';
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -84,7 +83,6 @@ export function createSandboxControlTerminalResult(manifest, request, output) {
         ? nested.run : null;
     const rawCompletion = nested.completionEvidence ?? run?.completionEvidence;
     const operation = request.operation ?? (typeof nested.intent === 'string' ? nested.intent : null) ?? '';
-    const warning = isRecoveryWarning(nested.warning) ? nested.warning : null;
     return {
         version: 1,
         requestId: request.id,
@@ -94,8 +92,7 @@ export function createSandboxControlTerminalResult(manifest, request, output) {
         targetState: typeof nested.targetState === 'string' ? nested.targetState : null,
         status: typeof nested.status === 'string' ? nested.status : 'completed',
         changed: typeof nested.changed === 'boolean' ? nested.changed : null,
-        completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null,
-        ...(warning ? { warning } : {})
+        completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null
     };
 }
 export function writeSandboxControlTerminalResult(manifest, request, output) {
@@ -126,9 +123,6 @@ export function readSandboxControlTerminalResult(filePath) {
     if (value.completionEvidence !== null && !isCompletionEvidence(value.completionEvidence)) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }
-    if (value.warning !== undefined && value.warning !== null && !isRecoveryWarning(value.warning)) {
-        throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
-    }
     if (value.changed === undefined) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }