@fitlab-ai/agent-infra 0.11.1 → 0.11.3

package/lib/task/codex-orchestration.ts

@@ -5,21 +5,10 @@ import {
   resolveCodexThread
 } from '../agent-clients/adapters/codex-lifecycle/app-server.ts';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.ts';
-import {
-  createCodexCapabilityStore,
-  isCodexCapabilityProvenanceDetail
-} from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
-import type { CodexCapabilityProvenanceDetail } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
 import {
   computeLifecycleBuildIdentity,
-  verifyLifecycleBuildIdentity,
   type LifecycleBuildIdentity,
-  type LifecycleIdentityWarning
 } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
-import { verifyCodexSandboxControllerContextWithWarnings as verifySandboxControllerWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
-import {
-  verifyCodexSandboxControllerContextWithWarnings as verifyControllerContextFileWithWarnings
-} from '../agent-clients/adapters/codex-lifecycle/controller-context.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import {
@@ -29,32 +18,20 @@ import {
   OrchestrationStateError,
   pauseMatchingOrchestrationDelegation,
   prepareOrchestrationDelegation,
-  routeOrchestration,
   reconcileMatchingOrchestrationDelegation,
   sealMatchingOrchestrationDelegationWithHostEvidence
 } from './orchestration.ts';
-import { randomUUID, createHash } from 'node:crypto';
 import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
-import {
-  consumeLifecycleRecoveryAttestation,
-  issueLifecycleRecoveryAttestation,
-  validateLifecycleRecoveryAttestation,
-  type LifecycleRecoveryAttestationV1
-} from './control-authority.ts';
 
 type LifecycleStore = ReturnType<typeof createCodexLifecycleStore>;
-type CapabilityStore = ReturnType<typeof createCodexCapabilityStore>;
 type CodexBridgeOptions = Readonly<{
   repoRoot?: string;
   store?: LifecycleStore;
   preflight?: typeof preflightCodexLifecycleEvidence;
   resolveThread?: typeof resolveCodexThread;
   resolveTerminal?: typeof resolveCodexTerminal;
-  capabilityStore?: CapabilityStore;
   buildIdentity?: LifecycleBuildIdentity;
   orchestrationOptions?: OrchestrationOptions;
-  controllerBinding?: Readonly<{ instanceDigest: string; controlGeneration: string }>;
-  deferLifecycleRecoveryConsumption?: boolean;
 }>;
 
 type CodexSpawnIdentity = Readonly<{
@@ -68,35 +45,14 @@ type CodexSpawnIdentity = Readonly<{
   requestedReasoningEffort?: string;
 }>;
 
-function buildIdentityDigest(value: LifecycleBuildIdentity): string {
-  return createHash('sha256').update(JSON.stringify(value), 'utf8').digest('hex');
-}
-
 function coreOptions(options: CodexBridgeOptions): OrchestrationOptions {
   return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
 
-function bridgeFailure(code: string, message: string, detail?: CodexCapabilityProvenanceDetail): OrchestrationResult {
+function bridgeFailure(code: string, message: string): OrchestrationResult {
   return {
     status: 'failed', changed: false, taskId: null, run: null, next: null,
-    error: { code, message, ...(detail ? { detail } : {}) }
-  };
-}
-
-function capabilityFailure(error: unknown): NonNullable<OrchestrationResult['error']> {
-  const detailValue = error instanceof Error
-    ? (error as Error & { detail?: unknown }).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 }
   };
 }
 
@@ -112,35 +68,12 @@ function requiredStore(options: CodexBridgeOptions): LifecycleStore {
   return options.store;
 }
 
-function brokerControllerBinding(): Readonly<{ instanceDigest: string; controlGeneration: string }> | null {
-  const raw = process.env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING;
-  if (!raw) return null;
-  let value: unknown;
-  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 as Record<string, unknown>;
-  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 as { instanceDigest: string; controlGeneration: string };
-}
-
 async function prepareCodexOrchestrationDelegation(
   taskRef: string,
   input: Readonly<{
     client: AgentClientId;
     requestedModel?: string;
     requestedReasoningEffort?: string;
-    capabilityRef?: string;
-    lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
   }>,
   options: CodexBridgeOptions = {}
 ): Promise<OrchestrationResult> {
@@ -149,164 +82,11 @@ async function prepareCodexOrchestrationDelegation(
     const repoRoot = options.repoRoot ?? process.cwd();
     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: LifecycleIdentityWarning[] = [...(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: LifecycleRecoveryAttestationV1 | null = 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 as const,
-        requestId: randomUUID(),
-        operationId: randomUUID(),
-        phase: 'orchestration.prepare' as const,
-        taskId: resolved.taskId,
-        family: routed.next.stage === 'analysis' ? 'analysis' as const
-          : routed.next.stage === 'plan' ? 'plan' as const : 'code' as const,
-        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 as Error & { detail?: unknown }).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));
   }
 }
 
@@ -335,16 +115,6 @@ async function activateCodexOrchestrationDelegation(
       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,
@@ -366,14 +136,11 @@ async function activateCodexOrchestrationDelegation(
         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) return bridgeFailure(error.code, error.message);
     return pauseBridge('ORCHESTRATION_CODEX_START_FAILED', error instanceof Error ? error.message : String(error), options);

package/lib/task/commit-operation.ts

@@ -32,8 +32,6 @@ type CommitOperationInput = Readonly<{
   agent?: string;
   mode?: CommitExecutionMode;
   round?: number;
-  /** Permit one retry to rebase a prepared intent's expected tree while HEAD and intent identity remain unchanged. */
-  recoverPreparedIntent?: boolean;
   delivery?: Readonly<{
     mode: 'local' | 'push';
     remote: string;
@@ -282,20 +280,6 @@ function checkpointTimestamp(): string {
   return new Date().toISOString();
 }
 
-function samePreparedCheckpointIdentity(
-  pending: NonNullable<ReturnType<typeof readCheckpointIntent>>,
-  identity: Parameters<typeof checkpointIntentDigest>[0]
-): boolean {
-  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: CommitOperationInput, task: BoundTask | null, mode: CommitExecutionMode): CommitOperationResult {
   const inspected = inspectGitWorkflow(input.cwd);
   if (!inspected.snapshot) return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
@@ -330,15 +314,11 @@ function executeUnlocked(input: CommitOperationInput, task: BoundTask | null, mo
         };
       }
       if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity)) {
-        if (!input.recoverPreparedIntent || !samePreparedCheckpointIdentity(pendingIntent, identity)) return {
-          status: 'failed' as const, 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); }
         catch (error) {

package/lib/task/control-authority.ts

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
 import { isAgentClientId } from '../agent-clients/types.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
+import { getAgentClientAdapter } from '../agent-clients/registry.ts';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from './human-override.ts';
 import {
   activateMatchingOrchestrationDelegation,
@@ -22,12 +23,7 @@ import {
   sealOrchestrationDelegation,
   statusOrchestration
 } from './orchestration.ts';
-import type {
-  OrchestrationDiagnosticLogger,
-  OrchestrationOptions,
-  OrchestrationResult
-} from './orchestration.ts';
-import { prepareCodexOrchestrationDelegation } from './codex-orchestration.ts';
+import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
 import {
   applyTaskFinalization,
   type TaskFinalizationRequest,
@@ -39,12 +35,10 @@ import {
   type TaskLifecycleRequest,
   type TaskLifecycleResult
 } from './lifecycle.ts';
-import {
-  recoverStartedLifecycleUnderLock,
-  recoveryFailure,
-  type LifecycleRecoveryResult
-} from './lifecycle-recovery.ts';
-import type { LifecycleRecoveryRequest } from './lifecycle-recovery.ts';
+import type {
+  AgentClientLifecycleRecoveryRequest as LifecycleRecoveryRequest,
+  AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult
+} from '../agent-clients/adapter.ts';
 import { locateActivityLog } from './activity-log.ts';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
@@ -542,7 +536,6 @@ export type TaskControlExecutionContext =
       generation: string;
       manifestPath: string;
       requestId: string;
-      diagnosticLog?: OrchestrationDiagnosticLogger;
       controllerBinding?: TaskControlControllerBinding | null;
       lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
     }>;
@@ -631,7 +624,6 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
   generation: string;
   manifestPath: string;
   requestId: string;
-  diagnosticLog?: OrchestrationDiagnosticLogger;
   controllerBinding?: TaskControlControllerBinding | null;
   lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
 }>): TaskControlExecutionContext {
@@ -652,7 +644,6 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
     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
@@ -697,11 +688,7 @@ function domainOptions(
 ): OrchestrationOptions {
   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
   };
 }
 
@@ -725,7 +712,17 @@ async function applyLifecycleWithAuthority(
   }
   const execute = async (): Promise<(TaskLifecycleResult | LifecycleRecoveryResult) & { humanOverride?: unknown }> => {
     if (request.intent === 'recover-started') {
-      return recoverStartedLifecycleUnderLock(request as LifecycleRecoveryRequest, { 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 as LifecycleRecoveryRequest, { repoRoot: context.repoRoot });
     }
     const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
     if (lifecycleResult.status !== 'failed' || !request.overrideTicket) return lifecycleResult;
@@ -761,7 +758,12 @@ async function applyLifecycleWithAuthority(
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;
     if (request.intent === 'recover-started') {
-      return recoveryFailure(request as LifecycleRecoveryRequest, '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);
   }
@@ -789,17 +791,13 @@ function orchestration(
         client: input.client as AgentClientId,
         requestedModel: input.requestedModel as string | undefined,
         requestedReasoningEffort: input.requestedReasoningEffort as string | undefined,
-        ...(input.capabilityRef === undefined ? {} : { capabilityRef: input.capabilityRef as string }),
-        ...(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);
@@ -904,7 +902,7 @@ function operationInvalid(message: string): never {
 
 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']);
@@ -912,10 +910,10 @@ 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(
@@ -926,7 +924,7 @@ function parseValues(
   const values: Record<string, string | boolean> = {};
   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) operationInvalid(`duplicate option '${flag}'`);
       values[flag] = true;
@@ -984,28 +982,18 @@ export function parseTaskControlOperation(
       ...(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');
-      }
-    } else if (values['--stage'] !== undefined || values['--round'] !== undefined || values['--artifact'] !== undefined) {
-      operationInvalid('--stage, --round, and --artifact are only supported for recover-started');
+      if (values['--auto'] !== true) operationInvalid('--auto is required for recover-started');
+      return { family, request: input as unknown as TaskLifecycleControlRequest };
+    } else if (values['--auto'] !== undefined) {
+      operationInvalid('--auto is only supported for recover-started');
     }
     return { family, request: input as unknown as TaskLifecycleControlRequest };
   }
@@ -1049,7 +1037,6 @@ export function parseTaskControlOperation(
   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']);
@@ -1099,8 +1086,5 @@ export function parseTaskControlOperation(
     if (recoverable !== 'true' && recoverable !== 'false') operationInvalid('--recoverable must be true or false');
     input.code = value(values, '--code'); 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 };
 }