@fitlab-ai/agent-infra 0.11.1 → 0.11.3

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

@@ -3,12 +3,11 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { isAgentClientId } from '../agent-clients/types.js';
+import { getAgentClientAdapter } from '../agent-clients/registry.js';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from './human-override.js';
 import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, prepareOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from './orchestration.js';
-import { prepareCodexOrchestrationDelegation } from './codex-orchestration.js';
 import { applyTaskFinalization } from './finalization.js';
 import { applyTaskLifecycle, taskLifecycleFailure } from './lifecycle.js';
-import { recoverStartedLifecycleUnderLock, recoveryFailure } from './lifecycle-recovery.js';
 import { locateActivityLog } from './activity-log.js';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
@@ -407,7 +406,6 @@ export function createSandboxExecutorExecutionContext(params) {
         generation: params.generation,
         manifestPath: absolute('manifestPath', params.manifestPath),
         requestId: params.requestId,
-        ...(params.diagnosticLog === undefined ? {} : { diagnosticLog: params.diagnosticLog }),
         ...(params.controllerBinding === undefined ? {} : { controllerBinding: binding(params.controllerBinding) }),
         ...(params.lifecycleRecoveryAttestation === undefined ? {} : {
             lifecycleRecoveryAttestation: params.lifecycleRecoveryAttestation === null
@@ -450,11 +448,7 @@ function operationTaskId(context, taskRef) {
 function domainOptions(context, options) {
     return {
         ...options,
-        repoRoot: context.repoRoot,
-        ...(context.source === 'sandbox-executor' && context.diagnosticLog !== undefined
-            ? { diagnosticLog: context.diagnosticLog }
-            : {}),
-        ...(context.source === 'sandbox-executor' ? { gitWorktreeRoot: context.worktreeRoot } : {})
+        repoRoot: context.repoRoot
     };
 }
 function lifecycleTaskId(request, repoRoot) {
@@ -475,7 +469,17 @@ async function applyLifecycleWithAuthority(context, request) {
     }
     const execute = async () => {
         if (request.intent === 'recover-started') {
-            return recoverStartedLifecycleUnderLock(request, { repoRoot: context.repoRoot });
+            const adapter = isAgentClientId(request.agent)
+                ? getAgentClientAdapter(request.agent).orchestrationAdapter
+                : undefined;
+            if (!adapter?.recoverStarted) {
+                return {
+                    status: 'no-op', changed: false, targetState: 'active',
+                    requestRef: request.taskRef, intent: 'recover-started', taskId: null,
+                    receiptId: null, childId: null, error: null
+                };
+            }
+            return adapter.recoverStarted(request, { repoRoot: context.repoRoot });
         }
         const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
         if (lifecycleResult.status !== 'failed' || !request.overrideTicket)
@@ -511,7 +515,12 @@ async function applyLifecycleWithAuthority(context, request) {
         if (!(error instanceof TaskExecutionLockError))
             throw error;
         if (request.intent === 'recover-started') {
-            return recoveryFailure(request, 'owner-unknown', error.code, error.message);
+            return {
+                status: 'owner-unknown', changed: false, targetState: 'active',
+                requestRef: request.taskRef, intent: 'recover-started', taskId,
+                receiptId: null, childId: null,
+                error: { code: error.code, message: error.message }
+            };
         }
         return taskLifecycleFailure(request, { code: error.code, message: error.message }, taskId);
     }
@@ -535,17 +544,13 @@ 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, {
+            const prepareDelegation = getAgentClientAdapter(prepareInput.client)
+                .orchestrationAdapter?.prepareDelegation;
+            if (prepareDelegation) {
+                return prepareDelegation(operation.taskRef, prepareInput, {
                     repoRoot: context.repoRoot,
                     orchestrationOptions: options,
-                    deferLifecycleRecoveryConsumption: context.source === 'sandbox-executor',
-                    ...(context.controllerBinding ? { controllerBinding: context.controllerBinding } : {})
                 });
             }
             return prepareOrchestrationDelegation(operation.taskRef, prepareInput, options);
@@ -623,22 +628,22 @@ function operationInvalid(message) {
 }
 const LIFECYCLE_FLAGS = new Set([
     '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-    '--stage', '--round', '--artifact', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
+    '--auto', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
 ]);
 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'
+    '--changed-paths', '--code', '--message', '--recoverable'
 ]);
 function parseValues(args, start, flags) {
     const values = {};
     for (let index = start; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--dry-run') {
+        if (flag === '--dry-run' || flag === '--auto') {
             if (!flags.has(flag))
                 operationInvalid(`unknown option '${flag}'`);
             if (values[flag] !== undefined)
@@ -699,31 +704,21 @@ export function parseTaskControlOperation(family, args) {
             ...(value(values, '--override-scope') ? { overrideScope: value(values, '--override-scope') } : {}),
             ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
             ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
-            ...(value(values, '--stage') ? { stage: value(values, '--stage') } : {}),
-            ...(value(values, '--round') ? { round: Number(value(values, '--round')) } : {}),
-            ...(value(values, '--artifact') ? { artifact: value(values, '--artifact') } : {}),
+            ...(values['--auto'] === true ? { auto: true } : {}),
             ...(values['--dry-run'] === true ? { dryRun: true } : {})
         };
         if (intent === 'recover-started') {
-            const recoveryFlags = new Set(['--agent', '--stage', '--round', '--artifact', '--reason']);
+            const recoveryFlags = new Set(['--agent', '--auto']);
             for (const flag of Object.keys(values)) {
                 if (!recoveryFlags.has(flag))
                     operationInvalid(`option '${flag}' is not supported for recover-started`);
             }
-            required(values, ['--stage', '--round', '--artifact', '--reason']);
-            const stage = value(values, '--stage');
-            if (!['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'].includes(stage ?? '')) {
-                operationInvalid('--stage must be a supported lifecycle stage');
-            }
-            const round = Number(value(values, '--round'));
-            if (!Number.isSafeInteger(round) || round < 1)
-                operationInvalid('--round must be a positive integer');
-            if (value(values, '--reason').includes('\n') || value(values, '--reason').includes('\r')) {
-                operationInvalid('--reason must be a single line');
-            }
+            if (values['--auto'] !== true)
+                operationInvalid('--auto is required for recover-started');
+            return { family, request: input };
         }
-        else if (values['--stage'] !== undefined || values['--round'] !== undefined || values['--artifact'] !== undefined) {
-            operationInvalid('--stage, --round, and --artifact are only supported for recover-started');
+        else if (values['--auto'] !== undefined) {
+            operationInvalid('--auto is only supported for recover-started');
         }
         return { family, request: input };
     }
@@ -769,7 +764,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']);
@@ -827,9 +821,6 @@ export function parseTaskControlOperation(family, args) {
         input.message = value(values, '--message');
         input.recoverable = recoverable === 'true';
     }
-    const options = value(values, '--git-worktree-root') === undefined
-        ? undefined
-        : { gitWorktreeRoot: value(values, '--git-worktree-root') };
-    return { family, taskRef, intent: parsedIntent, input, ...(options ? { options } : {}) };
+    return { family, taskRef, intent: parsedIntent, input };
 }
 //# sourceMappingURL=control-authority.js.map

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

@@ -1,7 +1,4 @@
 import { createHash } from 'node:crypto';
-import { isCompletionEvidence } from './orchestration.js';
-import { TASK_WORKFLOW_OPERATIONS } from './workflow-command.js';
-import { sameRecoveryWarning } from './recovery-warning.js';
 /** Normalize the command result once at the control transport boundary. */
 export function parseControlOutput(output) {
     if (output === null)
@@ -20,20 +17,10 @@ export const SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES = Object.freeze([
     'completed', 'evidence-written', 'publish-authorized'
 ]);
 const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'];
-const ORCHESTRATION_INTENTS = [
-    'begin-or-resume', 'route.read', 'route.clean-completion', 'status', 'prepare', 'dispatch',
-    'await-activation', 'recover-prepared', 'hook-start', 'hook-stop', 'advance', 'pause'
-];
 export const SANDBOX_CONTROL_RECOVERY_OPERATIONS = Object.freeze([
     ...LIFECYCLE_INTENTS.map((intent) => ({ family: 'task-lifecycle', intent, class: 'lifecycle-mutation' })),
     { family: 'task-finalization', intent: 'complete', class: 'finalization' },
-    ...ORCHESTRATION_INTENTS.map((intent) => ({
-        family: 'task-orchestration',
-        intent,
-        class: intent === 'route.clean-completion' ? 'route.clean-completion' : intent === 'route.read' || intent === 'status' ? 'read-only' : 'orchestration'
-    })),
     { family: 'task-create', intent: 'create', class: 'task-create' },
-    ...TASK_WORKFLOW_OPERATIONS.map((intent) => ({ family: 'task-workflow', intent, class: intent === 'artifact-inspect' || intent === 'decision-next-id' ? 'read-only' : 'workflow' })),
     ...['open', 'close', 'verify'].map((intent) => ({ family: 'codex-controller', intent, class: 'codex-controller' }))
 ]);
 export function digestControlRecoveryIntent(family, intent) {
@@ -53,30 +40,8 @@ function domainEvidenceMatches(operation, result, domain) {
         return false;
     if (domain.consistent !== true)
         return false;
-    if (operation.class === 'route.clean-completion') {
-        const completion = domain.completionEvidence;
-        const snapshot = domain.snapshot;
-        const lastReviewedCommit = domain.lastReviewedCommit;
-        return result.status === 'completed'
-            && domain.status === 'completed'
-            && domain.pendingDelegation === null
-            && isCompletionEvidence(completion)
-            && snapshot?.head === completion.head
-            && snapshot.headTree === completion.headTree
-            && snapshot.worktreeTree === completion.worktreeTree
-            && lastReviewedCommit === completion.lastReviewedCommit;
-    }
-    if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started') {
-        const retryRequired = domain.recoveryState === 'retry-required'
-            && sameRecoveryWarning(domain.warning, result.warning);
-        return result.targetState === 'active'
-            && ['applied', 'no-op'].includes(String(result.status))
-            && domain.recovery === true
-            && domain.targetState === 'active'
-            && (domain.recoveryState === 'released' || retryRequired);
-    }
-    if (operation.class === 'read-only')
-        return result.changed === false && domain.snapshotValid === true;
+    if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started')
+        return false;
     return true;
 }
 export function classifySandboxControlRecovery(input) {
@@ -127,11 +92,7 @@ export function classifySandboxControlRecovery(input) {
     return {
         outcome: 'success',
         responseReconstructable: true,
-        reasonCode: input.operation.class === 'route.clean-completion' && result.changed === false
-            ? 'RECOVERY_ROUTE_COMPLETION_NOOP'
-            : input.operation.intent === 'recover-started' && input.domain?.recoveryState === 'retry-required'
-                ? 'RECOVERY_RELEASE_RETRY_REQUIRED'
-                : 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
+        reasonCode: 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
     };
 }
 export function operationRecoveryBinding(requestId, generation, taskId, family, intent) {