@the-open-engine/zeroshot 6.39.0 → 6.39.2

package/src/foreground-benchmark-run.js

@@ -4,6 +4,7 @@ const { writeBenchmarkResultBundle } = require('./foreground-benchmark-files');
 const TERMINAL_TOPICS = ['CLUSTER_COMPLETE', 'CLUSTER_FAILED'];
 const VERIFIER_ELIGIBLE = new Set(['completed', 'task_failure']);
 const EXIT_CODES = Object.freeze({
+  task_failure: 23,
   provider_failure: 20,
   engine_failure: 21,
   cancelled: 22,
@@ -40,20 +41,24 @@ function requireSettledStatus(orchestrator, clusterId) {
   return status;
 }
 
-function writeForegroundResult({ orchestrator, cluster, clusterId, resultPath, cancelled }) {
-  const status = requireSettledStatus(orchestrator, clusterId);
-  const terminals = terminalMessages(cluster, clusterId);
-  let result;
+function buildForegroundResult({ orchestrator, cluster, clusterId, cancelled }) {
+  const finalRun = orchestrator.getFinalRun?.(clusterId);
+  const status = finalRun?.status || requireSettledStatus(orchestrator, clusterId);
+  const terminals = finalRun?.terminalMessages || terminalMessages(cluster, clusterId);
   if (cancelled && terminals.length === 0) {
-    result = buildCancelledResult({ runId: clusterId, agents: status.agents });
-  } else {
-    result = buildBenchmarkResult({
-      runId: clusterId,
-      terminalMessages: terminals,
-      agents: status.agents,
-    });
+    return buildCancelledResult({ runId: clusterId, agents: status.agents });
   }
-  const snapshot = cluster.messageBus.readSnapshot(clusterId);
+  return buildBenchmarkResult({
+    runId: clusterId,
+    terminalMessages: terminals,
+    agents: status.agents,
+  });
+}
+
+function writeForegroundResult({ orchestrator, cluster, clusterId, resultPath, cancelled }) {
+  const result = buildForegroundResult({ orchestrator, cluster, clusterId, cancelled });
+  const snapshot =
+    orchestrator.getFinalRun?.(clusterId)?.snapshot || cluster.messageBus.readSnapshot(clusterId);
   return writeBenchmarkResultBundle(resultPath, result, snapshot);
 }
 
@@ -64,8 +69,15 @@ function exitCodeForResult(result) {
   return exitCode;
 }
 
+function exitCodeForForegroundResult(result) {
+  if (result.outcome === 'completed') return 0;
+  return EXIT_CODES[result.outcome] ?? exitCodeForResult(result);
+}
+
 module.exports = {
+  buildForegroundResult,
   exitCodeForResult,
+  exitCodeForForegroundResult,
   isForegroundStatusSettled,
   terminalMessages,
   writeForegroundResult,

package/src/isolation-manager.js

@@ -34,6 +34,14 @@ const { resolveProviderCredentialPaths } = require('../lib/provider-credential-p
 const { getProvider } = require('./providers');
 const { readRepoSettings } = require('../lib/repo-settings');
 const { provisionClaudeCredentials } = require('./claude-credentials');
+const {
+  CopyContainmentError,
+  copyErrorFromPayload,
+  createCopyBoundary,
+  resolveCopyPath,
+  resolveSourcePath,
+  validateRelativePath,
+} = require('./copy-containment');
 
 const DEFAULT_WORKTREE_SETUP_TIMEOUT_MS = 15 * 60 * 1000;
 const FRESH_BASE_REF_PREFIX = 'refs/zeroshot/base-fetch';
@@ -1298,6 +1306,7 @@ class IsolationManager {
     // Phase 1: Collect all files and directories
     const files = [];
     const directories = new Set();
+    const copyBoundary = createCopyBoundary(src, dest);
 
     const shouldIgnoreFsError = (err) =>
       err.code === 'EACCES' || err.code === 'EPERM' || err.code === 'ENOENT';
@@ -1328,12 +1337,13 @@ class IsolationManager {
       }
     };
 
-    function handleEntry(entry, srcPath, relPath, relativePath) {
+    function handleEntry(entry, relPath, relativePath, ancestorDirectories) {
       if (entry.isSymbolicLink()) {
-        const targetStats = fs.statSync(srcPath);
+        const resolvedSourcePath = resolveSourcePath(copyBoundary, relPath);
+        const targetStats = fs.statSync(resolvedSourcePath);
         if (targetStats.isDirectory()) {
           directories.add(relPath);
-          collectFiles(srcPath, relPath);
+          collectFiles(relPath, ancestorDirectories);
           return;
         }
 
@@ -1344,7 +1354,7 @@ class IsolationManager {
 
       if (entry.isDirectory()) {
         directories.add(relPath);
-        collectFiles(srcPath, relPath);
+        collectFiles(relPath, ancestorDirectories);
         return;
       }
 
@@ -1352,7 +1362,15 @@ class IsolationManager {
       ensureParentDirTracked(relativePath);
     }
 
-    function collectFiles(currentSrc, relativePath = '') {
+    function collectFiles(relativePath = '', ancestorDirectories = new Set()) {
+      const currentSrc = relativePath
+        ? resolveSourcePath(copyBoundary, relativePath)
+        : copyBoundary.sourceRoot.canonicalPath;
+      if (ancestorDirectories.has(currentSrc)) {
+        throw new CopyContainmentError(relativePath, 'source directory symlink creates a cycle');
+      }
+      const childAncestors = new Set(ancestorDirectories);
+      childAncestors.add(currentSrc);
       const entries = readEntries(currentSrc);
 
       for (const entry of entries) {
@@ -1360,11 +1378,11 @@ class IsolationManager {
           continue;
         }
 
-        const srcPath = path.join(currentSrc, entry.name);
-        const relPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+        const entryName = validateRelativePath(entry.name);
+        const relPath = relativePath ? path.join(relativePath, entryName) : entryName;
 
         try {
-          handleEntry(entry, srcPath, relPath, relativePath);
+          handleEntry(entry, relPath, relativePath, childAncestors);
         } catch (err) {
           if (shouldIgnoreFsError(err)) {
             continue;
@@ -1374,7 +1392,7 @@ class IsolationManager {
       }
     }
 
-    collectFiles(src);
+    collectFiles();
 
     // Phase 2: Create directory structure (sequential - must exist before file copy)
     // Sort directories by depth to ensure parents are created before children
@@ -1385,7 +1403,7 @@ class IsolationManager {
     });
 
     for (const dir of sortedDirs) {
-      const destDir = path.join(dest, dir);
+      const { destinationPath: destDir } = resolveCopyPath(copyBoundary, dir);
       try {
         fs.mkdirSync(destDir, { recursive: true });
       } catch (err) {
@@ -1399,10 +1417,9 @@ class IsolationManager {
     // For small file counts (<100), use synchronous copy (worker overhead not worth it)
     if (files.length < 100) {
       for (const relPath of files) {
-        const srcPath = path.join(src, relPath);
-        const destPath = path.join(dest, relPath);
         try {
-          fs.copyFileSync(srcPath, destPath);
+          const { sourcePath, destinationPath } = resolveCopyPath(copyBoundary, relPath);
+          fs.copyFileSync(sourcePath, destinationPath);
         } catch (err) {
           if (err.code !== 'EACCES' && err.code !== 'EPERM' && err.code !== 'ENOENT') {
             throw err;
@@ -1424,18 +1441,22 @@ class IsolationManager {
     }
 
     // Spawn workers and wait for completion
+    const workers = [];
     const workerPromises = chunks.map((chunk) => {
       return new Promise((resolve, reject) => {
         const worker = new Worker(workerPath, {
           workerData: {
             files: chunk,
-            sourceBase: src,
-            destBase: dest,
+            sourceBase: copyBoundary.sourceRoot.canonicalPath,
+            destBase: copyBoundary.destinationRoot.canonicalPath,
+            expectedBoundary: copyBoundary,
           },
         });
+        workers.push(worker);
+        let result = null;
 
-        worker.on('message', (result) => {
-          resolve(result);
+        worker.on('message', (workerResult) => {
+          result = workerResult;
         });
 
         worker.on('error', (err) => {
@@ -1445,6 +1466,12 @@ class IsolationManager {
         worker.on('exit', (code) => {
           if (code !== 0) {
             reject(new Error(`Worker exited with code ${code}`));
+          } else if (!result) {
+            reject(new Error('Copy worker exited without reporting a result'));
+          } else if (result.error) {
+            reject(copyErrorFromPayload(result.error));
+          } else {
+            resolve(result);
           }
         });
       });
@@ -1453,7 +1480,12 @@ class IsolationManager {
     // Wait for all workers to complete (proper async/await - no busy-wait!)
     // FIX: Previous version used busy-wait which blocked the event loop,
     // preventing worker thread messages from being processed (timeout bug)
-    await Promise.all(workerPromises);
+    try {
+      await Promise.all(workerPromises);
+    } catch (err) {
+      await Promise.all(workers.map((worker) => worker.terminate().catch(() => undefined)));
+      throw err;
+    }
   }
 
   /**
@@ -2383,8 +2415,15 @@ class IsolationManager {
     // NEVER pass --volumes (irreversible data loss) and NEVER tear down a pinned/shared
     // Compose project — only a project scoped to the worktree directory basename, which is
     // the only kind zeroshot could itself have created, is touched.
-    const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
-    const teardown = resolveWorktreeComposeTeardown(worktreeInfo.path);
+    let teardown = { shouldTeardown: false };
+    try {
+      const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
+      teardown = resolveWorktreeComposeTeardown(worktreeInfo.path);
+    } catch (error) {
+      console.warn(
+        `[IsolationManager] Skipping Docker Compose teardown in ${worktreeInfo.path}: ${error.message}`
+      );
+    }
     if (teardown.shouldTeardown) {
       try {
         runSync('docker', teardown.args, {

package/src/legacy-lib/detached-startup.ts

@@ -26,6 +26,7 @@ interface RunOptions extends Record<string, unknown> {
   mergeQueue?: unknown;
   pr?: unknown;
   prBase?: unknown;
+  prBody?: unknown;
   ship?: unknown;
   worktree?: unknown;
 }
@@ -236,9 +237,10 @@ async function registerDetachedSetupCluster({
       setupStartedAt: Date.now(),
       setupStage: 'starting',
       autoPr: plan.delivery !== 'none',
-      prOptions: runOptions.prBase
+      prOptions: plan.delivery !== 'none'
         ? {
             prBase: runOptions.prBase,
+            prBody: typeof runOptions.prBody === 'string' ? runOptions.prBody : null,
             mergeQueue: runOptions.mergeQueue || false,
             closeIssue: runOptions.closeIssue || null,
             autoMerge: plan.autoMerge,

package/src/legacy-lib/git-remote-utils.ts

@@ -181,6 +181,25 @@ function parseGitRemoteUrl(remoteUrl: unknown): GitContext | null {
   return null;
 }
 
+function parseFetchRemoteLine(line: string): readonly [string, string] | null {
+  // 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.
@@ -205,15 +224,14 @@ function detectGitContext(cwd = process.cwd()): GitContextWithRemote | null {
 
     const supportedRemotes = new Map<string, GitContextWithRemote>();
     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/src/legacy-lib/start-cluster-environment.ts

@@ -10,6 +10,7 @@ interface RunOptions extends Record<string, unknown> {
   mount?: readonly string[] | null;
   noIsolation?: unknown;
   prBase?: unknown;
+  prBody?: unknown;
 }
 
 interface MountSpec {

package/src/legacy-lib/start-cluster-run-options.ts

@@ -28,6 +28,7 @@ interface RunOptions extends Record<string, unknown> {
   noMounts?: unknown;
   pr?: unknown;
   prBase?: unknown;
+  prBody?: unknown;
   preparedWorktree?: unknown;
   requiredQualityGates?: unknown;
   ship?: unknown;
@@ -201,6 +202,7 @@ function buildStartOptionsFromPlan({
     containerHome: optionalValue(options.containerHome),
     forceProvider: optionalValue(forceProvider),
     prBase: environment ? resolvePrBase(options) : optionalValue(options.prBase),
+    prBody: typeof options.prBody === 'string' ? options.prBody : undefined,
     mergeQueue: environment ? resolveMergeQueue(options) : optionalValue(options.mergeQueue),
     closeIssue: environment ? resolveCloseIssue(options) : optionalValue(options.closeIssue),
     ship: plan.delivery === 'ship',

package/src/omp-session-verifier.js

@@ -399,7 +399,10 @@ function streamSessionJsonl(fd, describePath, limits) {
         `${describePath} record ${records} is not valid JSON: ${error.message}`
       );
     }
-    if (header === null) header = parsed;
+    // OMP 17.2.1 may reserve its first JSONL record for mutable title metadata before writing the
+    // authoritative session record. Accept exactly that one known preamble position; every other
+    // ordering still fails closed in parseSessionHeader below.
+    if (header === null && !(records === 1 && parsed?.type === 'title')) header = parsed;
     collectCanonicalBlobRefs(parsed, blobRefs, limits);
   }
 
@@ -430,9 +433,9 @@ function streamSessionJsonl(fd, describePath, limits) {
   };
 }
 
-/** The session's first record is OMP's session header (`{type:"session", version, id, cwd, ...}` —
- * session-manager.ts `#resetToNewSession`). Its `id` is the authoritative session identity written
- * to disk and its `cwd` is the workspace the session belongs to. */
+/** The session header (`{type:"session", version, id, cwd, ...}`) is either the first record or
+ * follows OMP 17.2.1's single leading title-metadata record. Its `id` is the authoritative session
+ * identity written to disk and its `cwd` is the workspace the session belongs to. */
 function parseSessionHeader(header, describePath) {
   if (!header || typeof header !== 'object' || Array.isArray(header)) {
     fail('session-header-missing', `${describePath} has no session header record.`);
@@ -440,7 +443,7 @@ function parseSessionHeader(header, describePath) {
   if (header.type !== 'session') {
     fail(
       'session-header-invalid',
-      `${describePath} first record is type ${JSON.stringify(header.type)}, not "session".`
+      `${describePath} first non-title-preamble record is type ${JSON.stringify(header.type)}, not "session".`
     );
   }
   if (typeof header.id !== 'string' || header.id.length === 0) {

package/src/orchestrator.js

@@ -262,6 +262,7 @@ function buildPrOptions(options, requiredQualityGates) {
     prBase: options.prBase || null,
     mergeQueue: options.mergeQueue || false,
     closeIssue: options.closeIssue || null,
+    prBody: typeof options.prBody === 'string' ? options.prBody : null,
     gitRemote: options.gitRemote || null,
     autoMerge,
     ...(requiredQualityGates.length > 0 ? { requiredQualityGates } : {}),
@@ -306,6 +307,9 @@ class Orchestrator {
     this.closed = false;
     this._conductorWatchdogs = new Set();
     this._clusterRunBoundaries = new Map();
+    // Successful auto-cleanup closes and removes the live cluster before a foreground caller can
+    // build its authoritative result. Preserve only the bounded terminal handoff for this process.
+    this._finalRuns = new Map();
 
     // Track if clusters are loaded (for lazy loading pattern)
     this._clustersLoaded = options.skipLoad === true;
@@ -2038,6 +2042,7 @@ class Orchestrator {
       prBase: options.prBase,
       mergeQueue: options.mergeQueue,
       closeIssue: options.closeIssue,
+      prBody: options.prBody,
       requiredQualityGates: options.requiredQualityGates,
       autoMerge: resolveRunPlan(options).autoMerge,
       gitRemote: gitContext?.remote || options.gitRemote,
@@ -2155,8 +2160,16 @@ class Orchestrator {
     // NEVER pass --volumes (irreversible data loss) and NEVER tear down a pinned/shared
     // Compose project — only a project scoped to the worktree directory basename, which is
     // the only kind zeroshot could itself have created, is touched.
-    const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
-    const teardown = resolveWorktreeComposeTeardown(worktreePath);
+    let teardown;
+    try {
+      const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
+      teardown = resolveWorktreeComposeTeardown(worktreePath);
+    } catch (error) {
+      this._log(
+        `[Orchestrator] Skipping Docker Compose teardown in ${worktreePath}: ${error.message}`
+      );
+      return;
+    }
     if (!teardown.shouldTeardown) {
       if (teardown.composePath) {
         this._log(
@@ -2420,6 +2433,7 @@ class Orchestrator {
     cluster.pid = null; // Clear PID - cluster is no longer running
 
     if (shouldAutoCleanWorktree) {
+      this._captureFinalRun(clusterId, cluster);
       // Close message bus and ledger (same as kill() path)
       cluster.messageBus.close();
     }
@@ -2552,6 +2566,35 @@ class Orchestrator {
         cluster.messageBus.close();
       }
     }
+    this._finalRuns.clear();
+  }
+
+  _captureFinalRun(clusterId, cluster) {
+    const snapshot = cluster.messageBus.readSnapshot(clusterId);
+    const terminalMessages = ['CLUSTER_COMPLETE', 'CLUSTER_FAILED']
+      .flatMap((topic) => cluster.messageBus.query({ cluster_id: clusterId, topic }))
+      .sort((left, right) => {
+        const a = BigInt(left.sequence);
+        const b = BigInt(right.sequence);
+        return a < b ? -1 : a > b ? 1 : 0;
+      });
+    this._finalRuns.set(clusterId, {
+      snapshot,
+      terminalMessages,
+      status: {
+        id: clusterId,
+        state: cluster.state,
+        isZombie: false,
+        pid: null,
+        createdAt: cluster.createdAt,
+        agents: cluster.agents.map((agent) => agent.getState()),
+        messageCount: snapshot.messageCount,
+        setupLogPath: cluster.setupLogPath || null,
+        setupStage: cluster.setupStage || null,
+        failureInfo: cluster.failureInfo || null,
+        runMode: cluster.runMode || null,
+      },
+    });
   }
 
   /**
@@ -4217,7 +4260,7 @@ Continue from where you left off. Review your previous output to understand what
 
       // Get issue context from ledger
       const issueMsg = cluster.messageBus.ledger.findLast({ topic: 'ISSUE_OPENED' });
-      const issueNumber = issueMsg?.content?.data?.number || 'unknown';
+      const issueNumber = issueMsg?.content?.data?.issue_number || 'unknown';
       const issueTitle = issueMsg?.content?.data?.title || 'Implementation';
 
       // Generate the final prompt in one typed assembly pass. Issue values are
@@ -4290,11 +4333,16 @@ Continue from where you left off. Review your previous output to understand what
    * @returns {Object} Cluster status
    */
   getStatus(clusterId) {
+    const finalRun = this._finalRuns.get(clusterId);
+    if (finalRun) return finalRun.status;
     const cluster = this.clusters.get(clusterId);
     if (!cluster) {
       throw new Error(`Cluster ${clusterId} not found`);
     }
+    return this._getLiveStatus(clusterId, cluster);
+  }
 
+  _getLiveStatus(clusterId, cluster) {
     // Detect zombie clusters: state=running but no backing process
     let state = cluster.state;
     let isZombie = false;
@@ -4378,6 +4426,10 @@ Continue from where you left off. Review your previous output to understand what
     return this.clusters.get(clusterId);
   }
 
+  getFinalRun(clusterId) {
+    return this._finalRuns.get(clusterId) || null;
+  }
+
   /**
    * Export cluster conversation
    * @param {String} clusterId - Cluster ID

package/src/pr-body-template.js

@@ -0,0 +1,71 @@
+const MAX_PR_BODY_LENGTH = 65536;
+
+function normalizeIssueNumber(value) {
+  const candidate = typeof value === 'number' ? String(value) : value;
+  if (typeof candidate !== 'string') return 'unknown';
+  const trimmed = candidate.trim();
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed) ? trimmed : 'unknown';
+}
+
+function normalizeIssueTitle(value) {
+  if (typeof value !== 'string' || value.trim() === '') return 'Implementation';
+  const normalized = [...value]
+    .map((character) => {
+      const codePoint = character.codePointAt(0);
+      return codePoint < 0x20 || codePoint === 0x7f ? ' ' : character;
+    })
+    .join('')
+    .trim();
+  return normalized || 'Implementation';
+}
+
+function resolveIssueContext(options = {}) {
+  const issueNumber = normalizeIssueNumber(options.issueNumber);
+  const issueTitle = normalizeIssueTitle(options.issueTitle);
+  const issueReference =
+    options.includeIssueReference === false || issueNumber === 'unknown'
+      ? ''
+      : `Closes #${issueNumber}`;
+  return { issueNumber, issueTitle, issueReference };
+}
+
+function normalizePrBodyTemplate(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'string') throw new TypeError('PR body template must be a string');
+  if (value.includes('\0')) throw new TypeError('PR body template must not contain NUL bytes');
+  if (value.length > MAX_PR_BODY_LENGTH) {
+    throw new TypeError(`PR body template must not exceed ${MAX_PR_BODY_LENGTH} characters`);
+  }
+  return value;
+}
+
+/**
+ * Render a bounded PR body. Missing issue metadata expands to empty text so
+ * manual tasks never leak internal sentinel values into pull requests.
+ */
+function renderPullRequestBody(template, options = {}) {
+  const issueContext = resolveIssueContext(options);
+  const normalizedTemplate = normalizePrBodyTemplate(template);
+  if (normalizedTemplate === null) return issueContext.issueReference;
+
+  const hasIssue = issueContext.issueNumber !== 'unknown';
+  const substitutions = {
+    '{{issue_number}}': hasIssue ? issueContext.issueNumber : '',
+    '{{issue_title}}': hasIssue ? issueContext.issueTitle : '',
+    '{{issue_reference}}': hasIssue ? issueContext.issueReference : '',
+  };
+  let rendered = normalizedTemplate;
+  for (const [token, replacement] of Object.entries(substitutions)) {
+    rendered = rendered.replaceAll(token, replacement);
+  }
+  if (rendered.length > MAX_PR_BODY_LENGTH) {
+    throw new TypeError(`Rendered PR body must not exceed ${MAX_PR_BODY_LENGTH} characters`);
+  }
+  return rendered;
+}
+
+module.exports = {
+  MAX_PR_BODY_LENGTH,
+  renderPullRequestBody,
+  resolveIssueContext,
+};

package/src/preflight.js

@@ -29,6 +29,10 @@ const {
 } = require('../lib/provider-names');
 const { detectGitContext } = require('../lib/git-remote-utils');
 const { readKeychainCredentials } = require('./claude-credentials');
+const {
+  TASK_EXECUTION_CONTEXT_ENV,
+  resolveTaskExecutionContext,
+} = require('./task-execution-context');
 
 /**
  * Validation result
@@ -164,6 +168,13 @@ function checkClaudeAuth() {
     ...(method && { method }),
   });
 
+  // Claude Code supports gateway bearer authentication independently of Anthropic API keys.
+  // This is the documented path for OpenRouter and enterprise LLM gateways, where
+  // ANTHROPIC_API_KEY is intentionally present but empty to avoid credential conflicts.
+  if (process.env.ANTHROPIC_AUTH_TOKEN) {
+    return authResult(true, null, 'auth_token');
+  }
+
   // Check for Bedrock bearer token (highest priority)
   if (process.env.AWS_BEARER_TOKEN_BEDROCK) {
     if (!process.env.AWS_REGION) {
@@ -481,7 +492,7 @@ function validateProviderExecutionSettings(providerName, settings, options) {
     return [];
   }
 
-  const executionContext = options.requireDocker ? 'docker' : 'detached';
+  const executionContext = resolvePreflightExecutionContext(options);
   const error = metadata.settingsValidator(providerSettings, { executionContext });
   if (!error) return [];
 
@@ -519,11 +530,20 @@ function validateProvider(providerName, options) {
     return { errors: [...isolationErrors, ...result.errors], warnings: result.warnings };
   }
 
-  const result = validateRegistryCliProvider(providerName);
+  const result = validateRegistryCliProvider(
+    providerName,
+    resolvePreflightExecutionContext(options)
+  );
   return { errors: [...isolationErrors, ...result.errors], warnings: result.warnings };
 }
 
-function validateRegistryCliProvider(providerName) {
+function resolvePreflightExecutionContext(options) {
+  const executionContext =
+    options.executionContext ?? (options.requireDocker ? 'docker' : 'detached');
+  return resolveTaskExecutionContext({ [TASK_EXECUTION_CONTEXT_ENV]: executionContext });
+}
+
+function validateRegistryCliProvider(providerName, executionContext) {
   const metadata = getProviderMetadata(providerName);
   const { command } = resolveProviderCommand(providerName);
   const installSteps = metadata.installInstructions.split('\n').filter(Boolean);
@@ -537,7 +557,7 @@ function validateRegistryCliProvider(providerName) {
   }
 
   const { getProvider } = require('./providers');
-  if (getProvider(providerName).isAvailable()) {
+  if (getProvider(providerName).isAvailable({ executionContext })) {
     return { errors: [], warnings: [] };
   }
 
@@ -642,6 +662,7 @@ function validateGitRequirement() {
  * @param {boolean} options.quiet - Suppress success messages
  * @param {string} options.claudeCommand - Custom Claude command (from settings)
  * @param {string} options.provider - Provider override
+ * @param {'host'|'detached'|'docker'|'benchmark'} options.executionContext - Provider execution boundary
  * @returns {ValidationResult}
  */
 async function runPreflight(options = {}) {
@@ -670,10 +691,14 @@ async function runPreflight(options = {}) {
   const providerName = normalizeProviderName(
     options.provider || settings.defaultProvider || getDefaultProviderId()
   );
+  const providerOptions = {
+    ...options,
+    executionContext: resolvePreflightExecutionContext(options),
+  };
 
-  const providerResult = validateProvider(providerName, options);
+  const providerResult = validateProvider(providerName, providerOptions);
   errors.push(...providerResult.errors);
-  errors.push(...validateProviderExecutionSettings(providerName, settings, options));
+  errors.push(...validateProviderExecutionSettings(providerName, settings, providerOptions));
   warnings.push(...providerResult.warnings);
 
   // 4. Check issue provider CLI (if required)

package/src/providers/index.js

@@ -32,13 +32,13 @@ class RuntimeProvider extends BaseProvider {
     return this._adapter;
   }
 
-  isAvailable() {
+  isAvailable(context = {}) {
     if (this._usesBundledRunner()) {
-      return helper.probeRuntimeProviderCli(this.name).available;
+      return helper.probeRuntimeProviderCli(this.name, undefined, undefined, context).available;
     }
     const { command } = resolveProviderCommand(this.name);
     if (!commandExists(command)) return false;
-    return helper.probeRuntimeProviderCli(this.name).available;
+    return helper.probeRuntimeProviderCli(this.name, undefined, undefined, context).available;
   }
 
   getCliPath() {