@fitlab-ai/agent-infra 0.11.13 → 0.11.14

package/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller-cli.ts

@@ -1,109 +0,0 @@
-import {
-  runCodexSandboxController,
-  verifyCodexSandboxControllerContextWithWarnings
-} from './sandbox-controller.ts';
-import { ensureInternalHandlerRoute, internalHandlerRoute } from '../../../internal/cli-route-inventory.ts';
-
-const USAGE = 'Usage: agent-infra-internal codex-sandbox-controller <run|verify-context> [options]\n';
-
-function fail(code: string, message: string, exitCode = 1): void {
-  process.stdout.write(`${JSON.stringify({
-    status: 'failed',
-    changed: false,
-    error: { code, message }
-  })}\n`);
-  process.exitCode = exitCode;
-}
-
-function parse(args: string[]): Readonly<{ operation: string; values: Readonly<Record<string, string>> }> | null {
-  if (args[0] === '--help' || args[0] === '-h') {
-    process.stdout.write(USAGE);
-    return null;
-  }
-  const operation = args[0];
-  if (!operation || ![
-    internalHandlerRoute('codex-sandbox-controller', 'run', operation),
-    internalHandlerRoute('codex-sandbox-controller', 'verify-context', operation)
-  ].some(Boolean)) {
-    process.stderr.write(USAGE);
-    fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', 'operation must be run or verify-context', 2);
-    return null;
-  }
-  const allowed = new Set([
-    '--context',
-    '--executor-model',
-    '--executor-reasoning-effort',
-    '--reviewer-model',
-    '--reviewer-reasoning-effort'
-  ]);
-  const values: Record<string, string> = {};
-  for (let index = 1; index < args.length; index += 1) {
-    const flag = args[index]!;
-    if (flag === '--task-id' || flag.startsWith('--task-id=')
-      || flag === '--task-ref' || flag.startsWith('--task-ref=')) {
-      fail('CODEX_SANDBOX_CONTROLLER_IDENTITY_OPTION_UNSUPPORTED', 'controller task identity options are not supported', 2);
-      return null;
-    }
-    const value = args[++index];
-    if (!allowed.has(flag) || Object.hasOwn(values, flag) || !value || value.startsWith('--')) {
-      fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', `invalid option '${flag}'`, 2);
-      return null;
-    }
-    values[flag] = value;
-  }
-  return { operation, values };
-}
-
-async function codexSandboxController(args: string[] = []): Promise<void> {
-  if (!ensureInternalHandlerRoute('codex-sandbox-controller', args)) return;
-  const parsed = parse(args);
-  if (!parsed || process.exitCode) return;
-  try {
-    if (internalHandlerRoute('codex-sandbox-controller', 'verify-context', parsed.operation)) {
-      const contextPath = parsed.values['--context']
-        ?? process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-      if (!contextPath) throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_MISSING');
-      const verified = verifyCodexSandboxControllerContextWithWarnings(contextPath);
-      const context = verified.context;
-      process.stdout.write(`${JSON.stringify({
-        status: 'ready',
-        changed: false,
-        context: {
-          taskId: context.taskId,
-          controlGeneration: context.controlGeneration,
-          controllerInstanceDigest: context.controllerInstanceDigest,
-          expiresAt: context.expiresAt,
-          buildIdentity: context.buildIdentity,
-          hookDefinitionHash: context.hookDefinitionHash,
-        },
-        ...(verified.warnings.length > 0 ? { warnings: verified.warnings } : {}),
-        error: null
-      })}\n`);
-      return;
-    }
-    const policy = [
-      '--executor-model',
-      '--executor-reasoning-effort',
-      '--reviewer-model',
-      '--reviewer-reasoning-effort'
-    ];
-    if (policy.some((flag) => parsed.values[flag] !== undefined)
-      && policy.some((flag) => parsed.values[flag] === undefined)) {
-      throw new Error('CODEX_SANDBOX_CONTROLLER_MODEL_POLICY_INVALID');
-    }
-    const exitCode = await runCodexSandboxController({
-      executorModel: parsed.values['--executor-model'],
-      executorReasoningEffort: parsed.values['--executor-reasoning-effort'],
-      reviewerModel: parsed.values['--reviewer-model'],
-      reviewerReasoningEffort: parsed.values['--reviewer-reasoning-effort']
-    });
-    process.exitCode = exitCode;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const code = /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1]
-      ?? 'CODEX_SANDBOX_CONTROLLER_FAILED';
-    fail(code, message);
-  }
-}
-
-export { codexSandboxController };

package/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.ts

@@ -1,437 +0,0 @@
-import crypto from 'node:crypto';
-import { spawn, spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import semver from 'semver';
-import * as toml from 'smol-toml';
-
-import {
-  requestCodexControllerClose,
-  requestCodexControllerOpen,
-  requestCodexControllerVerify
-} from './controller-client.ts';
-import { getProcessStartTime, type ProcessIdentity } from '../../../server/process-state.ts';
-import { LIFECYCLE_PROTOCOL_VERSION, type LifecycleIdentityWarning } from './build-identity.ts';
-import {
-  contextFromControllerLease,
-  controllerProofFromContext,
-  verifyCodexSandboxControllerContextWithWarnings as verifyContextFileWithWarnings,
-  writeCodexSandboxControllerContext,
-  type CodexSandboxControllerContextV2
-} from './controller-context.ts';
-
-type ControllerControl = Readonly<{
-  token: string;
-  generation: string;
-  rootId?: string;
-  channelDir: string;
-  statusDir: string;
-  runtimeDir: string;
-}>;
-
-type ControllerInput = Readonly<{
-  executorModel?: string;
-  executorReasoningEffort?: string;
-  reviewerModel?: string;
-  reviewerReasoningEffort?: string;
-}>;
-
-type ControllerOptions = Readonly<{
-  repoRoot?: string;
-  codexHome?: string;
-  temporaryRoot?: string;
-  control?: ControllerControl;
-  now?: () => number;
-  codexVersion?: () => string;
-  verifyController?: typeof requestCodexControllerVerify;
-  openController?: typeof requestCodexControllerOpen;
-  closeController?: typeof requestCodexControllerClose;
-  environment?: NodeJS.ProcessEnv;
-}>;
-
-type PreparedCodexSandboxController = Readonly<{
-  command: 'codex';
-  args: readonly string[];
-  env: NodeJS.ProcessEnv;
-  home: string;
-  contextPath: string;
-  context: CodexSandboxControllerContextV2;
-  cleanup: () => void;
-}>;
-
-type VerifyContextOptions = Readonly<{
-  repoRoot?: string;
-  now?: number;
-  generation?: string;
-  probeProcess?: (identity: ProcessIdentity) => 'alive' | 'dead' | 'unknown';
-  control?: ControllerControl;
-  requestControllerVerify?: typeof requestCodexControllerVerify;
-}>;
-
-function copyRegular(source: string, destination: string, mode: number): void {
-  const stat = fs.lstatSync(source);
-  if (!stat.isFile() || stat.isSymbolicLink()) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_INPUT_INVALID');
-  }
-  fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
-  fs.copyFileSync(source, destination);
-  fs.chmodSync(destination, mode);
-}
-
-function controlFromEnvironment(): ControllerControl {
-  const token = process.env.AGENT_INFRA_CONTROL_TOKEN;
-  const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
-  const rootId = process.env.AGENT_INFRA_CONTROL_ROOT_ID;
-  const channelDir = process.env.AGENT_INFRA_CONTROL_DIR;
-  const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
-  const runtimeDir = process.env.AGENT_INFRA_RUNTIME_DIR;
-  if (!token || !generation || !rootId || !channelDir || !statusDir || !runtimeDir) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTROL_MISSING');
-  }
-  return { token, generation, rootId, channelDir, statusDir, runtimeDir };
-}
-
-function verifyRuntime(runtimeDir: string): void {
-  let stat: fs.Stats;
-  try {
-    stat = fs.lstatSync(runtimeDir);
-  } catch {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
-  }
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
-  }
-  const probe = path.join(runtimeDir, `.controller-${process.pid}-${crypto.randomUUID()}.probe`);
-  try {
-    fs.writeFileSync(probe, 'runtime-probe\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
-    if (fs.readFileSync(probe, 'utf8') !== 'runtime-probe\n') {
-      throw new Error('probe mismatch');
-    }
-  } catch {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
-  } finally {
-    fs.rmSync(probe, { force: true });
-  }
-}
-
-function verifyControllerBinding(
-  context: CodexSandboxControllerContextV2,
-  control: ControllerControl,
-  requestControllerVerify: typeof requestCodexControllerVerify
-): void {
-  verifyRuntime(control.runtimeDir);
-  const verified = requestControllerVerify({
-    controllerProof: controllerProofFromContext(context),
-    ...control,
-    timeoutMs: 30_000
-  });
-  if (verified.binding.controlGeneration !== context.controlGeneration
-    || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
-  }
-}
-
-function verifyCodexSandboxControllerContextWithWarnings(
-  contextPath: string,
-  options: VerifyContextOptions = {}
-): Readonly<{ context: CodexSandboxControllerContextV2; warnings: readonly LifecycleIdentityWarning[] }> {
-  const control = options.control ?? controlFromEnvironment();
-  const fileVerification = verifyContextFileWithWarnings(contextPath, {
-    repoRoot: options.repoRoot,
-    now: options.now,
-    generation: control.generation,
-    probeProcess: options.probeProcess
-  });
-  const context = fileVerification.context;
-  const verified = (options.requestControllerVerify ?? requestCodexControllerVerify)({
-    controllerProof: controllerProofFromContext(context),
-    ...control,
-    timeoutMs: 30_000
-  });
-  if (verified.binding.controlGeneration !== context.controlGeneration
-    || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-  }
-  return Object.freeze({
-    context,
-    warnings: fileVerification.warnings
-  });
-}
-
-function detectedCodexVersion(): string {
-  const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
-  const version = /codex-cli\s+(\d+\.\d+\.\d+)/u.exec(result.stdout ?? '')?.[1];
-  if (result.status !== 0 || !version) throw new Error('CODEX_SANDBOX_CONTROLLER_CODEX_UNAVAILABLE');
-  return version;
-}
-
-function sanitizedConfig(source: string, destination: string, sourceHome: string, targetHome: string): readonly string[] {
-  if (!fs.existsSync(source)) return [];
-  const parsed = toml.parse(fs.readFileSync(source, 'utf8')) as Record<string, unknown>;
-  const allowed = new Set([
-    'model',
-    'model_provider',
-    'model_providers',
-    'model_reasoning_effort',
-    'model_auto_compact_token_limit',
-    'preferred_auth_method'
-  ]);
-  const output = Object.fromEntries(Object.entries(parsed).filter(([key]) => allowed.has(key)));
-  const catalog = parsed.model_catalog_json;
-  if (typeof catalog === 'string' && catalog.trim()) {
-    const resolved = path.resolve(sourceHome, catalog.replace(/^~[/\\]/u, ''));
-    const relative = path.relative(sourceHome, resolved);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-      throw new Error('CODEX_SANDBOX_CONTROLLER_CONFIG_PATH_INVALID');
-    }
-    const target = path.join(targetHome, 'model-catalogs', path.basename(resolved));
-    copyRegular(resolved, target, 0o600);
-    output.model_catalog_json = target;
-  }
-  fs.writeFileSync(destination, `${toml.stringify(output)}\n`, { mode: 0o600 });
-  const providerEnvironment = new Set<string>();
-  const providers = output.model_providers;
-  if (providers && typeof providers === 'object' && !Array.isArray(providers)) {
-    for (const provider of Object.values(providers)) {
-      if (!provider || typeof provider !== 'object' || Array.isArray(provider)) continue;
-      for (const key of ['env_key', 'envKey']) {
-        const name = (provider as Record<string, unknown>)[key];
-        if (typeof name === 'string' && /^[A-Z][A-Z0-9_]{1,127}$/u.test(name)) {
-          providerEnvironment.add(name);
-        }
-      }
-    }
-  }
-  return Object.freeze([...providerEnvironment]);
-}
-
-function isolatedEnvironment(
-  home: string,
-  shimDir: string,
-  contextPath: string,
-  taskId: string,
-  control: ControllerControl,
-  providerEnvironment: readonly string[],
-  sourceEnvironment: NodeJS.ProcessEnv
-): NodeJS.ProcessEnv {
-  const inherited = new Set([
-    'LANG', 'LC_ALL', 'TERM', 'COLORTERM',
-    'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY',
-    'http_proxy', 'https_proxy', 'no_proxy',
-    'SSL_CERT_FILE', 'SSL_CERT_DIR', 'NODE_EXTRA_CA_CERTS',
-    'CODEX_CI',
-    ...providerEnvironment
-  ]);
-  const env: NodeJS.ProcessEnv = {};
-  for (const key of inherited) {
-    if (sourceEnvironment[key] !== undefined) env[key] = sourceEnvironment[key];
-  }
-  return {
-    ...env,
-    HOME: home,
-    CODEX_HOME: home,
-    PATH: `${shimDir}${path.delimiter}${sourceEnvironment.PATH ?? ''}`,
-    AGENT_INFRA_TASK_ID: taskId,
-    AGENT_INFRA_CONTROL_TOKEN: control.token,
-    AGENT_INFRA_CONTROL_GENERATION: control.generation,
-    ...(control.rootId || sourceEnvironment.AGENT_INFRA_CONTROL_ROOT_ID
-      ? { AGENT_INFRA_CONTROL_ROOT_ID: control.rootId ?? sourceEnvironment.AGENT_INFRA_CONTROL_ROOT_ID }
-      : {}),
-    AGENT_INFRA_CONTROL_DIR: control.channelDir,
-    AGENT_INFRA_CONTROL_STATUS_DIR: control.statusDir,
-    AGENT_INFRA_RUNTIME_DIR: control.runtimeDir,
-    AGENT_INFRA_CODEX_CONTROLLER_CONTEXT: contextPath
-  };
-}
-
-function shellQuote(value: string): string {
-  return `'${value.replaceAll("'", "'\\''")}'`;
-}
-
-function prepareCodexSandboxController(
-  input: ControllerInput,
-  options: ControllerOptions = {}
-): PreparedCodexSandboxController {
-  const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
-  const sourceHome = path.resolve(options.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'));
-  const control = options.control ?? controlFromEnvironment();
-  const version = (options.codexVersion ?? detectedCodexVersion)();
-  if (!semver.gte(version, '0.147.0')) throw new Error('CODEX_SANDBOX_CONTROLLER_CODEX_UNSUPPORTED');
-
-  const runtimeRoot = path.resolve(options.temporaryRoot
-    ?? path.join(os.tmpdir(), 'agent-infra-codex-controllers'));
-  fs.mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
-  fs.chmodSync(runtimeRoot, 0o700);
-  const key = crypto.createHash('sha256')
-    .update(`${process.pid}\0${control.generation}`)
-    .digest('hex');
-  const parentStartTime = getProcessStartTime(process.pid);
-  if (!parentStartTime) throw new Error('CODEX_SANDBOX_CONTROLLER_PROCESS_IDENTITY_INVALID');
-  const home = fs.mkdtempSync(path.join(runtimeRoot, `${key}-`));
-  fs.chmodSync(home, 0o700);
-  let cleaned = false;
-  let context: CodexSandboxControllerContextV2 | null = null;
-  const cleanup = () => {
-    if (cleaned) return;
-    cleaned = true;
-    if (context) {
-      try {
-        (options.closeController ?? requestCodexControllerClose)({
-          controllerProcess: context.controllerProcess,
-          controllerProof: controllerProofFromContext(context),
-          ...control,
-          timeoutMs: 30_000
-        });
-      } catch {
-        // The wrapper is exiting; dead-process recovery safely handles an unknown close result.
-      }
-    }
-    const relative = path.relative(runtimeRoot, home);
-    if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
-      fs.rmSync(home, { recursive: true, force: true });
-    }
-  };
-
-  try {
-    const auth = path.join(sourceHome, 'auth.json');
-    if (fs.existsSync(auth)) copyRegular(auth, path.join(home, 'auth.json'), 0o600);
-    const providerEnvironment = sanitizedConfig(
-      path.join(sourceHome, 'config.toml'),
-      path.join(home, 'config.toml'),
-      sourceHome,
-      home
-    );
-
-    const hooks = path.join(repoRoot, '.codex', 'hooks.json');
-    const executor = path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-executor.toml');
-    const reviewer = path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-reviewer.toml');
-    copyRegular(hooks, path.join(home, 'hooks.json'), 0o600);
-    copyRegular(executor, path.join(home, 'agents', path.basename(executor)), 0o600);
-    copyRegular(reviewer, path.join(home, 'agents', path.basename(reviewer)), 0o600);
-
-    const opened = (options.openController ?? requestCodexControllerOpen)({
-      controllerProcess: { pid: process.pid, startTime: parentStartTime },
-      ...control,
-      timeoutMs: 30_000
-    });
-    const taskId = opened.lease.taskId;
-    if (opened.lease.buildIdentity.protocolVersion !== LIFECYCLE_PROTOCOL_VERSION) {
-      throw new Error('CODEX_LIFECYCLE_PROTOCOL_MISMATCH: Codex lifecycle protocol version does not match');
-    }
-    context = contextFromControllerLease(opened.lease, {
-      hookDefinitionHash: crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex')
-    });
-    if (opened.lease.controlGeneration !== control.generation
-      || opened.lease.controllerProcess.pid !== process.pid
-      || opened.lease.controllerProcess.startTime !== parentStartTime) {
-      throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
-    }
-    verifyControllerBinding(context, control, options.verifyController ?? requestCodexControllerVerify);
-    const contextPath = path.join(home, 'controller-context.json');
-    writeCodexSandboxControllerContext(contextPath, context);
-
-    const shimDir = path.join(home, 'bin');
-    fs.mkdirSync(shimDir, { mode: 0o700 });
-    const internalCli = path.resolve(process.argv[1] ?? path.join(repoRoot, 'bin', 'internal-cli.ts'));
-    const launcherPrefix = ['#!/bin/sh', 'set -eu', 'unset NODE_OPTIONS NODE_PATH'].join('\n') + '\n';
-    const source = internalCli.endsWith('.ts')
-      ? `${launcherPrefix}exec ${shellQuote(process.execPath)} --experimental-strip-types ${shellQuote(internalCli)} "$@"\n`
-      : `${launcherPrefix}exec ${shellQuote(process.execPath)} ${shellQuote(internalCli)} "$@"\n`;
-    fs.writeFileSync(path.join(shimDir, 'agent-infra-internal'), source, { mode: 0o700 });
-
-    const policy = [
-      input.executorModel ? `--executor-model ${input.executorModel}` : '',
-      input.executorReasoningEffort ? `--executor-reasoning-effort ${input.executorReasoningEffort}` : '',
-      input.reviewerModel ? `--reviewer-model ${input.reviewerModel}` : '',
-      input.reviewerReasoningEffort ? `--reviewer-reasoning-effort ${input.reviewerReasoningEffort}` : ''
-    ].filter(Boolean).join(' ');
-    const prompt = `$run-task ${taskId}${policy ? ` ${policy}` : ''}`;
-    const args = Object.freeze([
-      'exec',
-      '--enable', 'hooks',
-      '--enable', 'multi_agent',
-      '--dangerously-bypass-hook-trust',
-      '--dangerously-bypass-approvals-and-sandbox',
-      '--json',
-      '-C', repoRoot,
-      prompt
-    ]);
-    const env = isolatedEnvironment(
-      home,
-      shimDir,
-      contextPath,
-      taskId,
-      control,
-      providerEnvironment,
-      options.environment ?? process.env
-    );
-    return Object.freeze({
-      command: 'codex' as const,
-      args,
-      env,
-      home,
-      contextPath,
-      context,
-      cleanup
-    });
-  } catch (error) {
-    cleanup();
-    throw error;
-  }
-}
-
-async function runCodexSandboxController(
-  input: ControllerInput,
-  options: ControllerOptions = {}
-): Promise<number> {
-  const prepared = prepareCodexSandboxController(input, options);
-  try {
-    const child = spawn(prepared.command, [...prepared.args], {
-      cwd: options.repoRoot ?? process.cwd(),
-      env: prepared.env,
-      stdio: 'inherit',
-      detached: process.platform !== 'win32'
-    });
-    let forceKill: NodeJS.Timeout | undefined;
-    const terminate = () => {
-      if (child.pid && process.platform !== 'win32') {
-        try { process.kill(-child.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
-      } else child.kill('SIGTERM');
-      forceKill = setTimeout(() => {
-        if (child.pid && process.platform !== 'win32') {
-          try { process.kill(-child.pid, 'SIGKILL'); } catch { child.kill('SIGKILL'); }
-        } else child.kill('SIGKILL');
-      }, 5_000);
-      forceKill.unref();
-    };
-    process.once('SIGINT', terminate);
-    process.once('SIGTERM', terminate);
-    try {
-      return await new Promise<number>((resolve, reject) => {
-        child.once('error', reject);
-        child.once('exit', (code, signal) => resolve(code ?? (signal ? 1 : 0)));
-      });
-    } finally {
-      if (forceKill) clearTimeout(forceKill);
-      process.off('SIGINT', terminate);
-      process.off('SIGTERM', terminate);
-    }
-  } finally {
-    prepared.cleanup();
-  }
-}
-
-export {
-  prepareCodexSandboxController,
-  runCodexSandboxController,
-  verifyCodexSandboxControllerContextWithWarnings,
-  controllerProofFromContext
-};
-export type {
-  CodexSandboxControllerContextV2 as CodexSandboxControllerContext,
-  ControllerControl,
-  ControllerInput,
-  ControllerOptions,
-  PreparedCodexSandboxController
-};

package/lib/sandbox/control/agent-operation.ts

@@ -1,49 +0,0 @@
-import { getAgentClientAdapter } from '../../agent-clients/registry.ts';
-import type { AgentClientSandboxControlOperation } from '../../agent-clients/adapter.ts';
-import type { SandboxControlManifest, SandboxAgentClientRequest } from './protocol.ts';
-
-function operationFor(request: SandboxAgentClientRequest) {
-  const adapter = getAgentClientAdapter(request.agentClient);
-  const operation = adapter.sandboxControlOperation;
-  if (!operation) throw new Error('SANDBOX_CONTROL_AGENT_OPERATION_UNSUPPORTED');
-  return operation;
-}
-
-function validateAgentClientOperation(request: SandboxAgentClientRequest, manifest: SandboxControlManifest): void {
-  operationFor(request).validate({
-    operation: request.operation,
-    payload: request.payload,
-    manifest
-  });
-}
-
-function executeAgentClientOperation(
-  request: SandboxAgentClientRequest,
-  manifest: SandboxControlManifest,
-  manifestPath: string,
-  override?: AgentClientSandboxControlOperation
-) {
-  return (override ?? operationFor(request)).execute({
-    operation: request.operation,
-    payload: request.payload,
-    manifest,
-    manifestPath
-  });
-}
-
-function recoverAgentClientOperation(params: Readonly<{
-  request: SandboxAgentClientRequest;
-  manifest: SandboxControlManifest;
-  manifestPath: string;
-  stdout: string | null;
-}>): Readonly<Record<string, unknown>> {
-  const operation = operationFor(params.request);
-  return operation.recover?.({
-    operation: params.request.operation,
-    manifest: params.manifest,
-    manifestPath: params.manifestPath,
-    stdout: params.stdout
-  }) ?? { consistent: false };
-}
-
-export { executeAgentClientOperation, recoverAgentClientOperation, validateAgentClientOperation };