@the-open-engine/zeroshot 6.39.1 → 6.39.2

package/lib/cluster-worker/engine-adapter-common.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const { MAX_SUMMARY_BYTES } = require('./contracts');
+
+const DEFAULT_COMPLETION_SUMMARY = 'Cluster completed';
 const PUBLIC_ADAPTER_METHODS = Object.freeze([
   'start',
   'status',
@@ -8,6 +11,20 @@ const PUBLIC_ADAPTER_METHODS = Object.freeze([
   'close',
 ]);
 
+function completionSummary(value) {
+  const summary = typeof value === 'string' ? value : DEFAULT_COMPLETION_SUMMARY;
+  if (Buffer.byteLength(summary, 'utf8') <= MAX_SUMMARY_BYTES) return summary;
+  let bounded = '';
+  let bytes = 0;
+  for (const character of summary) {
+    const characterBytes = Buffer.byteLength(character, 'utf8');
+    if (bytes + characterBytes > MAX_SUMMARY_BYTES) break;
+    bounded += character;
+    bytes += characterBytes;
+  }
+  return bounded;
+}
+
 function createAdapterFacade(adapter) {
   return Object.freeze(
     Object.fromEntries(PUBLIC_ADAPTER_METHODS.map((name) => [name, adapter[name].bind(adapter)]))
@@ -30,6 +47,7 @@ function frozenResourceStatus(resource, state, details) {
 }
 
 module.exports = {
+  completionSummary,
   createAdapterFacade,
   declaredFailureEvent,
   frozenResourceStatus,

package/lib/cluster-worker/engine-adapter.js

@@ -3,6 +3,7 @@
 const { cloneJson } = require('./object-utils');
 const { inputFromRequest } = require('./engine-input');
 const {
+  completionSummary,
   createAdapterFacade,
   declaredFailureEvent,
   frozenResourceStatus,
@@ -26,7 +27,7 @@ function terminalEventFromMessage(message) {
   if (message.topic === 'CLUSTER_COMPLETE') {
     return {
       type: 'complete',
-      summary: data.reason || message.content?.text,
+      summary: completionSummary(data.reason || message.content?.text),
       ...completionPayload(data),
     };
   }

package/lib/git-remote-utils.js

@@ -124,6 +124,24 @@ function parseGitRemoteUrl(remoteUrl) {
     }
     return null;
 }
+function parseFetchRemoteLine(line) {
+    // Partial clones append their filter after the fetch marker, for example
+    // `origin https://github.com/org/repo.git (fetch) [blob:none]`.
+    const fetchMarker = ' (fetch)';
+    const fetchMarkerIndex = line.lastIndexOf(fetchMarker);
+    if (fetchMarkerIndex < 1)
+        return null;
+    const suffix = line.slice(fetchMarkerIndex + fetchMarker.length);
+    if (suffix.length > 0 && !(suffix.startsWith(' [') && suffix.endsWith(']')))
+        return null;
+    const remoteLine = line.slice(0, fetchMarkerIndex);
+    const separatorIndex = remoteLine.search(/\s/);
+    if (separatorIndex < 1) {
+        return null;
+    }
+    const remoteUrl = remoteLine.slice(separatorIndex).trim();
+    return remoteUrl.length > 0 ? [remoteLine.slice(0, separatorIndex), remoteUrl] : null;
+}
 /**
  * Detect git repository context from current working directory.
  * Returns provider context extracted from git remote URL.
@@ -147,14 +165,13 @@ function detectGitContext(cwd = process.cwd()) {
         });
         const supportedRemotes = new Map();
         for (const line of remoteOutput.split(/\r?\n/)) {
-            const match = /^(\S+)\s+(.+)\s+\(fetch\)$/.exec(line);
-            if (!match) {
+            const remoteParts = parseFetchRemoteLine(line);
+            if (!remoteParts) {
                 continue;
             }
-            const remoteCandidate = match[1];
-            const remoteUrl = match[2];
+            const [remoteCandidate, remoteUrl] = remoteParts;
             const remote = normalizeGitRemoteName(remoteCandidate);
-            if (!remote || remoteUrl === undefined) {
+            if (!remote) {
                 continue;
             }
             const context = parseGitRemoteUrl(remoteUrl);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.39.1",
+  "version": "6.39.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@the-open-engine/zeroshot",
-      "version": "6.39.1",
+      "version": "6.39.2",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.39.1",
+  "version": "6.39.2",
   "description": "Independent executor–verifier orchestration for software changes.",
   "main": "src/orchestrator.js",
   "bin": {
@@ -47,6 +47,7 @@
     "typecheck:task-lib": "tsc --project tsconfig.task-lib.json",
     "typecheck:hosted-target": "tsc --project tsconfig.hosted-target.json",
     "typecheck:hosted-session": "tsc --project tsconfig.hosted-session.json",
+    "pretest:hosted": "npm run build:legacy-runtime",
     "test:hosted": "npm run build:cluster && node --test tests/private-hosted-cli/*.test.js && npm run test:hosted-target",
     "test:hosted-target": "npm run build:cluster && npm run build:target && node --test tests/hosted-target/*.test.ts",
     "test:target": "npm run build:agent-cli-provider && npm run build:target && node --test tests/target/*.test.ts",

package/scripts/omp/runtime-identities.js

@@ -10,6 +10,7 @@ const BUN_PACKAGE_NAME = 'bun';
 const BUN_RUNTIME_VERSION = '1.3.14';
 const SIDECAR_RELATIVE_PATH = path.join('scripts', 'omp', 'sidecar.ts');
 const HOST_SUPERVISOR_RELATIVE_PATH = path.join('scripts', 'omp', 'host-supervisor.ts');
+const ACTIVE_CONTAINER_INVOCATION = Symbol('active-container-invocation');
 const HOST_SDK_PLATFORM_KEYS = Object.freeze(['linux:arm64', 'linux:x64']);
 
 const BUN_PLATFORM_PACKAGES = Object.freeze({
@@ -227,24 +228,26 @@ function resolveOmpSdkRuntime(options = {}) {
   if (!fileExists(hostSupervisorPath)) {
     throw new Error(`OMP SDK host supervisor is missing: ${hostSupervisorPath}`);
   }
-  let containmentProbe;
-  try {
-    containmentProbe = JSON.parse(
-      String(readContainmentProbe(bunExecutable, hostSupervisorPath)).trim()
-    );
-  } catch (error) {
-    throw new Error(`Unable to attest Linux subreaper/pidfd containment: ${error.message}`);
-  }
-  if (
-    containmentProbe?.protocolVersion !== 1 ||
-    containmentProbe?.type !== 'cleanup-attestation' ||
-    containmentProbe?.status !== 'clean' ||
-    containmentProbe?.mode !== 'linux-subreaper-pidfd' ||
-    containmentProbe?.subreaper !== true ||
-    containmentProbe?.pidfd !== true ||
-    containmentProbe?.ownedProcessCount !== 0
-  ) {
-    throw new Error('Linux subreaper/pidfd containment probe returned invalid evidence');
+  if (runtimeOptions.activeInvocation !== ACTIVE_CONTAINER_INVOCATION) {
+    let containmentProbe;
+    try {
+      containmentProbe = JSON.parse(
+        String(readContainmentProbe(bunExecutable, hostSupervisorPath)).trim()
+      );
+    } catch (error) {
+      throw new Error(`Unable to attest Linux subreaper/pidfd containment: ${error.message}`);
+    }
+    if (
+      containmentProbe?.protocolVersion !== 1 ||
+      containmentProbe?.type !== 'cleanup-attestation' ||
+      containmentProbe?.status !== 'clean' ||
+      containmentProbe?.mode !== 'linux-subreaper-pidfd' ||
+      containmentProbe?.subreaper !== true ||
+      containmentProbe?.pidfd !== true ||
+      containmentProbe?.ownedProcessCount !== 0
+    ) {
+      throw new Error('Linux subreaper/pidfd containment probe returned invalid evidence');
+    }
   }
   return Object.freeze({
     bunExecutable,
@@ -261,6 +264,15 @@ function resolveOmpSdkRuntime(options = {}) {
     sidecarPath,
   });
 }
+
+function resolveOmpSdkContainerRuntime(options = {}) {
+  // Image inspection may run as PID 1, where no parent process exists to supervise. The actual
+  // provider invocation still starts the supervisor and requires its final cleanup attestation.
+  return resolveOmpSdkRuntime({
+    ...options,
+    activeInvocation: ACTIVE_CONTAINER_INVOCATION,
+  });
+}
 module.exports = {
   BUN_PACKAGE_INTEGRITY,
   BUN_PACKAGE_NAME,
@@ -279,5 +291,6 @@ module.exports = {
   REQUIRED_OMP_SDK_SOURCES,
   SIDECAR_RELATIVE_PATH,
   assertPackageIdentity,
+  resolveOmpSdkContainerRuntime,
   resolveOmpSdkRuntime,
 };

package/scripts/omp/runtime.js

@@ -12,6 +12,7 @@ const {
   REQUIRED_OMP_SDK_SOURCES,
   SIDECAR_RELATIVE_PATH,
   assertPackageIdentity,
+  resolveOmpSdkContainerRuntime,
   resolveOmpSdkRuntime,
 } = require('./runtime-identities');
 const { validateOmpSdkReleaseAssets } = require('./runtime-release');
@@ -28,6 +29,7 @@ module.exports = {
   REQUIRED_OMP_SDK_SOURCES,
   SIDECAR_RELATIVE_PATH,
   assertPackageIdentity,
+  resolveOmpSdkContainerRuntime,
   resolveOmpSdkRuntime,
   validateOmpSdkReleaseAssets,
 };

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),
+  };
+}