@the-open-engine/zeroshot 6.39.0 → 6.39.2

package/scripts/rust-distribution.js

@@ -325,10 +325,7 @@ function stagedLockDependencies(cargoLock, workspaceCargoToml) {
 
 function stageCargoLock(cargoLock, version, workspaceCargoToml) {
   const targetPackage = workspaceLockPackage(cargoLock);
-  let stagedPackage = targetPackage.text.replace(
-    /^(version = ")[^"]+(")$/m,
-    `$1${version}$2`
-  );
+  let stagedPackage = targetPackage.text.replace(/^(version = ")[^"]+(")$/m, `$1${version}$2`);
   for (const dependency of stagedLockDependencies(cargoLock, workspaceCargoToml)) {
     const dependencyPattern = new RegExp(
       `^(\\s*")${escapeRegExp(dependency.name)}(?: [^"]+)?(",\\r?)$`,
@@ -339,10 +336,7 @@ function stageCargoLock(cargoLock, version, workspaceCargoToml) {
         `RUST_VERSION_STAGE_FAILED: Cargo.lock zeroshot-rust entry has no ${dependency.name} dependency`
       );
     }
-    stagedPackage = stagedPackage.replace(
-      dependencyPattern,
-      `$1${dependency.reference}$2`
-    );
+    stagedPackage = stagedPackage.replace(dependencyPattern, `$1${dependency.reference}$2`);
   }
   return (
     cargoLock.slice(0, targetPackage.start) +
@@ -359,10 +353,7 @@ function verifyStagedCargoLock(cargoLock, version, workspaceCargoToml) {
     );
   }
   for (const dependency of stagedLockDependencies(cargoLock, workspaceCargoToml)) {
-    const dependencyPattern = new RegExp(
-      `^\\s*"${escapeRegExp(dependency.reference)}",\\r?$`,
-      'm'
-    );
+    const dependencyPattern = new RegExp(`^\\s*"${escapeRegExp(dependency.reference)}",\\r?$`, 'm');
     if (!dependencyPattern.test(targetPackage.text)) {
       throw new Error(
         `${VERSION_ERROR}: Cargo.lock zeroshot-rust dependency ${dependency.name} is not coupled to ${dependency.version}`
@@ -400,8 +391,7 @@ function stageVersion(
 function checkVersionCoupling(tag, cargoToml, cargoLock, workspaceCargoToml) {
   const useRepositoryFiles = cargoToml === undefined;
   const manifest =
-    cargoToml ??
-    fs.readFileSync(path.join(repositoryRoot, 'zeroshot-rust', 'Cargo.toml'), 'utf8');
+    cargoToml ?? fs.readFileSync(path.join(repositoryRoot, 'zeroshot-rust', 'Cargo.toml'), 'utf8');
   const releaseVersion = normalizeVersion(tag);
   const manifestVersion = cargoVersion(manifest);
   if (releaseVersion !== manifestVersion) {
@@ -416,8 +406,7 @@ function checkVersionCoupling(tag, cargoToml, cargoLock, workspaceCargoToml) {
       : undefined);
   if (lock !== undefined) {
     const workspace =
-      workspaceCargoToml ??
-      fs.readFileSync(path.join(repositoryRoot, 'Cargo.toml'), 'utf8');
+      workspaceCargoToml ?? fs.readFileSync(path.join(repositoryRoot, 'Cargo.toml'), 'utf8');
     verifyStagedCargoLock(lock, releaseVersion, workspace);
   }
   return releaseVersion;
@@ -483,9 +472,7 @@ const SCRIPT_INSTALL_CONTRACTS = Object.freeze([
 ]);
 
 function invokesRustDistribution(step) {
-  return (
-    typeof step.run === 'string' && RUST_DISTRIBUTION_INVOCATION.test(step.run)
-  );
+  return typeof step.run === 'string' && RUST_DISTRIBUTION_INVOCATION.test(step.run);
 }
 
 function checkScriptInstall(job, { jobName, installName, command, checkoutRef }) {
@@ -507,9 +494,7 @@ function checkScriptInstall(job, { jobName, installName, command, checkoutRef })
       checkout.with.repository !== '${{ github.repository }}') ||
     checkout.with?.ref !== checkoutRef
   ) {
-    failIntegrity(
-      `${jobName} must checkout expected current repository source at workspace root`
-    );
+    failIntegrity(`${jobName} must checkout expected current repository source at workspace root`);
   }
   const installIndex = job.steps.indexOf(install);
   const checkoutIndex = job.steps.indexOf(checkout);
@@ -745,11 +730,12 @@ function hasValidSri(integrity) {
 }
 
 function checkScriptDependencies(packageManifest, packageLock) {
-  const directSpec = packageManifest.devDependencies?.['js-yaml'];
+  // js-yaml is a runtime dependency: lib/compose-utils.js requires it from the published package.
+  const directSpec = packageManifest.dependencies?.['js-yaml'];
   if (typeof directSpec !== 'string' || directSpec.length === 0) {
-    failIntegrity('rust-distribution.js requires a direct js-yaml devDependency');
+    failIntegrity('rust-distribution.js requires a direct js-yaml dependency');
   }
-  const lockSpec = packageLock.packages?.['']?.devDependencies?.['js-yaml'];
+  const lockSpec = packageLock.packages?.['']?.dependencies?.['js-yaml'];
   if (lockSpec !== directSpec) {
     failIntegrity('package-lock root js-yaml spec must match package.json');
   }
@@ -773,12 +759,8 @@ function checkRepository(
   shimTargets = JSON.parse(
     fs.readFileSync(path.join(repositoryRoot, 'npm', 'zeroshot-rust', 'targets.json'), 'utf8')
   ),
-  packageManifest = JSON.parse(
-    fs.readFileSync(path.join(repositoryRoot, 'package.json'), 'utf8')
-  ),
-  packageLock = JSON.parse(
-    fs.readFileSync(path.join(repositoryRoot, 'package-lock.json'), 'utf8')
-  )
+  packageManifest = JSON.parse(fs.readFileSync(path.join(repositoryRoot, 'package.json'), 'utf8')),
+  packageLock = JSON.parse(fs.readFileSync(path.join(repositoryRoot, 'package-lock.json'), 'utf8'))
 ) {
   let document;
   try {

package/src/agent/agent-lifecycle.js

@@ -221,6 +221,7 @@ function start(agent) {
  */
 async function stop(agent) {
   stopLivenessCheck(agent);
+  agent._cancelStartDelay?.();
 
   const hasNestedExecutions = agent.nestedExecutions?.hasActive === true;
   if (!agent.running && !agent.currentTask && !hasNestedExecutions && !agent._currentExecution) {
@@ -440,7 +441,21 @@ async function applyValidatorJitter(agent) {
       `[Agent ${agent.id}] Adding ${Math.round(jitterMs / 1000)}s jitter to prevent lock contention`
     );
   }
-  await new Promise((resolve) => setTimeout(resolve, jitterMs));
+  await new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    let cancel;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (agent._cancelStartDelay === cancel) agent._cancelStartDelay = null;
+      resolve();
+    };
+    cancel = finish;
+    timer = setTimeout(finish, jitterMs);
+    agent._cancelStartDelay = cancel;
+  });
 }
 
 function publishTaskStarted(agent, triggeringMessage) {
@@ -641,6 +656,7 @@ async function runTaskAttempt(agent, triggeringMessage) {
   // Spawn provider task
   agent.state = 'executing_task';
   await applyValidatorJitter(agent);
+  if (!agent.running) return;
   publishTaskStarted(agent, triggeringMessage);
 
   let result;

package/src/agent/output-extraction-failures.js

@@ -5,6 +5,20 @@ const piExtraction = require("./output-extraction-pi");
 const { MAX_CLI_ERROR_BYTES, cliErrorDetail } = errorDetail;
 const { isObjectRecord, parseJsonRecordLine } = jsonExtraction;
 const { extractSettledPiFailure } = piExtraction;
+const OMP_SDK_ERROR_CODES = new Map([
+    ['invalid-request', 'request'],
+    ['model-resolution', 'model'],
+    ['model-fallback', 'model'],
+    ['provider-auth', 'auth'],
+    ['provider-rate-limit', 'rate-limit'],
+    ['provider-timeout', 'timeout'],
+    ['provider-error', 'provider'],
+    ['schema-violation', 'schema'],
+    ['cancelled', 'cancelled'],
+    ['sdk-error', 'sdk'],
+    ['cleanup-error', 'cleanup'],
+    ['internal-error', 'internal'],
+]);
 function firstTruthyValue(...values) {
     for (const value of values) {
         if (value)
@@ -54,6 +68,63 @@ function opencodeFailureFromObject(value) {
     const source = firstTruthyValue(recordField(recordField(error, 'data'), 'message'), recordField(error, 'message'), recordField(error, 'name'));
     return { ...cliErrorDetail(source, 'Session error'), provider: 'opencode' };
 }
+function hasExactKeys(value, expected) {
+    return (Object.keys(value).length === expected.length &&
+        expected.every((key) => Object.prototype.hasOwnProperty.call(value, key)));
+}
+function isOmpSdkIdentity(value, nameField, expectedName, expectedVersion) {
+    return (isObjectRecord(value) &&
+        value[nameField] === expectedName &&
+        value.version === expectedVersion &&
+        hasExactKeys(value, [nameField, 'version']));
+}
+function ompSdkErrorMetadata(value) {
+    if (!isObjectRecord(value))
+        return null;
+    const { category, code, redacted, retryable } = value;
+    if (typeof code !== 'string' ||
+        typeof category !== 'string' ||
+        OMP_SDK_ERROR_CODES.get(code) !== category ||
+        typeof retryable !== 'boolean' ||
+        redacted !== true ||
+        !hasExactKeys(value, ['category', 'code', 'redacted', 'retryable'])) {
+        return null;
+    }
+    return { category, code, retryable };
+}
+function ompProviderCategory(error) {
+    if (error.category === 'auth')
+        return 'authentication';
+    return error.retryable ? 'transient' : 'permanent';
+}
+function isOmpSdkRunId(value) {
+    return (typeof value === 'string' &&
+        value.length <= 128 &&
+        /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value));
+}
+function isOmpSdkErrorEnvelope(value) {
+    return (value.protocolVersion === 1 &&
+        value.type === 'error' &&
+        isOmpSdkRunId(value.runId) &&
+        hasExactKeys(value, ['backend', 'error', 'protocolVersion', 'runId', 'runtime', 'type']) &&
+        isOmpSdkIdentity(value.backend, 'id', 'omp-sdk', '17.2.1') &&
+        isOmpSdkIdentity(value.runtime, 'name', 'bun', '1.3.14'));
+}
+function ompSdkFailureFromObject(value) {
+    const error = ompSdkErrorMetadata(value.error);
+    if (error === null || !isOmpSdkErrorEnvelope(value))
+        return null;
+    const detail = `OMP SDK ${error.code} (${error.category})`;
+    return {
+        ...cliErrorDetail(detail, 'OMP SDK turn failed'),
+        provider: 'omp',
+        providerCategory: ompProviderCategory(error),
+        providerClassification: {
+            retryable: error.retryable,
+            kind: error.retryable ? 'unknown-retryable' : 'permanent-pattern',
+        },
+    };
+}
 function failureFromProviderObject(value, providerName) {
     if (!isObjectRecord(value))
         return null;
@@ -65,6 +136,8 @@ function failureFromProviderObject(value, providerName) {
         return geminiFailureFromObject(value);
     if (providerName === 'opencode')
         return opencodeFailureFromObject(value);
+    if (providerName === 'omp')
+        return ompSdkFailureFromObject(value);
     return null;
 }
 function vertexModelFromResult(parsed, useVertex) {

package/src/agent/output-extraction-failures.ts

@@ -12,6 +12,21 @@ const { MAX_CLI_ERROR_BYTES, cliErrorDetail } = errorDetail;
 const { isObjectRecord, parseJsonRecordLine } = jsonExtraction;
 const { extractSettledPiFailure } = piExtraction;
 
+const OMP_SDK_ERROR_CODES = new Map([
+  ['invalid-request', 'request'],
+  ['model-resolution', 'model'],
+  ['model-fallback', 'model'],
+  ['provider-auth', 'auth'],
+  ['provider-rate-limit', 'rate-limit'],
+  ['provider-timeout', 'timeout'],
+  ['provider-error', 'provider'],
+  ['schema-violation', 'schema'],
+  ['cancelled', 'cancelled'],
+  ['sdk-error', 'sdk'],
+  ['cleanup-error', 'cleanup'],
+  ['internal-error', 'internal'],
+]);
+
 function firstTruthyValue(...values: readonly unknown[]): unknown {
   for (const value of values) {
     if (value) return value;
@@ -71,12 +86,97 @@ function opencodeFailureFromObject(value: JsonRecord): CliFailure | null {
   return { ...cliErrorDetail(source, 'Session error'), provider: 'opencode' };
 }
 
+function hasExactKeys(value: JsonRecord, expected: readonly string[]): boolean {
+  return (
+    Object.keys(value).length === expected.length &&
+    expected.every((key) => Object.prototype.hasOwnProperty.call(value, key))
+  );
+}
+
+function isOmpSdkIdentity(
+  value: unknown,
+  nameField: 'id' | 'name',
+  expectedName: string,
+  expectedVersion: string
+): boolean {
+  return (
+    isObjectRecord(value) &&
+    value[nameField] === expectedName &&
+    value.version === expectedVersion &&
+    hasExactKeys(value, [nameField, 'version'])
+  );
+}
+
+interface OmpSdkErrorMetadata {
+  readonly category: string;
+  readonly code: string;
+  readonly retryable: boolean;
+}
+
+function ompSdkErrorMetadata(value: unknown): OmpSdkErrorMetadata | null {
+  if (!isObjectRecord(value)) return null;
+  const { category, code, redacted, retryable } = value;
+  if (
+    typeof code !== 'string' ||
+    typeof category !== 'string' ||
+    OMP_SDK_ERROR_CODES.get(code) !== category ||
+    typeof retryable !== 'boolean' ||
+    redacted !== true ||
+    !hasExactKeys(value, ['category', 'code', 'redacted', 'retryable'])
+  ) {
+    return null;
+  }
+  return { category, code, retryable };
+}
+
+function ompProviderCategory(
+  error: OmpSdkErrorMetadata
+): NonNullable<CliFailure['providerCategory']> {
+  if (error.category === 'auth') return 'authentication';
+  return error.retryable ? 'transient' : 'permanent';
+}
+
+function isOmpSdkRunId(value: unknown): value is string {
+  return (
+    typeof value === 'string' &&
+    value.length <= 128 &&
+    /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value)
+  );
+}
+
+function isOmpSdkErrorEnvelope(value: JsonRecord): boolean {
+  return (
+    value.protocolVersion === 1 &&
+    value.type === 'error' &&
+    isOmpSdkRunId(value.runId) &&
+    hasExactKeys(value, ['backend', 'error', 'protocolVersion', 'runId', 'runtime', 'type']) &&
+    isOmpSdkIdentity(value.backend, 'id', 'omp-sdk', '17.2.1') &&
+    isOmpSdkIdentity(value.runtime, 'name', 'bun', '1.3.14')
+  );
+}
+
+function ompSdkFailureFromObject(value: JsonRecord): CliFailure | null {
+  const error = ompSdkErrorMetadata(value.error);
+  if (error === null || !isOmpSdkErrorEnvelope(value)) return null;
+  const detail = `OMP SDK ${error.code} (${error.category})`;
+  return {
+    ...cliErrorDetail(detail, 'OMP SDK turn failed'),
+    provider: 'omp',
+    providerCategory: ompProviderCategory(error),
+    providerClassification: {
+      retryable: error.retryable,
+      kind: error.retryable ? 'unknown-retryable' : 'permanent-pattern',
+    },
+  };
+}
+
 function failureFromProviderObject(value: unknown, providerName: string): CliFailure | null {
   if (!isObjectRecord(value)) return null;
   if (providerName === 'claude') return claudeFailureFromObject(value);
   if (providerName === 'codex') return codexFailureFromObject(value);
   if (providerName === 'gemini') return geminiFailureFromObject(value);
   if (providerName === 'opencode') return opencodeFailureFromObject(value);
+  if (providerName === 'omp') return ompSdkFailureFromObject(value);
   return null;
 }
 

package/src/agent/output-extraction-types.ts

@@ -16,6 +16,11 @@ export interface CliErrorDetail {
 
 export interface CliFailure extends CliErrorDetail {
   provider: string;
+  providerCategory?: 'authentication' | 'permanent' | 'transient';
+  providerClassification?: {
+    retryable: boolean;
+    kind: 'permanent-pattern' | 'unknown-retryable';
+  };
 }
 
 export interface CliError {

package/src/agent/provider-terminal-failure.js

@@ -73,8 +73,8 @@ function extractProviderFailure(output, providerName) {
     const cliError = extractCliFailure(output, providerName);
     if (!cliError)
         return null;
-    const classification = classifyProviderFailure(providerName, cliError.error);
-    const category = categoryForProviderFailure(cliError.error, classification);
+    const classification = cliError.providerClassification ?? classifyProviderFailure(providerName, cliError.error);
+    const category = cliError.providerCategory ?? categoryForProviderFailure(cliError.error, classification);
     return {
         error: `Provider ${cliError.provider} failed (${category}; ${classification.kind})`,
         provider: cliError.provider,

package/src/agent/provider-terminal-failure.ts

@@ -89,8 +89,10 @@ function extractProviderFailure(output: string, providerName: string): ProviderF
   const cliError = extractCliFailure(output, providerName);
   if (!cliError) return null;
 
-  const classification = classifyProviderFailure(providerName, cliError.error);
-  const category = categoryForProviderFailure(cliError.error, classification);
+  const classification =
+    cliError.providerClassification ?? classifyProviderFailure(providerName, cliError.error);
+  const category =
+    cliError.providerCategory ?? categoryForProviderFailure(cliError.error, classification);
   return {
     error: `Provider ${cliError.provider} failed (${category}; ${classification.kind})`,
     provider: cliError.provider,

package/src/agent-cli-provider/adapters/claude.ts

@@ -315,7 +315,7 @@ export const claudeAdapter: StructuredOutputRecoveryAdapter = {
   displayName: 'Claude',
   binary: 'claude',
   adapterVersion: '1',
-  credentialEnvKeys: ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
+  credentialEnvKeys: ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_API_KEY'],
   modelCatalog: MODEL_CATALOG,
   levelMapping: LEVEL_MAPPING,
   defaultLevel: 'level2',

package/src/agent-cli-provider/adapters/codex.ts

@@ -73,6 +73,7 @@ function detectCliFeatures(
     supportsIgnoreUserConfig: !unknown && /--ignore-user-config\b/.test(help),
     supportsIgnoreRules: !unknown && /--ignore-rules\b/.test(help),
     supportsStrictConfig: !unknown && /--strict-config\b/.test(help),
+    supportsAddDir: !unknown && /--add-dir\b/.test(help),
     unknown,
   };
 }
@@ -119,6 +120,14 @@ function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions
         ? 'danger-full-access'
         : 'workspace-write';
     args.push('--sandbox', sandboxMode, '--config', 'approval_policy="never"');
+    if (sandboxMode === 'workspace-write') {
+      args.push('--config', 'sandbox_workspace_write.network_access=true');
+    }
+    if (features.supportsAddDir) {
+      for (const directory of new Set(options.additionalWritableDirectories ?? [])) {
+        args.push('--add-dir', directory);
+      }
+    }
   }
 }
 
@@ -129,6 +138,18 @@ function addSkipGitArgs(args: string[], options: BuildProviderCommandOptions): v
   }
 }
 
+function codexExecAuthEnv(
+  authEnv: Readonly<Record<string, string>>
+): Readonly<Record<string, string>> {
+  const openAiApiKey = authEnv.OPENAI_API_KEY;
+  if (openAiApiKey === undefined) return authEnv;
+  const { OPENAI_API_KEY: _openAiApiKey, ...rest } = authEnv;
+  return {
+    ...rest,
+    CODEX_API_KEY: rest.CODEX_API_KEY ?? openAiApiKey,
+  };
+}
+
 function applySchemaArgs(
   args: string[],
   cleanup: string[],
@@ -175,6 +196,19 @@ function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[
       )
     );
   }
+  if (
+    options.autoApprove &&
+    (options.additionalWritableDirectories?.length ?? 0) > 0 &&
+    features.supportsAddDir === false
+  ) {
+    warnings.push(
+      warning(
+        'codex',
+        'codex-add-dir',
+        'Codex CLI does not support --add-dir; Git worktree metadata outside cwd may be read-only.'
+      )
+    );
+  }
   if (options.jsonSchema && features.supportsOutputSchema === false) {
     warnings.push(
       warning(
@@ -216,6 +250,7 @@ function buildCommand(context: string, options: BuildProviderCommandOptions = {}
   }
   const args: string[] = ['exec'];
   const cleanup: string[] = [];
+  const authEnv = options.authEnv ?? {};
   const resumeSessionId =
     options.resumeSessionId && optionFeatures(options).supportsResume !== false
       ? options.resumeSessionId
@@ -244,7 +279,7 @@ function buildCommand(context: string, options: BuildProviderCommandOptions = {}
   return commandSpec({
     binary: 'codex',
     args,
-    env: {},
+    env: codexExecAuthEnv(authEnv),
     ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
     cleanup,
     cleanupMetadata: cleanup.map((schemaFile) => ({

package/src/agent-cli-provider/adapters/omp.ts

@@ -73,7 +73,8 @@ const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
 const CREDENTIAL_ENV_KEYS = OMP_CREDENTIAL_ENV_KEYS;
 
 const VERSION_TOKEN_PATTERN = /(?<![\w.])17\.2\.1(?![\w.])/;
-const MODEL_ID_PATTERN = /^@?[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u;
+const MODEL_ID_PATTERN =
+  /^(?=.{1,128}$)(?:@?[A-Za-z0-9][A-Za-z0-9._:/-]*|[a-z0-9][a-z0-9._-]*\/~[A-Za-z0-9][A-Za-z0-9._:/-]*)$/u;
 
 function detectCliFeatures(helpText?: string | null, versionText?: string | null): OmpCliFeatures {
   const help = helpText ?? '';

package/src/agent-cli-provider/omp/sdk-environment-policy.ts

@@ -0,0 +1,38 @@
+import { getProviderRegistryEntry } from '../provider-registry';
+import type { PreparedEnvironmentPolicy } from '../types';
+
+const MINIMAL_ENV_NAMES = [
+  'ALL_PROXY',
+  'HTTP_PROXY',
+  'HTTPS_PROXY',
+  'LANG',
+  'LC_ALL',
+  'NO_PROXY',
+  'PATH',
+  'SSL_CERT_DIR',
+  'SSL_CERT_FILE',
+  'TZ',
+] as const;
+
+const ALLOWED_ENV_NAMES = new Set([
+  ...MINIMAL_ENV_NAMES,
+  ...(getProviderRegistryEntry('omp').configurationEnvKeys ?? []),
+]);
+
+export function isOmpSdkEnvironmentName(name: string): boolean {
+  return ALLOWED_ENV_NAMES.has(name.toUpperCase());
+}
+
+export function ompSdkEnvironmentPolicy(
+  environment: NodeJS.ProcessEnv = process.env
+): PreparedEnvironmentPolicy {
+  const values: Record<string, string> = {};
+  for (const name of ALLOWED_ENV_NAMES) {
+    const value = environment[name];
+    if (value !== undefined) values[name] = value;
+  }
+  return {
+    inherit: 'minimal',
+    values: Object.freeze(values),
+  };
+}

package/src/agent-cli-provider/omp/sdk-process-private-runtime.ts

@@ -19,6 +19,7 @@ import type {
   PreparedProviderInvoke,
 } from '../types';
 import type { ProcessResult, ProcessRunnerOptions } from '../process-runner';
+import { isOmpSdkEnvironmentName } from './sdk-environment-policy';
 import { OmpSdkProcessRunnerError } from './sdk-process-error';
 
 export { credentialPayload, redactDiagnostic } from './sdk-process-credentials';
@@ -33,19 +34,6 @@ const PRIVATE_ENV_NAMES = new Set([
   'XDG_STATE_HOME',
   'PI_CODING_AGENT_DIR',
 ]);
-const MINIMAL_ENV_NAMES = new Set([
-  'ALL_PROXY',
-  'HTTP_PROXY',
-  'HTTPS_PROXY',
-  'LANG',
-  'LC_ALL',
-  'NO_PROXY',
-  'PATH',
-  'SSL_CERT_DIR',
-  'SSL_CERT_FILE',
-  'TZ',
-]);
-
 export interface OmpSdkPreparedInvocation extends PreparedSingleAgentProviderCommand {
   readonly invoke: PreparedProviderInvoke & {
     readonly lane: 'spawn';
@@ -119,13 +107,13 @@ export function assertPrepared(
 }
 export function assertHostContainment(requirement: OmpSdkContainmentRequirement): void {
   if (
-    requirement.mode !== 'host-process-tree' ||
+    (requirement.mode !== 'host-process-tree' && requirement.mode !== 'container') ||
     process.platform !== 'linux' ||
     (process.arch !== 'x64' && process.arch !== 'arm64')
   ) {
     throw new OmpSdkProcessRunnerError(
       'containment-error',
-      'OMP SDK host spawn requires the packaged Linux subreaper/pidfd supervisor; container invocations require the container spawn owner.'
+      'OMP SDK spawn requires the packaged Linux subreaper/pidfd supervisor.'
     );
   }
 }
@@ -228,7 +216,7 @@ export function childEnvironment(
   for (const [name, value] of Object.entries(policy.values)) {
     const normalized = name.toUpperCase();
     if (
-      !MINIMAL_ENV_NAMES.has(normalized) ||
+      !isOmpSdkEnvironmentName(normalized) ||
       PRIVATE_ENV_NAMES.has(normalized) ||
       /(?:^|_)(?:AUTH|CREDENTIAL|KEY|PASSWORD|SECRET|TOKEN)(?:_|$)/i.test(name)
     ) {

package/src/agent-cli-provider/omp/sdk-process-result.ts

@@ -4,7 +4,7 @@ import type {
   OmpSdkProtocolCollector,
   OmpSdkSidecarRequest,
 } from './sdk-protocol';
-import type { OmpSdkCleanupAttestation } from '../types';
+import type { OmpSdkCleanupAttestation, OmpSdkContainmentRequirement } from '../types';
 import { cancelledTerminal, type ChildOutcome } from './sdk-process-io';
 import {
   OmpSdkProcessRunnerError,
@@ -35,6 +35,7 @@ interface OmpSdkResultContext {
   readonly secretValues: readonly string[];
   readonly startedAt: number;
   readonly externalAbort: () => void;
+  readonly containmentMode: OmpSdkContainmentRequirement['mode'];
 }
 
 export async function collectOmpSdkProcessResult(
@@ -52,6 +53,7 @@ export async function collectOmpSdkProcessResult(
     secretValues,
     startedAt,
     externalAbort,
+    containmentMode,
   } = context;
   let rootRemoved = false;
   try {
@@ -113,7 +115,7 @@ export async function collectOmpSdkProcessResult(
     await removePrivateRoot(privateRuntime);
     rootRemoved = true;
     const cleanupAttestation: OmpSdkCleanupAttestation = {
-      mode: 'host-process-tree',
+      mode: containmentMode,
       terminalBuffered: true,
       descendantsReaped: true,
       clean: true,

package/src/agent-cli-provider/omp/sdk-process-runner.ts

@@ -60,6 +60,10 @@ export async function spawnOmpSdkProcess(
     const environment = childEnvironment(prepared.environmentPolicy, privateRuntime);
     const { payload, secretValues } = credentialPayload(prepared.credentialNames, process.env);
     const requestProvider = request.modelSelector.slice(0, request.modelSelector.indexOf('/'));
+    const requestContainmentMode =
+      request.executionContext === 'docker' || request.executionContext === 'benchmark'
+        ? 'container'
+        : 'host-process-tree';
     const sidecarPath = prepared.commandSpec.args[0] ?? '';
     if (
       !isAbsolute(prepared.commandSpec.binary) ||
@@ -70,7 +74,8 @@ export async function spawnOmpSdkProcess(
       Object.keys(prepared.commandSpec.env).length !== 0 ||
       prepared.semanticIdentity.requestedModelSelector !== request.modelSelector ||
       prepared.semanticIdentity.reasoningEffort !== request.reasoningEffort ||
-      prepared.semanticIdentity.provider !== requestProvider
+      prepared.semanticIdentity.provider !== requestProvider ||
+      prepared.containmentRequirement.mode !== requestContainmentMode
     ) {
       payload.fill(0);
       throw new OmpSdkProcessRunnerError(
@@ -258,6 +263,7 @@ export async function spawnOmpSdkProcess(
       secretValues,
       startedAt,
       externalAbort,
+      containmentMode: prepared.containmentRequirement.mode,
     });
 
     return {