@the-open-engine/zeroshot 6.39.1 → 6.40.0

package/src/claude-task-runner.js

@@ -11,6 +11,7 @@ const TaskRunner = require('./task-runner');
 const { loadSettings } = require('../lib/settings');
 const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
+const { decodeTaskLogLine } = require('./task-log-line');
 const { prependWorktreeToolBinToEnv } = require('./worktree-tooling-env');
 const { applyDarwinKeychainBoundaryToEnv } = require('./darwin-keychain-boundary');
 const { getTask, getTaskBySpawnOwnershipToken } = require('../task-lib/store.js');
@@ -556,18 +557,17 @@ class ClaudeTaskRunner extends TaskRunner {
       const broadcastLine = (line) => {
         if (!line.trim()) return;
 
-        let content = line;
-        const timestampMatch = line.match(/^\[(\d{13})\](.*)$/);
-        if (timestampMatch) {
-          content = timestampMatch[2];
-        }
+        const decoded = decodeTaskLogLine(line);
+        if (!decoded.providerOutput) return;
+        const content = decoded.content;
 
         // Skip non-JSON patterns
         if (
-          content.startsWith('===') ||
-          content.startsWith('Finished:') ||
-          content.startsWith('Exit code:') ||
-          (content.includes('"type":"system"') && content.includes('"subtype":"init"'))
+          decoded.channel !== 'provider_stdout' &&
+          (content.startsWith('===') ||
+            content.startsWith('Finished:') ||
+            content.startsWith('Exit code:') ||
+            (content.includes('"type":"system"') && content.includes('"subtype":"init"')))
         ) {
           return;
         }

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/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/stream-json-parser.ts

@@ -16,9 +16,16 @@ interface ProviderFacade {
   listProviders(): string[];
 }
 
+interface TaskLogDecoder {
+  decodeTaskLogLine(line: string): { content: string; providerOutput: boolean };
+}
+
 // The runtime facade is maintained JavaScript; keep its original emitted require path.
 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { getProvider, listProviders }: ProviderFacade = require('../src/providers');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const taskLogDecoder: TaskLogDecoder = require('../src/task-log-line');
+const { decodeTaskLogLine } = taskLogDecoder;
 
 function createProviderParsers(): ProviderParser[] {
   return listProviders().map((name) => getProvider(name));
@@ -26,11 +33,9 @@ function createProviderParsers(): ProviderParser[] {
 
 function stripTimestampPrefix(line: unknown): string {
   if (!line || typeof line !== 'string') return '';
-  let trimmed = line.trim().replace(/\r$/, '');
-  if (!trimmed) return '';
-
-  const tsMatch = /^\[(\d{13})\](.*)$/.exec(trimmed);
-  if (tsMatch) trimmed = (tsMatch[2] || '').trimStart();
+  const decoded = decodeTaskLogLine(line.trim());
+  if (!decoded.providerOutput) return '';
+  const trimmed = decoded.content;
 
   if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
     const pipeMatch = /^[^|]{1,40}\|\s*(.*)$/.exec(trimmed);

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

@@ -307,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;
@@ -2430,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();
     }
@@ -2562,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,
+      },
+    });
   }
 
   /**
@@ -4300,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;
@@ -4388,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/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

@@ -6,6 +6,7 @@ const {
 } = require('../../lib/provider-names');
 const { commandExists, getCommandPath } = require('../../lib/provider-detection');
 const helper = require('../../lib/agent-cli-provider');
+const { stripTimestampPrefix } = require('../../lib/agent-cli-provider/log-prefix');
 
 const warned = new Set();
 
@@ -32,13 +33,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() {
@@ -218,25 +219,6 @@ function listProviders() {
   return helper.listProviderAdapters();
 }
 
-function stripTimestampPrefix(line) {
-  if (!line || typeof line !== 'string') return '';
-  let trimmed = line.trim().replace(/\r$/, '');
-  if (!trimmed) return '';
-
-  const tsMatch = trimmed.match(/^\[(\d{13})\](.*)$/);
-  if (tsMatch) trimmed = (tsMatch[2] || '').trimStart();
-
-  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
-    const pipeMatch = trimmed.match(/^[^|]{1,40}\|\s*(.*)$/);
-    if (pipeMatch) {
-      const afterPipe = (pipeMatch[1] || '').trimStart();
-      if (afterPipe.startsWith('{') || afterPipe.startsWith('[')) return afterPipe;
-    }
-  }
-
-  return trimmed;
-}
-
 function collectEvents(events, event) {
   if (!event) return;
   if (Array.isArray(event)) {

package/src/task-execution-context.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const TASK_EXECUTION_CONTEXT_ENV = 'ZEROSHOT_TASK_EXECUTION_CONTEXT';
+const TASK_EXECUTION_CONTEXTS = Object.freeze(['host', 'detached', 'docker', 'benchmark']);
+const taskExecutionContexts = new Set(TASK_EXECUTION_CONTEXTS);
+
+function resolveTaskExecutionContext(environment = process.env) {
+  const context = environment[TASK_EXECUTION_CONTEXT_ENV];
+  if (context === undefined) return 'detached';
+  if (!taskExecutionContexts.has(context)) {
+    throw new Error(
+      `${TASK_EXECUTION_CONTEXT_ENV} must be one of: ${TASK_EXECUTION_CONTEXTS.join(', ')}.`
+    );
+  }
+  return context;
+}
+
+module.exports = {
+  TASK_EXECUTION_CONTEXT_ENV,
+  TASK_EXECUTION_CONTEXTS,
+  resolveTaskExecutionContext,
+};

package/src/task-log-line.d.ts

@@ -0,0 +1,20 @@
+export const TASK_LOG_V2_MARKER: '[ZEROSHOT][LOG_FORMAT] channel-framed-v2';
+export const TASK_LOG_STDOUT_PREFIX: '[ZEROSHOT][PROVIDER_STDOUT] ';
+export const TASK_LOG_STDERR_PREFIX: '[ZEROSHOT][PROVIDER_STDERR] ';
+
+export type TaskLogChannel = 'provider_stdout' | 'provider_stderr' | 'control' | 'legacy';
+export type TaskLogFormat = 'stderr-tagged-v1' | 'channel-framed-v2' | null;
+
+export interface DecodedTaskLogLine {
+  readonly channel: TaskLogChannel;
+  readonly content: string;
+  readonly format: TaskLogFormat;
+  readonly providerOutput: boolean;
+  readonly timestamp: number | null;
+  readonly timestamped: boolean;
+}
+
+export function decodeTaskLogLine(line: string): DecodedTaskLogLine;
+export function formatTaskLogMarker(timestamp: number): string;
+export function formatTaskLogStderr(timestamp: number, content: string): string;
+export function formatTaskLogStdout(timestamp: number, content: string): string;

package/src/task-log-line.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const TASK_LOG_V2_MARKER = '[ZEROSHOT][LOG_FORMAT] channel-framed-v2';
+const TASK_LOG_STDOUT_PREFIX = '[ZEROSHOT][PROVIDER_STDOUT] ';
+const TASK_LOG_STDERR_PREFIX = '[ZEROSHOT][PROVIDER_STDERR] ';
+const TASK_LOG_V1_MARKER = '[ZEROSHOT][LOG_FORMAT] stderr-tagged-v1';
+const CONTROL_LINE =
+  /^\[(?:ATTACH|CLEANUP|CRASH|DETACH|ERROR|OMP-OWNERSHIP|SDK-DIAGNOSTIC|SYSTEM)\](?:\s|$)/;
+
+function timestampParts(line) {
+  const normalized = line.replace(/\r$/, '');
+  const match = /^\[(\d{13}|\d{4}-\d{2}-\d{2}T[^\]]+)\](.*)$/.exec(normalized);
+  if (!match) return { content: normalized, timestamp: null };
+  const rawTimestamp = match[1];
+  const epochTimestamp = /^\d{13}$/.test(rawTimestamp);
+  const timestamp = epochTimestamp
+    ? Number.parseInt(rawTimestamp, 10)
+    : new Date(rawTimestamp).getTime();
+  return {
+    content: match[2].trimStart(),
+    timestamp: Number.isFinite(timestamp) ? timestamp : null,
+  };
+}
+
+function decodeTaskLogLine(line) {
+  const { content, timestamp } = timestampParts(line);
+  const common = { timestamp, timestamped: timestamp !== null };
+  if (content.startsWith(TASK_LOG_STDOUT_PREFIX)) {
+    return {
+      ...common,
+      channel: 'provider_stdout',
+      content: content.slice(TASK_LOG_STDOUT_PREFIX.length),
+      format: null,
+      providerOutput: true,
+    };
+  }
+  if (content.startsWith(TASK_LOG_STDERR_PREFIX)) {
+    return {
+      ...common,
+      channel: 'provider_stderr',
+      content: content.slice(TASK_LOG_STDERR_PREFIX.length),
+      format: null,
+      providerOutput: false,
+    };
+  }
+  let format = null;
+  if (content === TASK_LOG_V2_MARKER) format = 'channel-framed-v2';
+  else if (content === TASK_LOG_V1_MARKER) format = 'stderr-tagged-v1';
+  const control =
+    format !== null || content.startsWith('[ZEROSHOT][FATAL] ') || CONTROL_LINE.test(content);
+  return {
+    ...common,
+    channel: control ? 'control' : 'legacy',
+    content,
+    format,
+    providerOutput: !control,
+  };
+}
+
+function formatTaskLogMarker(timestamp) {
+  return `[${timestamp}]${TASK_LOG_V2_MARKER}\n`;
+}
+
+function formatTaskLogStdout(timestamp, content) {
+  return `[${timestamp}]${TASK_LOG_STDOUT_PREFIX}${content}\n`;
+}
+
+function formatTaskLogStderr(timestamp, content) {
+  return `[${timestamp}]${TASK_LOG_STDERR_PREFIX}${content}\n`;
+}
+
+module.exports = {
+  TASK_LOG_STDERR_PREFIX,
+  TASK_LOG_STDOUT_PREFIX,
+  TASK_LOG_V2_MARKER,
+  decodeTaskLogLine,
+  formatTaskLogMarker,
+  formatTaskLogStderr,
+  formatTaskLogStdout,
+};

package/src/watcher-prompt-channel.js

@@ -4,7 +4,7 @@
  * The OMP prompt is task content (repository text, instructions, whatever a caller pasted in), so
  * it must never travel in the watcher's argv: `ps` and /proc/<pid>/cmdline expose argv to every
  * local user for the entire lifetime of a long-lived watcher. task-lib/runner.js therefore hands
- * the prompt to task-lib/rpc-watcher.js over the anonymous stdin pipe fork() creates for it. The
+ * the prompt to task-lib/rpc-watcher.js over its anonymous stdin pipe. The
  * pipe has exactly two ends and no name, so nothing is written to the filesystem, the task log, or
  * the ledger while the prompt is in transit.
  *

package/src/worktree-claude-config.js

@@ -12,6 +12,11 @@ const CLAUDE_SETTINGS_ENV = 'ZEROSHOT_CLAUDE_SETTINGS_FILE';
 const CLAUDE_MCP_CONFIG_ENV = 'ZEROSHOT_CLAUDE_MCP_CONFIG_FILE';
 const ASK_USER_HOOK = 'block-ask-user-question.py';
 const DANGEROUS_GIT_HOOK = 'block-dangerous-git.py';
+const ALTERNATE_BACKEND_ENV = [
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_VERTEX',
+    'CLAUDE_CODE_USE_FOUNDRY',
+];
 function isMutableRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -109,6 +114,25 @@ function ensureDangerousGitHook(targetClaudeDir) {
         writeSettings(settingsPath, settings);
     }
 }
+function ensureExplicitGatewayBackend(targetClaudeDir, environment) {
+    if (!environment.ANTHROPIC_AUTH_TOKEN?.trim() || !environment.ANTHROPIC_BASE_URL?.trim())
+        return;
+    const overlayDir = requireTargetClaudeDir(targetClaudeDir);
+    const settingsPath = path.join(overlayDir, SETTINGS_BASENAME);
+    const settings = readSettings(settingsPath);
+    const existingEnv = settings.env;
+    let env = {};
+    if (existingEnv !== undefined) {
+        if (!isMutableRecord(existingEnv)) {
+            throw new TypeError('Claude settings env must be an object.');
+        }
+        env = { ...existingEnv };
+    }
+    for (const name of ALTERNATE_BACKEND_ENV)
+        env[name] = '0';
+    settings.env = env;
+    writeSettings(settingsPath, settings);
+}
 function prepareClaudeSettingsOverlay(options = {}) {
     const overlayDir = fs.mkdtempSync(path.join(os.tmpdir(), OVERLAY_PREFIX));
     fs.chmodSync(overlayDir, 0o700);
@@ -116,6 +140,7 @@ function prepareClaudeSettingsOverlay(options = {}) {
         ensureAskUserQuestionHook(overlayDir);
         if (options.includeDangerousGit)
             ensureDangerousGitHook(overlayDir);
+        ensureExplicitGatewayBackend(overlayDir, options.environment || process.env);
         return path.join(overlayDir, SETTINGS_BASENAME);
     }
     catch (error) {

package/src/worktree-claude-config.ts

@@ -19,6 +19,7 @@ interface HookEntry {
 
 interface OverlayOptions {
   includeDangerousGit?: boolean;
+  environment?: NodeJS.ProcessEnv;
 }
 
 interface WorktreeOptions {
@@ -34,6 +35,11 @@ const CLAUDE_SETTINGS_ENV = 'ZEROSHOT_CLAUDE_SETTINGS_FILE';
 const CLAUDE_MCP_CONFIG_ENV = 'ZEROSHOT_CLAUDE_MCP_CONFIG_FILE';
 const ASK_USER_HOOK = 'block-ask-user-question.py';
 const DANGEROUS_GIT_HOOK = 'block-dangerous-git.py';
+const ALTERNATE_BACKEND_ENV = [
+  'CLAUDE_CODE_USE_BEDROCK',
+  'CLAUDE_CODE_USE_VERTEX',
+  'CLAUDE_CODE_USE_FOUNDRY',
+] as const;
 
 function isMutableRecord(value: unknown): value is MutableRecord {
   return typeof value === 'object' && value !== null;
@@ -155,12 +161,34 @@ function ensureDangerousGitHook(targetClaudeDir: unknown): void {
   }
 }
 
+function ensureExplicitGatewayBackend(
+  targetClaudeDir: unknown,
+  environment: NodeJS.ProcessEnv
+): void {
+  if (!environment.ANTHROPIC_AUTH_TOKEN?.trim() || !environment.ANTHROPIC_BASE_URL?.trim()) return;
+  const overlayDir = requireTargetClaudeDir(targetClaudeDir);
+  const settingsPath = path.join(overlayDir, SETTINGS_BASENAME);
+  const settings = readSettings(settingsPath);
+  const existingEnv = settings.env;
+  let env: MutableRecord = {};
+  if (existingEnv !== undefined) {
+    if (!isMutableRecord(existingEnv)) {
+      throw new TypeError('Claude settings env must be an object.');
+    }
+    env = { ...existingEnv };
+  }
+  for (const name of ALTERNATE_BACKEND_ENV) env[name] = '0';
+  settings.env = env;
+  writeSettings(settingsPath, settings);
+}
+
 function prepareClaudeSettingsOverlay(options: OverlayOptions = {}): string {
   const overlayDir = fs.mkdtempSync(path.join(os.tmpdir(), OVERLAY_PREFIX));
   fs.chmodSync(overlayDir, 0o700);
   try {
     ensureAskUserQuestionHook(overlayDir);
     if (options.includeDangerousGit) ensureDangerousGitHook(overlayDir);
+    ensureExplicitGatewayBackend(overlayDir, options.environment || process.env);
     return path.join(overlayDir, SETTINGS_BASENAME);
   } catch (error) {
     fs.rmSync(overlayDir, { recursive: true, force: true });