@fitlab-ai/agent-infra 0.11.2 → 0.11.4

package/lib/sandbox/control/executor.ts

@@ -31,12 +31,8 @@ import {
   createSandboxExecutorExecutionContext,
   dispatchTaskControlOperation,
   parseTaskControlOperation,
-  validateLifecycleRecoveryAttestation,
-  type LifecycleAuthorityResponseV1,
-  type LifecycleRecoveryAttestationV1,
   type TaskControlOperation
 } from '../../task/control-authority.ts';
-import { executeTaskWorkflow } from './workflow-executor.ts';
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest, type BrokerOwner } from './lifecycle.ts';
 import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.ts';
 import {
@@ -45,7 +41,6 @@ import {
   openCodexControllerRegistration,
   resolveCodexControllerBinding
 } from './controller-registration.ts';
-import type { OrchestrationDiagnosticLogger } from '../../task/orchestration.ts';
 
 export type SandboxControlExecutionResult = {
   exitCode: number;
@@ -127,7 +122,6 @@ export async function prepareSandboxControlExecution(params: {
   request: SandboxControlRequest;
   requestPath: string;
   internalCliPath: string;
-  lifecycleAuthority?: LifecycleAuthorityResponseV1;
 }): Promise<PreparedSandboxControlExecution> {
   const nonce = randomUUID();
   const child = spawn(
@@ -181,17 +175,11 @@ export async function prepareSandboxControlExecution(params: {
       if (!canWrite()) throw new Error('SANDBOX_CONTROL_OWNER_LOST');
       atomicWriteJson(executionPath(params.manifest, params.request.id), { ...execution, phase: 'running', updatedAt: Date.now() });
       if (!canWrite()) throw new Error('SANDBOX_CONTROL_OWNER_LOST');
-      const authority = params.lifecycleAuthority?.attestation ?? null;
       child.send({
         version: 2,
         nonce,
         owner: gateOwner,
-        requestId: params.request.id,
-        operationId: authority?.operationId ?? params.request.id,
-        phase: authority?.phase ?? (params.request.family === 'task-workflow'
-          && params.request.workflow?.operation === 'artifact-preflight' ? 'artifact.preflight'
-          : params.request.family === 'task-workflow' ? 'artifact.finalize-local' : 'orchestration.prepare'),
-        authority
+        requestId: params.request.id
       } satisfies SandboxControlExecutorGateV2);
     },
     completion,
@@ -206,7 +194,7 @@ export async function prepareSandboxControlExecution(params: {
   };
 }
 
-function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner: BrokerOwner; authority: LifecycleRecoveryAttestationV1 | null; requestId: string; operationId: string; phase: SandboxControlExecutorGateV2['phase'] }>> {
+function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner: BrokerOwner; requestId: string }>> {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => reject(new Error('SANDBOX_CONTROL_EXECUTOR_GATE_TIMEOUT')), timeoutMs);
     const onDisconnect = () => {
@@ -222,12 +210,9 @@ function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner
         nonce?: unknown;
         owner?: Partial<BrokerOwner> | null;
         requestId?: unknown;
-        operationId?: unknown;
-        phase?: unknown;
-        authority?: unknown;
       } | null;
       const owner = value?.owner;
-      if (!value || Object.keys(value).sort().join(',') !== 'authority,nonce,operationId,owner,phase,requestId,version'
+      if (!value || Object.keys(value).sort().join(',') !== 'nonce,owner,requestId,version'
         || value.version !== 2 || value.nonce !== nonce
         || !owner || owner.version !== 3 || !Number.isSafeInteger(owner.pid) || (owner.pid ?? 0) <= 0
         || typeof owner.startTime !== 'number' || !Number.isSafeInteger(owner.startTime)
@@ -236,20 +221,13 @@ function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner
         reject(new Error('SANDBOX_CONTROL_EXECUTOR_GATE_INVALID'));
         return;
       }
-      if (typeof value.requestId !== 'string' || typeof value.operationId !== 'string'
-        || !['orchestration.prepare', 'artifact.preflight', 'artifact.finalize-local', 'task-event.completed'].includes(value.phase as string)
-        || (value.authority !== null && value.authority !== undefined && (() => {
-          try { validateLifecycleRecoveryAttestation(value.authority); return false; } catch { return true; }
-        })())) {
+      if (typeof value.requestId !== 'string') {
         reject(new Error('SANDBOX_CONTROL_EXECUTOR_GATE_INVALID'));
         return;
       }
       resolve({
         owner: owner as BrokerOwner,
-        authority: value.authority === null || value.authority === undefined ? null : value.authority as LifecycleRecoveryAttestationV1,
-        requestId: value.requestId,
-        operationId: value.operationId,
-        phase: value.phase as SandboxControlExecutorGateV2['phase']
+        requestId: value.requestId
       });
     });
   });
@@ -273,17 +251,6 @@ function controllerFailure(error: unknown): SandboxControlExecutionResult {
   return { exitCode: 1, stdout: `${JSON.stringify(payload)}\n`, stderr: '' };
 }
 
-function orchestrationFailure(code: string, message: string): SandboxControlExecutionResult {
-  return {
-    exitCode: 1,
-    stdout: `${JSON.stringify({
-      status: 'failed', changed: false, taskId: null, run: null, next: null,
-      error: { code, message }
-    })}\n`,
-    stderr: ''
-  };
-}
-
 function lifecycleFailure(code: string, message: string): SandboxControlExecutionResult {
   return {
     exitCode: 1,
@@ -330,7 +297,6 @@ function finalizationResult(result: Awaited<ReturnType<typeof applyTaskFinalizat
 type ExecuteRequestOptions = Readonly<{
   buildIdentity?: typeof computeLifecycleBuildIdentity;
   resolveControllerBinding?: typeof resolveCodexControllerBinding;
-  lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
 }>;
 
 async function executeRequestInner(
@@ -406,7 +372,6 @@ async function executeRequestInner(
       return controllerFailure(error);
     }
   }
-  if (request.family === 'task-workflow') return executeTaskWorkflow(manifest, request.workflow, options.lifecycleRecoveryAttestation ?? null);
   if (request.family === 'task-finalization') {
     const operation = parseTaskControlOperation(
       'task-finalization', [manifest.taskId!, 'complete', '--agent', request.agent]
@@ -420,35 +385,21 @@ async function executeRequestInner(
         taskId: manifest.taskId!,
         generation: manifest.generation,
         manifestPath,
-        requestId: request.id,
-        lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
+        requestId: request.id
       }),
       operation
     );
     return finalizationResult(await result);
   }
   const boundArgs = bindSandboxControlTask(request, manifest.taskId!);
-  if (request.family === 'task-orchestration') {
-    boundArgs.push('--git-worktree-root', manifest.worktreeRoot);
-  }
   let operation: TaskControlOperation;
   try {
     operation = parseTaskControlOperation(request.family, boundArgs);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const code = /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'TASK_CONTROL_OPERATION_INVALID';
-    return request.family === 'task-lifecycle'
-      ? lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', message)
-      : orchestrationFailure(code, message);
+    return lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', `${code}: ${message}`);
   }
-  const diagnosticLog: OrchestrationDiagnosticLogger = (event, fields): void => {
-    appendExecutorAudit(manifest, event.startsWith('orchestration-') ? event : `orchestration-${event}`, {
-      requestId: request.id,
-      requestFamily: request.family,
-      sandboxTaskId: manifest.taskId,
-      ...fields
-    });
-  };
   const context = createSandboxExecutorExecutionContext({
     repoRoot: manifest.repoRoot,
     worktreeRoot: manifest.worktreeRoot,
@@ -456,9 +407,7 @@ async function executeRequestInner(
     taskId: manifest.taskId!,
     generation: manifest.generation,
     manifestPath,
-    requestId: request.id,
-    diagnosticLog,
-    lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
+    requestId: request.id
   });
   const format = (value: unknown): SandboxControlExecutionResult => {
     const result = value as { status?: string };
@@ -468,12 +417,8 @@ async function executeRequestInner(
       stderr: ''
     };
   };
-  if (request.family === 'task-orchestration') {
-    if (operation.family !== 'task-orchestration') throw new Error('SANDBOX_CONTROL_ORCHESTRATION_OPERATION_INVALID');
-    return format(await dispatchTaskControlOperation(context, operation));
-  }
   if (operation.family !== 'task-lifecycle') throw new Error('SANDBOX_CONTROL_LIFECYCLE_OPERATION_INVALID');
-    return format(await dispatchTaskControlOperation(context, operation));
+  return format(await dispatchTaskControlOperation(context, operation));
 }
 
 export async function executeRequest(
@@ -535,12 +480,6 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
   const raw = JSON.parse(fs.readFileSync(requestPath, 'utf8')) as unknown;
   const request = validateSandboxControlRequest(raw, manifest);
   if (gate.requestId !== request.id) throw new Error('SANDBOX_CONTROL_EXECUTOR_GATE_REQUEST_MISMATCH');
-  if (gate.authority !== null
-    && (gate.authority.requestId !== request.id
-      || gate.authority.operationId !== gate.operationId
-      || gate.authority.phase !== gate.phase)) {
-    throw new Error('SANDBOX_CONTROL_EXECUTOR_GATE_AUTHORITY_MISMATCH');
-  }
   appendExecutorAudit(manifest, 'executor-request-validated', requestAuditFields(manifest, request));
   const requestDirectory = path.resolve(path.dirname(requestPath));
   const processingDirectory = path.resolve(path.join(manifest.processingDir, request.id));
@@ -558,7 +497,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
   let result: SandboxControlExecutionResult;
   try {
     assertSandboxControlExecutorAuthority(manifest, gateOwner);
-    const operation = request.family === 'task-lifecycle' || request.family === 'task-orchestration'
+    const operation = request.family === 'task-lifecycle'
       ? (() => {
         try { return parseTaskControlOperation(request.family, request.args); } catch { return null; }
       })()
@@ -566,10 +505,8 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
     const context = createSandboxControlAuditContext(manifest, {
       requestId: request.id,
       family: request.family,
-      operation: operation?.family === 'task-orchestration'
-        ? operation.intent
-        : operation?.family === 'task-lifecycle'
-          ? operation.request.intent
+      operation: operation?.family === 'task-lifecycle'
+        ? operation.request.intent
           : request.family === 'task-finalization' ? request.operation : null,
       phase: 'started-committed',
       outcome: 'in-progress'
@@ -578,9 +515,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
     writeSandboxControlTransition(manifest, { requestId: request.id, phase: 'started-committed' });
     const execution = readJsonExecution(executionPath(manifest, request.id));
     atomicWriteJson(executionPath(manifest, request.id), { ...execution, phase: 'running', updatedAt: Date.now() });
-    result = await executeRequest(manifest, manifestPath, request, {
-      lifecycleRecoveryAttestation: gate.authority
-    });
+    result = await executeRequest(manifest, manifestPath, request);
   } catch (error) {
     appendExecutorAudit(manifest, 'executor-authority-or-dispatch-failed', {
       ...requestAuditFields(manifest, request),
@@ -599,9 +534,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
       }
       : request.family === 'task-create'
         ? taskCreateExecutionFailure(request.id, code, detail)
-        : request.family === 'task-lifecycle'
-        ? lifecycleFailure(code, detail)
-        : orchestrationFailure(code, detail);
+        : lifecycleFailure(code, detail);
   }
   process.stdout.write(result.stdout);
   process.stderr.write(result.stderr);

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');