@fitlab-ai/agent-infra 0.11.1 → 0.11.2

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

@@ -357,43 +357,6 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             ? lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', message)
             : orchestrationFailure(code, message);
     }
-    let controllerBinding = null;
-    if (request.family === 'task-orchestration') {
-        const codexPrepare = operation.family === 'task-orchestration'
-            && operation.intent === 'prepare'
-            && operation.input.client === 'codex';
-        if (codexPrepare) {
-            if (!request.controllerProof) {
-                const authority = options.lifecycleRecoveryAttestation;
-                if (!authority || authority.phase !== 'orchestration.prepare') {
-                    return orchestrationFailure('CODEX_SANDBOX_CONTROLLER_PROOF_REQUIRED', 'Codex prepare requires a current controller lease proof');
-                }
-                controllerBinding = {
-                    instanceDigest: authority.controllerInstanceDigest,
-                    controlGeneration: authority.controlGeneration
-                };
-            }
-            else {
-                try {
-                    controllerBinding = (options.resolveControllerBinding ?? resolveCodexControllerBinding)({
-                        manifest,
-                        manifestPath,
-                        proof: request.controllerProof,
-                        buildIdentity: (options.buildIdentity ?? computeLifecycleBuildIdentity)(manifest.repoRoot)
-                    });
-                }
-                catch (error) {
-                    const code = error instanceof CodexControllerRegistrationError
-                        ? error.code
-                        : 'CODEX_SANDBOX_CONTROLLER_PROOF_INVALID';
-                    return orchestrationFailure(code, `${code}: Codex controller proof was rejected`);
-                }
-            }
-        }
-        else if (request.controllerProof !== null) {
-            return orchestrationFailure('CODEX_SANDBOX_CONTROLLER_PROOF_INVALID', 'Controller proof is only accepted for canonical Codex prepare');
-        }
-    }
     const diagnosticLog = (event, fields) => {
         appendExecutorAudit(manifest, event.startsWith('orchestration-') ? event : `orchestration-${event}`, {
             requestId: request.id,
@@ -411,7 +374,6 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
         manifestPath,
         requestId: request.id,
         diagnosticLog,
-        ...(controllerBinding ? { controllerBinding } : {}),
         lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
     });
     const format = (value) => {

package/dist/lib/sandbox/control/finalization-response.js

@@ -1,9 +1,15 @@
 export function finalizationTerminalResponse(taskId, requestId, receipt) {
     const pendingSteps = [
         receipt.taskComment === 'pending' ? 'task-comment' : null,
-        receipt.verification === 'pending' ? 'verification' : null
+        receipt.verification === 'pending' ? 'verification' : null,
+        receipt.summary === 'pending' ? 'summary' : null,
+        receipt.postSummaryVerification === 'pending' ? 'post-summary-verification' : null
     ].filter((step) => step !== null);
-    const completedSteps = ['lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment', receipt.verification === 'pending' ? null : 'verification']
+    const completedSteps = [
+        'lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment',
+        receipt.verification === 'pending' ? null : 'verification', receipt.summary === 'pending' ? null : 'summary',
+        receipt.postSummaryVerification === 'pending' ? null : 'post-summary-verification'
+    ]
         .filter((step) => step !== null);
     const warnings = receipt.warnings
         .filter((warning) => warning.status === 'open')
@@ -13,6 +19,8 @@ export function finalizationTerminalResponse(taskId, requestId, receipt) {
         lifecycle: { status: 'no-op', changed: false, error: null },
         taskComment: receipt.taskComment === 'pending' ? null : { status: 'no-op', changed: false, error: null },
         verification: receipt.verification === 'pending' ? null : { status: 'no-op', changed: false, error: null },
+        summary: receipt.summary === 'pending' ? null : { status: 'no-op', changed: false, error: null },
+        postSummaryVerification: receipt.postSummaryVerification === 'pending' ? null : { status: 'no-op', changed: false, error: null },
         completedSteps, pendingSteps,
         result: pendingSteps.length > 0 || receipt.warningProjection === 'pending' || warnings.length > 0
             ? 'completed_with_warnings' : 'completed',

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

@@ -13,9 +13,11 @@ function receiptIdentity(value, generation, requestId) {
     if (!binding || typeof binding !== 'object' || Array.isArray(binding))
         return null;
     const controlBinding = binding;
-    if (receipt.version !== 2 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
+    if (receipt.version !== 3 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
         || !Number.isSafeInteger(receipt.revision) || receipt.revision < 0
         || receipt.lifecycle !== 'done'
+        || !['pending', 'done', 'skipped'].includes(String(receipt.summary))
+        || !['pending', 'done', 'skipped'].includes(String(receipt.postSummaryVerification))
         || controlBinding.generation !== generation
         || typeof controlBinding.requestId !== 'string'
         || !/^[a-f0-9-]{16,64}$/u.test(controlBinding.requestId)

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

@@ -1,9 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { TASK_WORKFLOW_COMMANDS } from '../../task/workflow-command.js';
 import { parseArtifactCommand, executeArtifactCommand } from '../../task/artifact-command.js';
 import { parseReviewCommand } from '../../task/review-command.js';
 import { prepareLocalArtifact, preflightLocalArtifact, commitLocalArtifactProvenance } from '../../task/local-artifact-finalization.js';
-import { prepareReviewSummaryCandidate, commitReviewSummaryProvenance, preflightReviewSummary } from '../../task/review-finalization.js';
-import { readArtifactRecoveryIntent } from '../../task/artifact-repair-intent.js';
+import { prepareReviewSummaryCandidate, preflightReviewSummary } from '../../task/review-finalization.js';
 import { withTaskExecutionLock } from '../../task/task-execution-lock.js';
 import { dispatchWorkflowCommand } from '../../task/workflow-dispatch.js';
 import { assertSandboxTaskSource } from '../workspace-view.js';
@@ -14,20 +16,25 @@ import { parseTaskEventRequest } from '../../internal/task-event.js';
 function executionResult(result) {
     return { exitCode: result.status === 'failed' || result.status === 'refused' ? 1 : 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
 }
+function replaceCurrentArtifactAtomically(file, content) {
+    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        fs.writeFileSync(temporary, content, { encoding: 'utf8', flag: 'wx' });
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
 /** The broker already authorized this host executor; domain operations own validation. */
 export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAttestation = null, options = {}) {
     let publicationCommitted = false;
-    let recoveryObservation = null;
-    const observeRecoveryPublication = () => {
-        if (!recoveryObservation || recoveryObservation.wasPassed)
-            return;
-        const intent = readArtifactRecoveryIntent(manifest.repoRoot, request.taskId, recoveryObservation.family, recoveryObservation.artifact);
-        publicationCommitted ||= intent?.state === 'preflight-ready'
-            || intent?.state === 'preflight-commit-started'
-            || intent?.state === 'preflight-passed'
-            || intent?.state === 'passed'
-            || intent?.state === 'commit-started';
-    };
     let faultTriggered = false;
     const fault = (window) => {
         if (faultTriggered || options.faultWindow !== window)
@@ -91,26 +98,13 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
                 const { family } = input;
                 if (family !== 'analysis' && family !== 'plan' && family !== 'code')
                     throw new Error('ARTIFACT_IDENTITY_INVALID');
-                const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, recoveryId: input.recoveryId, lockAlreadyHeld: true };
+                const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, lockAlreadyHeld: true };
                 if (input.operation === 'preflight') {
-                    // Preflight only seals a verified generation. It must not publish the
-                    // formal artifact, set publicationStarted, or append finalizer audit.
                     const result = preflightLocalArtifact(local);
-                    recoveryObservation = { family, artifact: input.artifact, wasPassed: false };
-                    observeRecoveryPublication();
                     return response(result);
                 }
-                recoveryObservation = {
-                    family,
-                    artifact: input.artifact,
-                    wasPassed: readArtifactRecoveryIntent(manifest.repoRoot, request.taskId, family, input.artifact)?.state === 'passed'
-                };
-                const prepared = prepareLocalArtifact(local, content, lifecycleRecoveryAttestation ?? undefined);
-                observeRecoveryPublication();
-                const commitOptions = { afterPublish: () => fault('after-atomic-rename') };
-                if (prepared.result.status === 'failed')
-                    return executionResult(commitLocalArtifactProvenance(prepared, commitOptions));
-                result = commitLocalArtifactProvenance(prepared, commitOptions);
+                const prepared = prepareLocalArtifact(local, content);
+                result = commitLocalArtifactProvenance(prepared);
             }
             else {
                 if (input.overrideTicket)
@@ -118,25 +112,17 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
                 const family = `review-${input.stage}`;
                 if (request.operation === 'review-preflight') {
                     const result = preflightReviewSummary(input, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true });
-                    recoveryObservation = { family, artifact: input.artifact, wasPassed: false };
-                    observeRecoveryPublication();
                     return response(result);
                 }
-                recoveryObservation = {
-                    family,
-                    artifact: input.artifact,
-                    wasPassed: readArtifactRecoveryIntent(manifest.repoRoot, request.taskId, family, input.artifact)?.state === 'passed'
-                };
-                const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true, startRecovery: true });
-                observeRecoveryPublication();
+                const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true });
                 if (input.dryRun || prepared.result.status === 'planned')
                     return executionResult(prepared.result);
-                const commitOptions = { afterPublish: () => fault('after-atomic-rename') };
                 if (prepared.result.status === 'failed')
-                    return executionResult(commitReviewSummaryProvenance(prepared, manifest.repoRoot, commitOptions));
-                result = commitReviewSummaryProvenance(prepared, manifest.repoRoot, commitOptions);
+                    return executionResult(prepared.result);
+                if (prepared.result.changed)
+                    replaceCurrentArtifactAtomically(path.join(taskDir, input.artifact), prepared.content);
+                result = prepared.result;
             }
-            observeRecoveryPublication();
             publicationCommitted ||= result.changed === true;
             if (result.status !== 'failed')
                 appendDiagnosticAudit(manifest, 'task-workflow-artifact-finalized', {
@@ -148,7 +134,6 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
         });
     }
     catch (error) {
-        observeRecoveryPublication();
         const message = error instanceof Error ? error.message : String(error);
         const code = error?.code ?? /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'TASK_WORKFLOW_REQUEST_INVALID';
         return executionResult({ status: 'failed', changed: publicationCommitted ? null : false, error: { code, message } });

package/dist/lib/task/artifact-command.js

@@ -15,8 +15,8 @@ export function parseArtifactCommand(args) {
     const allowed = {
         inspect: ['--family'],
         init: ['--family', '--artifact', '--locale'],
-        'preflight': ['--family', '--artifact', '--recovery-id'],
-        'finalize-local': ['--family', '--artifact', '--recovery-id']
+        'preflight': ['--family', '--artifact'],
+        'finalize-local': ['--family', '--artifact']
     }[operation];
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
@@ -38,12 +38,12 @@ export function parseArtifactCommand(args) {
         throw new Error("option '--locale' must be 'zh-CN' or 'en'");
     return {
         taskRef, operation: operation, family: fields['--family'],
-        artifact: fields['--artifact'] ?? '', locale, recoveryId: fields['--recovery-id']
+        artifact: fields['--artifact'] ?? '', locale
     };
 }
 /** Resolve authoritative task metadata separately from a trusted candidate directory. */
 export function executeArtifactCommand(command, options = {}) {
-    const { taskRef, operation, family, artifact, locale, recoveryId } = command;
+    const { taskRef, operation, family, artifact, locale } = command;
     const fail = (code, message) => ({ status: 'failed', changed: false, error: { code, message } });
     if (operation === 'inspect') {
         const result = resolveArtifactContext(taskRef, family, { repoRoot: options.repoRoot });
@@ -76,7 +76,7 @@ export function executeArtifactCommand(command, options = {}) {
         return fail('ARTIFACT_PAYLOAD_INVALID', "preflight and finalize-local only support 'analysis', 'plan', and 'code'");
     }
     if (operation === 'preflight')
-        return { ...preflightLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot, recoveryId }) };
-    return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot, recoveryId }) };
+        return { ...preflightLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
+    return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
 }
 //# sourceMappingURL=artifact-command.js.map

package/dist/lib/task/codex-orchestration.js

@@ -1,39 +1,15 @@
 import { preflightCodexLifecycleEvidence, resolveCodexSpawnedChild, resolveCodexTerminal, resolveCodexThread } from '../agent-clients/adapters/codex-lifecycle/app-server.js';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.js';
-import { createCodexCapabilityStore, isCodexCapabilityProvenanceDetail } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
-import { computeLifecycleBuildIdentity, verifyLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
-import { verifyCodexSandboxControllerContextWithWarnings as verifySandboxControllerWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
-import { verifyCodexSandboxControllerContextWithWarnings as verifyControllerContextFileWithWarnings } from '../agent-clients/adapters/codex-lifecycle/controller-context.js';
+import { computeLifecycleBuildIdentity, } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, routeOrchestration, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
-import { randomUUID, createHash } from 'node:crypto';
-import { consumeLifecycleRecoveryAttestation, issueLifecycleRecoveryAttestation, validateLifecycleRecoveryAttestation } from './control-authority.js';
-function buildIdentityDigest(value) {
-    return createHash('sha256').update(JSON.stringify(value), 'utf8').digest('hex');
-}
+import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
 function coreOptions(options) {
     return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
-function bridgeFailure(code, message, detail) {
+function bridgeFailure(code, message) {
     return {
         status: 'failed', changed: false, taskId: null, run: null, next: null,
-        error: { code, message, ...(detail ? { detail } : {}) }
-    };
-}
-function capabilityFailure(error) {
-    const detailValue = error instanceof Error
-        ? error.detail
-        : undefined;
-    return {
-        code: error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
-            ? error.name
-            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
-        message: error instanceof Error ? error.message : String(error),
-        ...(error instanceof Error
-            && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
-            && isCodexCapabilityProvenanceDetail(detailValue)
-            ? { detail: detailValue }
-            : {})
+        error: { code, message }
     };
 }
 function pauseBridge(code, message, options) {
@@ -47,28 +23,6 @@ function requiredStore(options) {
         throw new Error('Codex lifecycle store is required for orchestration bridge events');
     return options.store;
 }
-function brokerControllerBinding() {
-    const raw = process.env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING;
-    if (!raw)
-        return null;
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
-    }
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
-    }
-    const binding = value;
-    if (Object.keys(binding).sort().join(',') !== 'controlGeneration,instanceDigest'
-        || typeof binding.instanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(binding.instanceDigest)
-        || typeof binding.controlGeneration !== 'string' || binding.controlGeneration.length === 0) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
-    }
-    return binding;
-}
 async function prepareCodexOrchestrationDelegation(taskRef, input, options = {}) {
     if (input.client !== 'codex')
         return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
@@ -77,152 +31,13 @@ async function prepareCodexOrchestrationDelegation(taskRef, input, options = {})
         const resolved = resolveTaskRef(taskRef, { repoRoot });
         if (!resolved.ok)
             return bridgeFailure(resolved.code, resolved.message);
-        const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
-        const capabilityRef = input.capabilityRef;
-        if (!capabilityRef) {
-            return bridgeFailure('ORCHESTRATION_CODEX_CAPABILITY_REQUIRED', 'Codex prepare requires a current-session capability reference');
-        }
-        const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
-        const brokerController = options.controllerBinding ?? brokerControllerBinding();
-        const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-        const contextVerification = contextPath
-            ? (brokerController
-                ? verifyControllerContextFileWithWarnings(contextPath, {
-                    repoRoot,
-                    generation: process.env.AGENT_INFRA_CONTROL_GENERATION ?? brokerController.controlGeneration
-                })
-                : verifySandboxControllerWithWarnings(contextPath, { repoRoot }))
-            : null;
-        const identityWarnings = [...(contextVerification?.warnings ?? [])];
-        const localController = contextVerification?.context ?? null;
-        if (localController && brokerController
-            && (localController.controllerInstanceDigest !== brokerController.instanceDigest
-                || localController.controlGeneration !== brokerController.controlGeneration)) {
-            return bridgeFailure('CODEX_SANDBOX_CONTROLLER_BINDING_MISMATCH', 'broker and local controller bindings do not match');
-        }
-        const controller = brokerController ?? (localController ? {
-            instanceDigest: localController.controllerInstanceDigest,
-            controlGeneration: localController.controlGeneration
-        } : null);
-        const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
-        const attested = capabilityStore.inspectReference(capabilityRef);
-        const capabilityIdentity = verifyLifecycleBuildIdentity(attested.buildIdentity, buildIdentity);
-        if (!capabilityIdentity.ok) {
-            return bridgeFailure(capabilityIdentity.code, capabilityIdentity.message);
-        }
-        identityWarnings.push(...capabilityIdentity.warnings);
-        const lifecycleProvenance = {
-            ...attested.buildIdentity,
-            hookDefinitionHash: preflight.hookDefinitionHash,
-            ...preflight.hookProvenance,
-            capabilitySessionId: attested.sessionId,
-            capabilityTurnId: attested.turnId,
-            capabilityToolUseId: attested.toolUseId,
-            controllerInstanceDigest: controller?.instanceDigest ?? null,
-            controlGeneration: controller?.controlGeneration ?? null
-        };
-        const capabilityExpected = {
-            taskId: resolved.taskId,
-            hookDefinitionHash: preflight.hookDefinitionHash,
-            buildIdentity,
-            ...(controller ? { controller: {
-                    instanceDigest: controller.instanceDigest,
-                    controlGeneration: controller.controlGeneration
-                } } : {})
-        };
-        if (input.lifecycleRecoveryAttestation) {
-            try {
-                validateLifecycleRecoveryAttestation(input.lifecycleRecoveryAttestation);
-            }
-            catch (error) {
-                return bridgeFailure('LIFECYCLE_AUTHORITY_ATTESTATION_INVALID', error instanceof Error ? error.message : String(error));
-            }
-        }
-        let lifecycleRecoveryAttestation = input.lifecycleRecoveryAttestation ?? null;
-        const routed = input.capabilityRef && !lifecycleRecoveryAttestation
-            ? routeOrchestration(taskRef, coreOptions(options))
-            : null;
-        if (routed && !routed.next)
-            return routed;
-        if (routed?.next && ['analysis', 'plan', 'code'].includes(routed.next.stage)) {
-            const recoveryRequest = {
-                version: 1,
-                requestId: randomUUID(),
-                operationId: randomUUID(),
-                phase: 'orchestration.prepare',
-                taskId: resolved.taskId,
-                family: routed.next.stage === 'analysis' ? 'analysis'
-                    : routed.next.stage === 'plan' ? 'plan' : 'code',
-                artifact: routed.next.artifact,
-                round: routed.next.round,
-                lifecycleRequestId: randomUUID(),
-                authorityRef: capabilityRef,
-                expectedControlGeneration: controller?.controlGeneration ?? '',
-                expectedControllerInstanceDigest: controller?.instanceDigest ?? '0'.repeat(64),
-                expectedBuildIdentityDigest: buildIdentityDigest(buildIdentity),
-                expectedHookDefinitionHash: preflight.hookDefinitionHash
-            };
-            const authority = issueLifecycleRecoveryAttestation(recoveryRequest, {
-                capabilityStore,
-                ...(controller ? { controllerBinding: controller } : {}),
-                buildIdentity
-            });
-            if (authority.status === 'rejected' || !authority.attestation) {
-                return bridgeFailure(authority.error?.code ?? 'LIFECYCLE_AUTHORITY_REJECTED', authority.error?.message ?? 'lifecycle authority was rejected');
-            }
-            lifecycleRecoveryAttestation = authority.attestation;
-        }
-        const prepared = prepareOrchestrationDelegation(taskRef, {
-            ...input,
-            lifecycleProvenance,
-            lifecycleRecoveryAttestation
-        }, {
-            ...coreOptions(options),
-            validateLifecycleCapability: () => {
-                try {
-                    const validated = capabilityStore.validateReference(capabilityRef, capabilityExpected);
-                    if (validated.sessionId !== attested.sessionId
-                        || validated.turnId !== attested.turnId
-                        || validated.toolUseId !== attested.toolUseId) {
-                        return {
-                            code: 'CODEX_CAPABILITY_IDENTITY_CHANGED',
-                            message: 'capability identity changed during validation'
-                        };
-                    }
-                    return null;
-                }
-                catch (error) {
-                    return capabilityFailure(error);
-                }
-            },
-            consumeLifecycleCapability: () => null
-        });
-        if (lifecycleRecoveryAttestation && !options.deferLifecycleRecoveryConsumption && prepared.status !== 'failed') {
-            try {
-                consumeLifecycleRecoveryAttestation(lifecycleRecoveryAttestation);
-            }
-            catch (error) {
-                return bridgeFailure(error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_CONSUME_FAILED', error instanceof Error ? error.message : String(error));
-            }
-        }
-        return identityWarnings.length > 0 && prepared.status !== 'failed'
-            ? { ...prepared, warnings: Object.freeze(identityWarnings) }
-            : prepared;
+        await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
+        return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
     }
     catch (error) {
         if (error instanceof OrchestrationStateError)
             return bridgeFailure(error.code, error.message);
-        const detailValue = error instanceof Error
-            ? error.detail
-            : undefined;
-        const detail = error instanceof Error
-            && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
-            && isCodexCapabilityProvenanceDetail(detailValue)
-            ? detailValue
-            : undefined;
-        return bridgeFailure(error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
-            ? error.name
-            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error), detail);
+        return bridgeFailure('ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error));
     }
 }
 async function activateCodexOrchestrationDelegation(childThreadId, options = {}) {
@@ -248,16 +63,6 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
             toolUseId: evidence.spawnToolUseId
         });
         const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
-        const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-        const contextVerification = contextPath
-            ? verifySandboxControllerWithWarnings(contextPath, { repoRoot })
-            : null;
-        const controller = options.controllerBinding
-            ?? brokerControllerBinding()
-            ?? (contextVerification?.context ? {
-                instanceDigest: contextVerification.context.controllerInstanceDigest,
-                controlGeneration: contextVerification.context.controlGeneration
-            } : null);
         const activated = activateMatchingOrchestrationDelegation('codex', {
             nativeAgent: evidence.nativeAgent,
             childId: evidence.childThreadId,
@@ -279,14 +84,11 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
                 capabilityTurnId: evidence.parentTurnId,
                 spawnToolUseId: evidence.spawnToolUseId,
                 spawnObservedAt: record.spawnObservedAt ?? undefined,
-                controllerInstanceDigest: controller?.instanceDigest ?? null,
-                controlGeneration: controller?.controlGeneration ?? null
+                controllerInstanceDigest: null,
+                controlGeneration: null
             }
         }, coreOptions(options));
-        const warnings = contextVerification?.warnings ?? [];
-        return warnings.length > 0 && activated.status !== 'failed'
-            ? { ...activated, warnings: Object.freeze(warnings) }
-            : activated;
+        return activated;
     }
     catch (error) {
         if (error instanceof OrchestrationStateError)

package/dist/lib/task/commit-operation.js

@@ -181,16 +181,6 @@ function checkpointIdentity(input, task, delivery) {
 function checkpointTimestamp() {
     return new Date().toISOString();
 }
-function samePreparedCheckpointIdentity(pending, identity) {
-    return pending.state === 'prepared'
-        && pending.taskId === identity.taskId
-        && pending.branch === identity.branch
-        && pending.mode === identity.mode
-        && pending.expectedHead === identity.expectedHead
-        && pending.message === identity.message
-        && pending.round === identity.round
-        && JSON.stringify(pending.paths) === JSON.stringify(identity.paths);
-}
 function executeUnlocked(input, task, mode) {
     const inspected = inspectGitWorkflow(input.cwd);
     if (!inspected.snapshot)
@@ -225,16 +215,11 @@ function executeUnlocked(input, task, mode) {
                 };
             }
             if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity)) {
-                if (!input.recoverPreparedIntent || !samePreparedCheckpointIdentity(pendingIntent, identity))
-                    return {
-                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
-                        error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
-                    };
+                const timestamp = checkpointTimestamp();
                 pendingIntent = {
-                    ...pendingIntent,
-                    expectedTree: identity.expectedTree,
+                    version: 1, ...identity,
                     digest: checkpointIntentDigest(identity),
-                    updatedAt: checkpointTimestamp()
+                    state: 'prepared', committedHead: null, createdAt: timestamp, updatedAt: timestamp
                 };
                 try {
                     writeCheckpointIntent(task.repoRoot, pendingIntent);

package/dist/lib/task/control-authority.js

@@ -535,17 +535,11 @@ function orchestration(context, operation) {
                 client: input.client,
                 requestedModel: input.requestedModel,
                 requestedReasoningEffort: input.requestedReasoningEffort,
-                ...(input.capabilityRef === undefined ? {} : { capabilityRef: input.capabilityRef }),
-                ...(context.lifecycleRecoveryAttestation === undefined
-                    ? {}
-                    : { lifecycleRecoveryAttestation: context.lifecycleRecoveryAttestation })
             };
             if (prepareInput.client === 'codex') {
                 return prepareCodexOrchestrationDelegation(operation.taskRef, prepareInput, {
                     repoRoot: context.repoRoot,
                     orchestrationOptions: options,
-                    deferLifecycleRecoveryConsumption: context.source === 'sandbox-executor',
-                    ...(context.controllerBinding ? { controllerBinding: context.controllerBinding } : {})
                 });
             }
             return prepareOrchestrationDelegation(operation.taskRef, prepareInput, options);
@@ -629,7 +623,7 @@ const FINALIZATION_FLAGS = new Set(['--agent']);
 const ORCHESTRATION_FLAGS = new Set([
     '--agent', '--max-steps', '--executor-model', '--executor-reasoning-effort', '--reviewer-model',
     '--reviewer-reasoning-effort', '--client', '--requested-model', '--requested-reasoning-effort',
-    '--capability-ref', '--parent-id', '--before-fingerprint', '--stage', '--round', '--artifact', '--role',
+    '--parent-id', '--before-fingerprint', '--stage', '--round', '--artifact', '--role',
     '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
     '--model-fallback-reason', '--reasoning-effort-fallback-reason', '--exit-code', '--after-fingerprint',
     '--changed-paths', '--code', '--message', '--recoverable', '--git-worktree-root'
@@ -769,7 +763,6 @@ export function parseTaskControlOperation(family, args) {
     if (parsedIntent === 'prepare') {
         input.requestedModel = value(values, '--requested-model');
         input.requestedReasoningEffort = value(values, '--requested-reasoning-effort');
-        input.capabilityRef = value(values, '--capability-ref');
     }
     if (parsedIntent === 'await-activation') {
         required(values, ['--stage', '--round', '--artifact', '--role']);