@fitlab-ai/agent-infra 0.11.2 → 0.11.3

package/lib/sandbox/control/protocol.ts

@@ -5,12 +5,6 @@ import type { ProcessIdentity } from '../../server/process-state.ts';
 import type { CodexControllerLeaseProofV1 } from './controller-registration.ts';
 import type { SandboxAuthorityEvidenceV1 } from '../engines/authority.ts';
 import type { SandboxTaskView } from './task-view.ts';
-import { validateTaskWorkflowRequest, type TaskWorkflowRequest } from './task-workflow.ts';
-import {
-  validateLifecycleAuthorityRequest,
-  type LifecycleAuthorityRequestV1,
-  type LifecycleRecoveryAttestationV1
-} from '../../task/control-authority.ts';
 
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
 export const SANDBOX_CONTROL_MAX_LOGICAL_RECORDS = 1024;
@@ -21,7 +15,7 @@ export const SANDBOX_CONTROL_ADMISSION_WINDOW_MS = 2_000;
 export const SANDBOX_CONTROL_STATUS_INTERVAL_MS = 250;
 export const SANDBOX_CONTROL_STATUS_STALE_MS = 1_500;
 export const SANDBOX_CONTROL_FUTURE_SKEW_MS = 1_000;
-export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-orchestration', 'task-finalization', 'task-create', 'codex-controller', 'task-workflow'] as const;
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-finalization', 'task-create', 'codex-controller'] as const;
 export type SandboxControlTimingPolicy = Readonly<{
   controlTickMs: number;
   parkedBindingInitialMs: number;
@@ -61,9 +55,6 @@ export type SandboxControlExecutorGateV2 = Readonly<{
   nonce: string;
   owner: SandboxControlBrokerOwner;
   requestId: string;
-  operationId: string;
-  phase: 'orchestration.prepare' | 'artifact.preflight' | 'artifact.finalize-local' | 'task-event.completed';
-  authority: LifecycleRecoveryAttestationV1 | null;
 }>;
 type RequestBase = Readonly<{
   version: 3; id: string; token: string; generation: string; issuedAt: number; expiresAt: number;
@@ -71,8 +62,7 @@ type RequestBase = Readonly<{
   controllerProof: CodexControllerLeaseProofV1 | null;
 }>;
 export type SandboxTaskCommandRequest = RequestBase & Readonly<{
-  family: 'task-lifecycle' | 'task-orchestration'; args: string[];
-  authority?: LifecycleAuthorityRequestV1;
+  family: 'task-lifecycle'; args: string[];
 }>;
 export type SandboxTaskFinalizationRequest = RequestBase & Readonly<{
   family: 'task-finalization'; operation: 'complete'; agent: string; args: [];
@@ -85,13 +75,7 @@ export type SandboxCodexControllerRequest = RequestBase & Readonly<{
   command: 'open' | 'close' | 'verify';
   args: [];
 }>;
-export type SandboxTaskWorkflowRequest = RequestBase & Readonly<{
-  family: 'task-workflow';
-  args: [];
-  workflow: TaskWorkflowRequest;
-  authority?: LifecycleAuthorityRequestV1;
-}>;
-export type SandboxControlRequest = SandboxTaskCommandRequest | SandboxTaskFinalizationRequest | SandboxTaskCreateRequest | SandboxCodexControllerRequest | SandboxTaskWorkflowRequest;
+export type SandboxControlRequest = SandboxTaskCommandRequest | SandboxTaskFinalizationRequest | SandboxTaskCreateRequest | SandboxCodexControllerRequest;
 export type SandboxControlError = Readonly<{ code: string; message: string; retryable: boolean }>;
 export type SandboxControlResultEvidence = Readonly<{
   version: 1;
@@ -131,11 +115,6 @@ export type SandboxControlResponse = Readonly<{
   outputState?: 'available' | 'unavailable';
   payload?: SandboxControlPayloadReference | null;
 }>;
-export type SandboxControlRecoveryWarning = Readonly<{
-  code: string;
-  message: string;
-  action: string;
-}>;
 export type SandboxControlStatus = Readonly<{
   version: 3; generation: string; broker: ProcessIdentity & { brokerId: string };
   state: 'starting' | 'healthy' | 'busy' | 'parked'; reasonCode: string | null;
@@ -313,25 +292,8 @@ export function validateSandboxControlRequest(
     }
     return request as SandboxTaskFinalizationRequest;
   }
-  if (request.family === 'task-workflow') {
-    const expected = ['args', 'authority', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version', 'workflow'];
-    const baseExpected = expected.filter((key) => key !== 'authority');
-    if (![baseExpected, expected].some((keys) => Object.keys(request).sort().join(',') === keys.sort().join(','))
-      || !Array.isArray(request.args) || request.args.length !== 0
-      || request.controllerProcess !== null || request.controllerProof !== null) {
-      fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-workflow request schema is invalid');
-    }
-    if (manifest.mode !== 'task-bound' || !manifest.taskId) fail('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot use task-workflow');
-    const workflow = validateTaskWorkflowRequest(request.workflow);
-    if (workflow.taskId !== manifest.taskId || workflow.generation !== manifest.generation || workflow.id !== request.id) {
-      fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-workflow binding does not match the sandbox manifest');
-    }
-    if (request.authority !== undefined) validateAuthoritySelector(request.authority, request, manifest);
-    return { ...request, workflow } as SandboxTaskWorkflowRequest;
-  }
-  const expected = ['args', 'authority', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
-  const baseExpected = expected.filter((key) => key !== 'authority');
-  if (![baseExpected, expected].some((keys) => Object.keys(request).sort().join(',') === keys.sort().join(','))
+  const expected = ['args', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
+  if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
     || !Array.isArray(request.args) || !request.args.every((arg) => typeof arg === 'string')) {
     fail('SANDBOX_CONTROL_REQUEST_INVALID', 'request schema or authorization is invalid');
   }
@@ -341,52 +303,14 @@ export function validateSandboxControlRequest(
       "branch-only sandboxes cannot coordinate tasks; return to the host and run 'ai sandbox start --recreate <task-ref-or-correct-branch>'"
     );
   }
-  if (request.family === 'task-orchestration'
-    && request.args.some((arg) => arg === '--git-worktree-root' || arg.startsWith('--git-worktree-root='))) {
-    fail('SANDBOX_CONTROL_REQUEST_INVALID', 'worktree binding is reserved for the control broker');
-  }
-  if (request.controllerProcess !== null
-    || (request.controllerProof !== null && !validControllerProof(request.controllerProof))) {
+  if (request.controllerProcess !== null || request.controllerProof !== null) {
     fail('SANDBOX_CONTROL_REQUEST_INVALID', 'controller authority is invalid');
   }
-  if (request.family !== 'task-orchestration' && request.controllerProof !== null) {
-    fail('SANDBOX_CONTROL_REQUEST_INVALID', 'controller proof is not allowed for this family');
-  }
-  if (request.authority !== undefined) validateAuthoritySelector(request.authority, request, manifest);
   return request as SandboxTaskCommandRequest;
 }
 
-function validateAuthoritySelector(
-  value: unknown,
-  request: Record<string, unknown>,
-  manifest: SandboxControlManifest
-): asserts value is LifecycleAuthorityRequestV1 {
-  let authority: LifecycleAuthorityRequestV1;
-  try { authority = validateLifecycleAuthorityRequest(value); }
-  catch { fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'lifecycle authority selector is invalid'); }
-  if (authority.requestId !== request.id
-    || authority.taskId !== manifest.taskId
-    || authority.expectedControlGeneration !== manifest.generation) {
-    fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'lifecycle authority selector is not bound to this request');
-  }
-  const args = Array.isArray(request.args) ? request.args : [];
-  if (request.family === 'task-orchestration'
-    && (args[1] !== 'prepare' || authority.phase !== 'orchestration.prepare')) {
-    fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'orchestration authority is only valid for prepare');
-  }
-  const workflow = request.workflow as TaskWorkflowRequest | undefined;
-  if (request.family === 'task-workflow') {
-    const expectedPhase = workflow?.operation === 'artifact-finalize-local'
-      ? 'artifact.finalize-local'
-      : workflow?.operation === 'event' ? 'task-event.completed' : null;
-    if (authority.phase !== expectedPhase) {
-      fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'workflow authority phase does not match the workflow operation');
-    }
-  }
-}
-
 export function bindSandboxControlTask(request: SandboxControlRequest, taskId: string): string[] {
-  if (request.family === 'task-create' || request.family === 'codex-controller' || request.family === 'task-finalization' || request.family === 'task-workflow') {
+  if (request.family === 'task-create' || request.family === 'codex-controller' || request.family === 'task-finalization') {
     fail('SANDBOX_CONTROL_REQUEST_INVALID', `${request.family} requests do not bind a current task`);
   }
   if (request.args.length === 0) fail('SANDBOX_CONTROL_REQUEST_INVALID', 'command arguments are required');

package/lib/sandbox/control/server.ts

@@ -1,5 +1,4 @@
 import { finalizationTerminalResponse } from './finalization-response.ts';
-import { isDeepStrictEqual } from 'node:util';
 import { completedReentryView } from './completed-reentry.ts';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -12,7 +11,6 @@ import {
   SANDBOX_CONTROL_MAX_RESPONSE_BYTES,
   SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES,
   type SandboxControlManifest,
-  type SandboxControlRecoveryWarning,
   type SandboxControlRequest,
   type SandboxControlResponse,
   type SandboxControlTimingPolicy
@@ -62,10 +60,6 @@ import {
   operationRecoveryBinding,
   SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES
 } from '../../task/control-recovery.ts';
-import { readRun } from '../../task/orchestration.ts';
-import { readLifecycleRecoveryDomainEvidence } from '../../task/lifecycle-recovery.ts';
-import { captureRepositorySnapshot } from '../../task/workspace-snapshot.ts';
-import { parseTypedTaskFrontmatter } from '../../task/frontmatter.ts';
 import { readLifecycleJournalEvidence } from '../../task/lifecycle.ts';
 import { resolveTaskRef } from '../../task/resolve-ref.ts';
 import { loadShortIdByTaskId } from '../../task/short-id.ts';
@@ -88,70 +82,16 @@ import {
   type SandboxTaskView
 } from './task-view.ts';
 import { taskCreateOutputUnavailableResult } from '../../task/create-service.ts';
-import {
-  consumeLifecycleRecoveryAttestation,
-  issueLifecycleRecoveryAttestation,
-  recoverLifecycleRecoveryOperation,
-  type LifecycleAuthorityResponseV1
-} from '../../task/control-authority.ts';
-import { createCodexCapabilityStore } from '../../agent-clients/adapters/codex-lifecycle/capability-store.ts';
-import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.ts';
 
 type ActiveExecution = {
   request: SandboxControlRequest;
   prepared: PreparedSandboxControlExecution;
-  lifecycleAuthority: LifecycleAuthorityResponseV1 | undefined;
   result: SandboxControlExecutionResult | null;
   resultEvidenceWritten: boolean;
   failure: unknown;
   settled: boolean;
 };
 
-function consumeLifecycleAuthorityForResult(
-  manifest: SandboxControlManifest,
-  execution: ActiveExecution
-): boolean {
-  const authority = execution.lifecycleAuthority?.attestation;
-  if (!authority || execution.result?.exitCode !== 0) return true;
-  try {
-    consumeLifecycleRecoveryAttestation(authority);
-    return true;
-  } catch (error) {
-    appendBrokerAudit(manifest, 'lifecycle-authority-consume-retry', {
-      ...requestAuditFields(manifest, execution.request),
-      errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_CONSUME_FAILED'
-    });
-    return false;
-  }
-}
-
-function lifecycleAuthorityForRequest(
-  manifest: SandboxControlManifest,
-  manifestPath: string,
-  request: SandboxControlRequest
-): LifecycleAuthorityResponseV1 | undefined {
-  const selector = request.family === 'task-workflow' || request.family === 'task-orchestration'
-    ? request.authority
-    : undefined;
-  if (!selector) return undefined;
-  let controllerBinding: { instanceDigest: string; controlGeneration: string } | null = null;
-  try {
-    const registration = readCodexControllerRegistration(manifestPath);
-    controllerBinding = {
-      instanceDigest: registration.controllerInstanceDigest,
-      controlGeneration: registration.controlGeneration
-    };
-  } catch {
-    // The issuer reports the stable unavailable result; the broker never trusts
-    // a controller binding supplied by the request.
-  }
-  return issueLifecycleRecoveryAttestation(selector, {
-    controllerBinding,
-    capabilityStore: createCodexCapabilityStore(),
-    buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot)
-  });
-}
-
 function appendBrokerAudit(
   manifest: SandboxControlManifest,
   event: string,
@@ -160,38 +100,21 @@ function appendBrokerAudit(
   appendDiagnosticAudit(manifest, event, { source: 'broker', ...fields });
 }
 
-function operationKey(request: SandboxControlRequest, output?: string): string | null {
+function operationKey(request: SandboxControlRequest): string | null {
   if (request.family === 'task-finalization') return request.operation;
   if (request.family === 'task-create') return 'create';
   if (request.family === 'codex-controller') return request.command;
-  if (request.family === 'task-workflow') return request.workflow.operation;
-  if (request.family !== 'task-lifecycle' && request.family !== 'task-orchestration') return null;
-  if (request.family === 'task-orchestration' && request.args[1] === 'route') {
-    if (!output) return 'route';
-    const result = parseControlOutput(output);
-    return result?.changed === true && result.status === 'completed' ? 'route.clean-completion' : 'route.read';
-  }
+  if (request.family !== 'task-lifecycle') return null;
   try {
     const operation = parseTaskControlOperation(request.family, request.args);
-    return operation.family === 'task-orchestration' ? operation.intent : operation.request.intent;
+    return operation.family === 'task-lifecycle' ? operation.request.intent : null;
   } catch {
     return null;
   }
 }
 
-function recoveryOperationKey(
-  request: SandboxControlRequest,
-  terminalResult: ReturnType<typeof readSandboxControlTerminalResult> | null,
-  output: string | undefined
-): string | null {
-  const operation = operationKey(request, output);
-  if (operation !== 'route') return operation;
-  const digest = terminalResult?.intentDigest;
-  for (const candidate of ['route.read', 'route.clean-completion'] as const) {
-    const expected = operationRecoveryBinding(request.id, request.generation, null, request.family, candidate).intentDigest;
-    if (digest === expected) return candidate;
-  }
-  return null;
+function recoveryOperationKey(request: SandboxControlRequest): string | null {
+  return operationKey(request);
 }
 
 function terminalResultMatchesRequest(
@@ -199,9 +122,7 @@ function terminalResultMatchesRequest(
   terminalResult: ReturnType<typeof readSandboxControlTerminalResult>
 ): boolean {
   const operation = operationKey(request);
-  const candidates = operation === 'route'
-    ? ['route.read', 'route.clean-completion']
-    : operation ? [operation] : [];
+  const candidates = operation ? [operation] : [];
   return candidates.some((candidate) => createHash('sha256').update(`${request.family}\0${candidate}`, 'utf8').digest('hex') === terminalResult.intentDigest);
 }
 
@@ -374,8 +295,7 @@ export function genericRecoveryResponse(
   request: SandboxControlRequest,
   exitCode: number,
   payload: ReturnType<typeof readSandboxControlPayload> | null,
-  cause: 'publish' | 'recovery' = 'recovery',
-  warning: SandboxControlRecoveryWarning | null = null
+  cause: 'publish' | 'recovery' = 'recovery'
 ): SandboxControlResponse {
   const outputUnavailable = request.family === 'task-create' && !payload;
   return {
@@ -384,9 +304,7 @@ export function genericRecoveryResponse(
     phase: 'completed',
     exitCode,
     stdout: outputUnavailable ? `${JSON.stringify(taskCreateOutputUnavailableResult(request.id))}\n` : '',
-    stderr: payload ? '' : warning
-      ? `${warning.code}: ${warning.message}\nAction: ${warning.action}\n`
-      : cause === 'publish'
+    stderr: payload ? '' : cause === 'publish'
         ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
         : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
     error: null,
@@ -465,42 +383,16 @@ function controllerDomainEvidence(
   }
 }
 
-function orchestrationDomainEvidence(
-  operation: ReturnType<typeof findSandboxControlRecoveryOperation>,
-  terminalResult: ReturnType<typeof readSandboxControlTerminalResult>,
-  output: Record<string, unknown> | null,
-  run: ReturnType<typeof readRun> | null
-): Readonly<Record<string, unknown>> {
-  if (!operation || !output) return { consistent: false };
-  const outputRun = output.run && typeof output.run === 'object' && !Array.isArray(output.run)
-    ? output.run as Record<string, unknown> : null;
-  const runMatches = outputRun === null ? run === null : run !== null && JSON.stringify(run) === JSON.stringify(outputRun);
-  if (operation.class === 'read-only') {
-    return {
-      consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
-      snapshotValid: true,
-      status: run?.status ?? terminalResult.status,
-      pendingDelegation: run?.pendingDelegation ?? null
-    };
-  }
-  if (!run || !outputRun) return { consistent: false };
-  return {
-    consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
-    status: run.status,
-    pendingDelegation: run.pendingDelegation
-  };
-}
-
-function readRecoveryDomain(
+async function readRecoveryDomain(
   manifest: SandboxControlManifest,
   manifestPath: string,
   request: SandboxControlRequest,
   operation: ReturnType<typeof findSandboxControlRecoveryOperation>,
   terminalResult: ReturnType<typeof readSandboxControlTerminalResult>,
   payloadOutput: string | null
-): RecoveryDomainEvidence {
+): Promise<RecoveryDomainEvidence> {
   if (!operation) return { domain: null };
-  const taskRef = request.family === 'task-finalization' || request.family === 'task-workflow'
+  const taskRef = request.family === 'task-finalization'
     ? manifest.taskId
     : 'args' in request ? request.args[0] ?? null : manifest.taskId;
   const output = parseControlOutput(payloadOutput);
@@ -510,19 +402,7 @@ function readRecoveryDomain(
 
   if (operation.family === 'task-lifecycle') {
     if (operation.intent === 'recover-started') {
-      try {
-        if (!('args' in request)) return { domain: null };
-        const parsed = parseTaskControlOperation('task-lifecycle', request.args);
-        if (parsed.family !== 'task-lifecycle' || parsed.request.intent !== 'recover-started') {
-          return { domain: null };
-        }
-        return {
-          domain: readLifecycleRecoveryDomainEvidence(manifest.repoRoot, parsed.request, terminalResult),
-          journal: readLifecycleJournalEvidence(manifest.repoRoot, taskRef!)
-        };
-      } catch {
-        return { domain: null };
-      }
+      return { domain: null };
     }
     if (!taskRef || !terminalResult.targetState) return { domain: null };
     const journal = readLifecycleJournalEvidence(manifest.repoRoot, taskRef);
@@ -541,48 +421,12 @@ function readRecoveryDomain(
     }
   }
 
-  if (operation.family === 'task-orchestration') {
-    if (!taskRef) return { domain: null };
-    try {
-      const resolved = resolveTaskRef(taskRef, { repoRoot: manifest.repoRoot });
-      if (!resolved.ok) return { domain: { consistent: false } };
-      const run = readRun(resolved.taskDir);
-      if (!run && operation.class !== 'read-only') return { domain: { consistent: false } };
-      if (operation.class === 'route.clean-completion') {
-        const snapshot = captureRepositorySnapshot(manifest.repoRoot);
-        const metadata = parseTypedTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
-        const completion = run?.completionEvidence ?? null;
-        const consistent = run !== null && completion !== null
-          && terminalResult.completionEvidence !== null
-          && isDeepStrictEqual(completion, terminalResult.completionEvidence);
-        return {
-          domain: {
-            consistent,
-            status: run?.status ?? null,
-            pendingDelegation: run?.pendingDelegation ?? null,
-            completionEvidence: completion,
-            snapshot,
-            lastReviewedCommit: metadata.last_reviewed_commit
-          }
-        };
-      }
-      return { domain: orchestrationDomainEvidence(operation, terminalResult, output, run) };
-    } catch {
-      return { domain: { consistent: false } };
-    }
-  }
-
   if (operation.family === 'task-create') {
     return { domain: taskCreateDomainEvidence(manifest, output) };
   }
   if (operation.family === 'codex-controller') {
     return { domain: controllerDomainEvidence(manifest, manifestPath, request, output) };
   }
-  if (operation.family === 'task-workflow') {
-    return {
-      domain: { consistent: output?.status === terminalResult.status && output.changed === terminalResult.changed, snapshotValid: true }
-    };
-  }
   return { domain: null };
 }
 
@@ -597,15 +441,15 @@ function readCommittedCriticalPhases(manifest: SandboxControlManifest, requestId
   });
 }
 
-export function recoveryResponse(
+export async function recoveryResponse(
   manifest: SandboxControlManifest,
   manifestPath: string,
   request: SandboxControlRequest,
   evidence: ReturnType<typeof readSandboxControlResultEvidence>,
   payload: ReturnType<typeof readSandboxControlPayload> | null,
   terminalResult: ReturnType<typeof readSandboxControlTerminalResult>
-): SandboxControlResponse | null {
-  const operationName = recoveryOperationKey(request, terminalResult, payload?.stdout);
+): Promise<SandboxControlResponse | null> {
+  const operationName = recoveryOperationKey(request);
   const operation = operationName ? findSandboxControlRecoveryOperation(request.family, operationName) : null;
   if (!operation) return null;
   if (payload) {
@@ -616,30 +460,9 @@ export function recoveryResponse(
   }
   const finalization = request.family === 'task-finalization' ? finalizationRecoveryResponse(manifest, request.id, 0) : null;
   if (evidence.exitCode === 0 && finalization?.status === 'deferred') return null;
-  if (evidence.exitCode === 0 && request.family === 'task-workflow' && request.authority?.phase === 'task-event.completed') {
-    try {
-      const registration = readCodexControllerRegistration(manifestPath);
-      const recovered = recoverLifecycleRecoveryOperation(request.authority, {
-        repoRoot: manifest.repoRoot,
-        capabilityStore: createCodexCapabilityStore(),
-        buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot),
-        controllerBinding: {
-          instanceDigest: registration.controllerInstanceDigest,
-          controlGeneration: registration.controlGeneration
-        }
-      });
-      if (recovered.status !== 'committed') return null;
-    } catch (error) {
-      appendBrokerAudit(manifest, 'lifecycle-authority-recovery-failed', {
-        ...requestAuditFields(manifest, request),
-        errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_RECOVERY_FAILED'
-      });
-      return null;
-    }
-  }
   const recovery: RecoveryDomainEvidence = finalization
     ? { domain: { consistent: finalization.status === 'matched' } }
-    : readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
+    : await readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
   const binding = operationRecoveryBinding(request.id, manifest.generation, manifest.taskId, request.family, operationName!);
   const decision = classifySandboxControlRecovery({
     operation,
@@ -657,10 +480,10 @@ export function recoveryResponse(
     if (finalization?.status !== 'matched') return null;
     return finalization.response ?? null;
   }
-  return genericRecoveryResponse(request, evidence.exitCode, payload, 'recovery', terminalResult.warning ?? null);
+  return genericRecoveryResponse(request, evidence.exitCode, payload);
 }
 
-function terminalMatchesEvidence(
+async function terminalMatchesEvidence(
   manifest: SandboxControlManifest,
   manifestPath: string,
   request: SandboxControlRequest,
@@ -669,10 +492,10 @@ function terminalMatchesEvidence(
   payload: ReturnType<typeof readSandboxControlPayload> | null,
   payloadInvalid: boolean,
   terminalResult: ReturnType<typeof readSandboxControlTerminalResult> | null
-): { valid: boolean; payloadReferenced: boolean } {
+): Promise<{ valid: boolean; payloadReferenced: boolean }> {
   if (request.family === 'task-finalization' && evidence.exitCode === 0) {
     if (!terminalResult) return { valid: false, payloadReferenced: false };
-    const expected = recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult);
+    const expected = await recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult);
     return {
       valid: expected !== null && JSON.stringify(response) === JSON.stringify(expected),
       payloadReferenced: false
@@ -701,7 +524,7 @@ function terminalMatchesEvidence(
   if (response.outputState === 'unavailable') {
     const causes = ['recovery', 'publish'] as const;
     const valid = causes.some((cause) => JSON.stringify(response)
-      === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause, terminalResult?.warning ?? null)));
+      === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause)));
     return { valid, payloadReferenced: false };
   }
   return {
@@ -723,7 +546,7 @@ function publishExecutionResult(
   const terminalResult = writeSandboxControlTerminalResult(manifest, {
     id: request.id,
     family: request.family,
-    operation: operationKey(request, normalized.stdout)
+    operation: operationKey(request)
   }, normalized.stdout);
   if (fs.existsSync(path.join(manifest.processingDir, request.id, 'transitions'))) {
     criticalRequestPhase(manifest, request, 'completed', normalized.exitCode === 0 ? 'success' : 'failure');
@@ -757,7 +580,7 @@ function publishExecutionResult(
       } catch {
         payload = null;
       }
-      terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish', terminalResult.warning ?? null);
+      terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish');
     }
   }
   if (!brokerOwns()) return false;
@@ -848,7 +671,7 @@ function assertCurrentSandboxControlIdentity(manifest: SandboxControlManifest, m
   }
 }
 
-function recoverProcessing(manifest: SandboxControlManifest, manifestPath: string, broker: BrokerOwner, brokerOwns: () => boolean): boolean {
+async function recoverProcessing(manifest: SandboxControlManifest, manifestPath: string, broker: BrokerOwner, brokerOwns: () => boolean): Promise<boolean> {
   for (const entry of fs.readdirSync(manifest.processingDir, { withFileTypes: true })) {
     if (!entry.isDirectory() || !/^[a-f0-9-]{16,64}$/.test(entry.name)) continue;
     if (!brokerOwns()) return false;
@@ -955,7 +778,7 @@ function recoverProcessing(manifest: SandboxControlManifest, manifestPath: strin
       if (terminal && (!request || !resultEvidence)) continue;
       if (terminal && request && resultEvidence) {
         if (!terminalResult && request.family !== 'task-create') continue;
-        const reconciliation = terminalMatchesEvidence(
+        const reconciliation = await terminalMatchesEvidence(
           manifest,
           manifestPath,
           request,
@@ -989,7 +812,7 @@ function recoverProcessing(manifest: SandboxControlManifest, manifestPath: strin
       if (!terminal) {
         if (!brokerOwns()) return false;
         if (!resultEvidence || !request || payloadInvalid) continue;
-        const recovered = recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult!);
+        const recovered = await recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult!);
         if (!recovered) continue;
         if (request.family === 'task-finalization' && resultEvidence.exitCode === 0) {
           const view = publishFinalizationTaskView(manifest, broker, request.id, 'starting', null, null);
@@ -1140,7 +963,7 @@ export async function serveSandboxControl(
       pid: broker.pid,
       brokerId: broker.brokerId
     });
-    if (!recoverProcessing(manifest, manifestPath, broker, brokerOwns)) return;
+    if (!await recoverProcessing(manifest, manifestPath, broker, brokerOwns)) return;
     try {
       const published = readSandboxControlStatus(manifest.publicStatusDir);
       if (published.generation === manifest.generation) taskView = published.taskView;
@@ -1263,10 +1086,6 @@ export async function serveSandboxControl(
         if (!brokerOwns()) break;
         let terminalCommitted = false;
         if (settledExecution.result && settledExecution.resultEvidenceWritten) {
-          if (!consumeLifecycleAuthorityForResult(manifest, settledExecution)) {
-            active = settledExecution;
-            continue;
-          }
           terminalCommitted = publishExecutionResult(manifest, settledExecution.request, settledExecution.result, broker, brokerOwns);
           if (terminalCommitted && settledExecution.request.family === 'task-finalization') {
             try {
@@ -1351,17 +1170,9 @@ export async function serveSandboxControl(
             executorCwd: manifest.repoRoot,
             executorEntry: options.internalCliPath ?? process.argv[1] ?? null
           });
-          const lifecycleAuthority = lifecycleAuthorityForRequest(manifest, manifestPath, request);
-          if (lifecycleAuthority?.status === 'rejected') {
-            throw Object.assign(
-              new Error(lifecycleAuthority.error?.message ?? 'lifecycle authority was rejected'),
-              { code: lifecycleAuthority.error?.code ?? 'LIFECYCLE_AUTHORITY_REJECTED' }
-            );
-          }
           prepared = await prepareExecution({
             manifest, manifestPath, request, requestPath: claimed,
-            internalCliPath: options.internalCliPath ?? process.argv[1]!,
-            ...(lifecycleAuthority ? { lifecycleAuthority } : {})
+            internalCliPath: options.internalCliPath ?? process.argv[1]!
           });
           const preparedExecution = prepared;
           if (!preparedExecution) throw new Error('SANDBOX_CONTROL_EXECUTION_PREPARE_INVALID');
@@ -1376,7 +1187,7 @@ export async function serveSandboxControl(
             executionPath: executionPath(manifest, request.id)
           });
           const execution: ActiveExecution = {
-            request, prepared: preparedExecution, lifecycleAuthority, result: null,
+            request, prepared: preparedExecution, result: null,
             resultEvidenceWritten: false, failure: null, settled: false
           };
           active = execution;
@@ -1530,8 +1341,7 @@ export async function serveSandboxControl(
         }
       }
       if (owned && active.result && active.resultEvidenceWritten) {
-        if (consumeLifecycleAuthorityForResult(manifest, active)
-          && publishExecutionResult(manifest, active.request, active.result, broker, brokerOwns)) {
+        if (publishExecutionResult(manifest, active.request, active.result, broker, brokerOwns)) {
           if (brokerOwns()) {
             removeAcceptedResponse(manifest, active.request.id);
             fs.rmSync(path.join(manifest.processingDir, active.request.id), { recursive: true, force: true });

package/lib/sandbox/control/state.ts

@@ -1,6 +1,5 @@
 import { isCompletionEvidence, type CleanCompletionEvidence } from '../../task/orchestration.ts';
 import { parseControlOutput } from '../../task/control-recovery.ts';
-import { isRecoveryWarning } from '../../task/recovery-warning.ts';
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -15,7 +14,6 @@ import type {
   SandboxControlPayload,
   SandboxControlReservation,
   SandboxControlResultEvidence,
-  SandboxControlRecoveryWarning,
   SandboxControlStatus
 } from './protocol.ts';
 import {
@@ -115,7 +113,6 @@ export type SandboxControlTerminalResult = Readonly<{
   status: string;
   changed: boolean | null;
   completionEvidence: CleanCompletionEvidence | null;
-  warning?: SandboxControlRecoveryWarning | null;
 }>;
 
 export function terminalResultPath(manifest: SandboxControlManifest, requestId: string): string {
@@ -133,7 +130,6 @@ export function createSandboxControlTerminalResult(
     ? nested.run as Record<string, unknown> : null;
   const rawCompletion = nested.completionEvidence ?? run?.completionEvidence;
   const operation = request.operation ?? (typeof nested.intent === 'string' ? nested.intent : null) ?? '';
-  const warning = isRecoveryWarning(nested.warning) ? nested.warning : null;
   return {
     version: 1,
     requestId: request.id,
@@ -143,8 +139,7 @@ export function createSandboxControlTerminalResult(
     targetState: typeof nested.targetState === 'string' ? nested.targetState : null,
     status: typeof nested.status === 'string' ? nested.status : 'completed',
     changed: typeof nested.changed === 'boolean' ? nested.changed : null,
-    completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null,
-    ...(warning ? { warning } : {})
+    completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null
   };
 }
 
@@ -178,9 +173,6 @@ export function readSandboxControlTerminalResult(filePath: string): SandboxContr
   if (value.completionEvidence !== null && !isCompletionEvidence(value.completionEvidence)) {
     throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
   }
-  if (value.warning !== undefined && value.warning !== null && !isRecoveryWarning(value.warning)) {
-    throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
-  }
   if (value.changed === undefined) {
     throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
   }