fix(errors): show actual host in 404 message instead of Ollama hint (#926)

When an OpenAI-compatible provider returns a 404, the user-facing error
message hardcoded "for Ollama: http://127.0.0.1:11434/v1" as a hint
regardless of the configured base URL. Users on remote providers
(NVIDIA NIM, OpenRouter, etc.) read this as the app ignoring their
custom OPENAI_BASE_URL and routing to localhost.

Plumb the request URL through the classifier and marker so the
user-facing message can name the actual host. Localhost endpoints keep
the existing Ollama-flavored guidance for backward compatibility.

- classifyOpenAIHttpFailure now accepts an optional url and produces a
  host-aware hint for non-localhost 404s
- the [openai_category=...] marker carries an optional host segment
- mapOpenAICompatibilityFailureToAssistantMessage branches on host to
  show "Endpoint at <host> returned 404. Verify OPENAI_BASE_URL is
  correct and the selected model (<model>) is supported by this
  provider." for remote URLs
- backward compatibility preserved when no URL is available

src/services/api/errors.openaiCompatibility.test.ts

@@ -28,6 +28,38 @@ test('maps endpoint_not_found category markers to actionable setup guidance', ()
   expect(text).toContain('/v1')
 })
 
+test('endpoint_not_found from a remote host shows the actual host, not Ollama (issue #926)', () => {
+  const error = APIError.generate(
+    404,
+    undefined,
+    'OpenAI API error 404: Not Found [openai_category=endpoint_not_found,host=integrate.api.nvidia.com] Hint: Endpoint at integrate.api.nvidia.com returned 404.',
+    new Headers(),
+  )
+
+  const message = getAssistantMessageFromError(error, 'moonshotai/kimi-k2.5-thinking')
+  const text = getFirstText(message)
+
+  expect(text).toContain('integrate.api.nvidia.com')
+  expect(text).toContain('moonshotai/kimi-k2.5-thinking')
+  expect(text).not.toContain('Ollama')
+  expect(text).not.toContain('11434')
+})
+
+test('endpoint_not_found without a host falls back to the Ollama-aware message', () => {
+  const error = APIError.generate(
+    404,
+    undefined,
+    'OpenAI API error 404: Not Found [openai_category=endpoint_not_found] Hint: Confirm OPENAI_BASE_URL includes /v1.',
+    new Headers(),
+  )
+
+  const message = getAssistantMessageFromError(error, 'qwen2.5-coder:7b')
+  const text = getFirstText(message)
+
+  expect(text).toContain('Provider endpoint was not found')
+  expect(text).toContain('Ollama')
+})
+
 test('maps tool_call_incompatible category markers to model/tool guidance', () => {
   const error = APIError.generate(
     400,

src/services/api/errors.ts

@@ -51,7 +51,9 @@ import {
 import { shouldProcessRateLimits } from '../rateLimitMocking.js' // Used for /mock-limits command
 import { extractConnectionErrorDetails, formatAPIError } from './errorUtils.js'
 import {
+  extractOpenAICategoryHost,
   extractOpenAICategoryMarker,
+  isLocalhostLikeHost,
   type OpenAICompatibilityFailureCategory,
 } from './openaiErrorClassification.js'
 
@@ -68,25 +70,29 @@ function mapOpenAICompatibilityFailureToAssistantMessage(options: {
   category: OpenAICompatibilityFailureCategory
   model: string
   rawMessage: string
+  host?: string
 }): AssistantMessage {
   const switchCmd = getIsNonInteractiveSession() ? '--model' : '/model'
   const compactHint = getIsNonInteractiveSession()
     ? 'Reduce prompt size or start a new session.'
     : 'Run /compact or start a new session with /new.'
+  const isLocalhost = options.host === undefined || isLocalhostLikeHost(options.host)
 
   switch (options.category) {
     case 'localhost_resolution_failed':
     case 'connection_refused':
       return createAssistantAPIErrorMessage({
-        content:
-          'Could not connect to the local OpenAI-compatible provider. Ensure the local server is running, then use OPENAI_BASE_URL=http://127.0.0.1:11434/v1 for Ollama.',
+        content: isLocalhost
+          ? 'Could not connect to the local OpenAI-compatible provider. Ensure the local server is running, then use OPENAI_BASE_URL=http://127.0.0.1:11434/v1 for Ollama.'
+          : `Could not connect to the provider at ${options.host}. Verify OPENAI_BASE_URL is correct and that the host is reachable.`,
         error: 'unknown',
       })
 
     case 'endpoint_not_found':
       return createAssistantAPIErrorMessage({
-        content:
-          'Provider endpoint was not found. Confirm OPENAI_BASE_URL targets an OpenAI-compatible /v1 endpoint (for Ollama: http://127.0.0.1:11434/v1).',
+        content: isLocalhost
+          ? 'Provider endpoint was not found. Confirm OPENAI_BASE_URL targets an OpenAI-compatible /v1 endpoint (for Ollama: http://127.0.0.1:11434/v1).'
+          : `Provider endpoint at ${options.host} returned 404. Verify OPENAI_BASE_URL is correct and that the selected model (${options.model}) is supported by this provider.`,
         error: 'invalid_request',
       })
 
@@ -567,6 +573,7 @@ export function getAssistantMessageFromError(
         category: openaiCategory,
         model,
         rawMessage: error.message,
+        host: extractOpenAICategoryHost(error.message),
       })
     }
   }

src/services/api/openaiErrorClassification.test.ts

@@ -4,8 +4,10 @@ import {
   buildOpenAICompatibilityErrorMessage,
   classifyOpenAIHttpFailure,
   classifyOpenAINetworkFailure,
+  extractOpenAICategoryHost,
   extractOpenAICategoryMarker,
   formatOpenAICategoryMarker,
+  isLocalhostLikeHost,
 } from './openaiErrorClassification.js'
 
 test('classifies localhost ECONNREFUSED as connection_refused', () => {
@@ -95,3 +97,58 @@ test('ignores unknown category markers during extraction', () => {
   const malformed = 'OpenAI API error 500 [openai_category=totally_fake_category]'
   expect(extractOpenAICategoryMarker(malformed)).toBeUndefined()
 })
+
+test('endpoint_not_found 404 from a remote host gets a host-aware hint (issue #926)', () => {
+  const failure = classifyOpenAIHttpFailure({
+    status: 404,
+    body: 'Not Found',
+    url: 'https://integrate.api.nvidia.com/v1/chat/completions',
+  })
+
+  expect(failure.category).toBe('endpoint_not_found')
+  expect(failure.requestUrl).toBe('https://integrate.api.nvidia.com/v1/chat/completions')
+  expect(failure.hint).toContain('integrate.api.nvidia.com')
+  expect(failure.hint).not.toContain('local providers')
+})
+
+test('endpoint_not_found 404 from localhost keeps the Ollama-flavored hint', () => {
+  const failure = classifyOpenAIHttpFailure({
+    status: 404,
+    body: 'Not Found',
+    url: 'http://127.0.0.1:11434/v1/chat/completions',
+  })
+
+  expect(failure.category).toBe('endpoint_not_found')
+  expect(failure.hint).toContain('local providers')
+})
+
+test('marker round-trip preserves host segment', () => {
+  const formatted = buildOpenAICompatibilityErrorMessage(
+    'OpenAI API error 404: Not Found',
+    {
+      category: 'endpoint_not_found',
+      hint: 'Endpoint at integrate.api.nvidia.com returned 404.',
+      requestUrl: 'https://integrate.api.nvidia.com/v1/chat/completions',
+    },
+  )
+
+  expect(formatted).toContain('[openai_category=endpoint_not_found,host=integrate.api.nvidia.com]')
+  expect(extractOpenAICategoryMarker(formatted)).toBe('endpoint_not_found')
+  expect(extractOpenAICategoryHost(formatted)).toBe('integrate.api.nvidia.com')
+})
+
+test('marker without host stays backward-compatible', () => {
+  const marker = formatOpenAICategoryMarker('endpoint_not_found')
+  expect(marker).toBe('[openai_category=endpoint_not_found]')
+  expect(extractOpenAICategoryMarker(marker)).toBe('endpoint_not_found')
+  expect(extractOpenAICategoryHost(marker)).toBeUndefined()
+})
+
+test('isLocalhostLikeHost matches loopback variants', () => {
+  expect(isLocalhostLikeHost('localhost')).toBe(true)
+  expect(isLocalhostLikeHost('127.0.0.1')).toBe(true)
+  expect(isLocalhostLikeHost('127.0.0.5')).toBe(true)
+  expect(isLocalhostLikeHost('::1')).toBe(true)
+  expect(isLocalhostLikeHost('integrate.api.nvidia.com')).toBe(false)
+  expect(isLocalhostLikeHost(undefined)).toBe(false)
+})

src/services/api/openaiErrorClassification.ts

@@ -21,6 +21,7 @@ export type OpenAICompatibilityFailure = {
   hint?: string
   code?: string
   status?: number
+  requestUrl?: string
 }
 
 const OPENAI_CATEGORY_MARKER_PREFIX = '[openai_category='
@@ -96,6 +97,11 @@ function isLocalhostLikeHostname(hostname: string | null): boolean {
   return /^127\./.test(hostname)
 }
 
+export function isLocalhostLikeHost(host: string | null | undefined): boolean {
+  if (!host) return false
+  return isLocalhostLikeHostname(host.toLowerCase())
+}
+
 function isContextOverflowMessage(body: string): boolean {
   const lower = body.toLowerCase()
   return (
@@ -149,14 +155,18 @@ function isModelNotFoundMessage(body: string): boolean {
 
 export function formatOpenAICategoryMarker(
   category: OpenAICompatibilityFailureCategory,
+  host?: string,
 ): string {
+  if (host && /^[A-Za-z0-9.\-:]+$/.test(host)) {
+    return `${OPENAI_CATEGORY_MARKER_PREFIX}${category},host=${host}]`
+  }
   return `${OPENAI_CATEGORY_MARKER_PREFIX}${category}]`
 }
 
 export function extractOpenAICategoryMarker(
   message: string,
 ): OpenAICompatibilityFailureCategory | undefined {
-  const match = message.match(/\[openai_category=([a-z_]+)]/)
+  const match = message.match(/\[openai_category=([a-z_]+)(?:,host=[^\]]+)?]/)
   const category = match?.[1]
 
   if (!category || !isOpenAICompatibilityFailureCategory(category)) {
@@ -166,11 +176,17 @@ export function extractOpenAICategoryMarker(
   return category
 }
 
+export function extractOpenAICategoryHost(message: string): string | undefined {
+  const match = message.match(/\[openai_category=[a-z_]+,host=([A-Za-z0-9.\-:]+)]/)
+  return match?.[1]
+}
+
 export function buildOpenAICompatibilityErrorMessage(
   baseMessage: string,
-  failure: Pick<OpenAICompatibilityFailure, 'category' | 'hint'>,
+  failure: Pick<OpenAICompatibilityFailure, 'category' | 'hint' | 'requestUrl'>,
 ): string {
-  const marker = formatOpenAICategoryMarker(failure.category)
+  const host = failure.requestUrl ? getHostname(failure.requestUrl) ?? undefined : undefined
+  const marker = formatOpenAICategoryMarker(failure.category, host)
   const hint = failure.hint ? ` Hint: ${failure.hint}` : ''
   return `${baseMessage} ${marker}${hint}`
 }
@@ -247,8 +263,11 @@ export function classifyOpenAINetworkFailure(
 export function classifyOpenAIHttpFailure(options: {
   status: number
   body: string
+  url?: string
 }): OpenAICompatibilityFailure {
   const body = options.body ?? ''
+  const hostname = options.url ? getHostname(options.url) : null
+  const isLocalHost = isLocalhostLikeHostname(hostname)
 
   if (options.status === 401 || options.status === 403) {
     return {
@@ -284,13 +303,17 @@ export function classifyOpenAIHttpFailure(options: {
   }
 
   if (options.status === 404) {
+    const isRemote = hostname !== null && !isLocalHost
     return {
       source: 'http',
       category: 'endpoint_not_found',
       retryable: false,
       status: options.status,
       message: body,
-      hint: 'Endpoint was not found. Confirm OPENAI_BASE_URL includes /v1 for OpenAI-compatible local providers.',
+      requestUrl: options.url,
+      hint: isRemote
+        ? `Endpoint at ${hostname} returned 404. Verify OPENAI_BASE_URL is correct and the requested model is supported by this provider.`
+        : 'Endpoint was not found. Confirm OPENAI_BASE_URL includes /v1 for OpenAI-compatible local providers.',
     }
   }
 

src/services/api/openaiShim.ts

@@ -1935,7 +1935,9 @@ class OpenAIShimMessages {
         classifyOpenAIHttpFailure({
           status,
           body: errorBody,
+          url: requestUrl,
         })
+      const failureWithUrl = { ...failure, requestUrl: failure.requestUrl ?? requestUrl }
       const redactedUrl = redactUrlForDiagnostics(requestUrl)
 
       logForDebugging(
@@ -1948,7 +1950,7 @@ class OpenAIShimMessages {
         parsedBody,
         buildOpenAICompatibilityErrorMessage(
           `OpenAI API error ${status}: ${errorBody}${rateHint}`,
-          failure,
+          failureWithUrl,
         ),
         responseHeaders,
       )

src/utils/plugins/gitEnv.test.ts

@@ -1,104 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-
-import {
-  __resetGitEnvWarningForTesting,
-  buildGitChildEnv,
-  sanitizeEnvForGit,
-} from './gitEnv.js'
-
-describe('sanitizeEnvForGit', () => {
-  test('drops values containing LF', () => {
-    const result = sanitizeEnvForGit({
-      GOOD: 'value',
-      BAD_NEWLINE: 'line1\nline2',
-    })
-    expect(result.env).toEqual({ GOOD: 'value' })
-    expect(result.dropped).toEqual(['BAD_NEWLINE'])
-  })
-
-  test('drops values containing CR', () => {
-    const result = sanitizeEnvForGit({
-      GOOD: 'value',
-      BAD_CR: 'value\r',
-    })
-    expect(result.dropped).toEqual(['BAD_CR'])
-  })
-
-  test('drops values containing NUL', () => {
-    const result = sanitizeEnvForGit({
-      GOOD: 'value',
-      BAD_NUL: 'a\0b',
-    })
-    expect(result.dropped).toEqual(['BAD_NUL'])
-  })
-
-  test('drops keys whose name itself contains a control character', () => {
-    const result = sanitizeEnvForGit({
-      'BAD\nKEY': 'safe-value',
-      GOOD: 'value',
-    })
-    expect(result.env).toEqual({ GOOD: 'value' })
-    expect(result.dropped).toEqual(['BAD\nKEY'])
-  })
-
-  test('skips entries explicitly set to undefined without listing them as dropped', () => {
-    const result = sanitizeEnvForGit({
-      GOOD: 'value',
-      MAYBE: undefined,
-    })
-    expect(result.env).toEqual({ GOOD: 'value' })
-    expect(result.dropped).toEqual([])
-  })
-
-  test('returns input unchanged when nothing is unsafe', () => {
-    const env = { PATH: '/usr/bin:/bin', HOME: '/home/user', GIT_TERMINAL_PROMPT: '0' }
-    const result = sanitizeEnvForGit(env)
-    expect(result.env).toEqual(env)
-    expect(result.dropped).toEqual([])
-  })
-})
-
-describe('buildGitChildEnv', () => {
-  const ORIGINAL_BAD_KEY = 'OPENCLAUDE_TEST_BAD_ENV_FOR_GIT'
-  let originalValue: string | undefined
-
-  beforeEach(() => {
-    __resetGitEnvWarningForTesting()
-    originalValue = process.env[ORIGINAL_BAD_KEY]
-  })
-
-  afterEach(() => {
-    if (originalValue === undefined) {
-      delete process.env[ORIGINAL_BAD_KEY]
-    } else {
-      process.env[ORIGINAL_BAD_KEY] = originalValue
-    }
-  })
-
-  test('always sets the no-prompt overrides', () => {
-    const env = buildGitChildEnv()
-    expect(env.GIT_TERMINAL_PROMPT).toBe('0')
-    expect(env.GIT_ASKPASS).toBe('')
-  })
-
-  test('drops process.env values containing control characters (issue #751)', () => {
-    process.env[ORIGINAL_BAD_KEY] = 'paste-with-newline\n'
-    const env = buildGitChildEnv()
-    expect(env[ORIGINAL_BAD_KEY]).toBeUndefined()
-    expect(env.GIT_TERMINAL_PROMPT).toBe('0')
-  })
-
-  test('caller extras override process.env and the no-prompt defaults', () => {
-    const env = buildGitChildEnv({
-      GIT_TERMINAL_PROMPT: '1',
-      CUSTOM_KEY: 'custom-value',
-    })
-    expect(env.GIT_TERMINAL_PROMPT).toBe('1')
-    expect(env.CUSTOM_KEY).toBe('custom-value')
-  })
-
-  test('caller-provided unsafe extras are also dropped', () => {
-    const env = buildGitChildEnv({ EXTRA_BAD: 'a\rb' })
-    expect(env.EXTRA_BAD).toBeUndefined()
-  })
-})

src/utils/plugins/gitEnv.ts

@@ -1,70 +0,0 @@
-import { logForDebugging } from '../debug.js'
-
-/**
- * Git 2.30+ refuses to start when any environment value contains a NUL,
- * CR, or LF character ("Unsafe environment: control characters are not
- * allowed in values"). User shells frequently leak such values — a
- * copy-pasted API key with a trailing newline, or a terminal-set
- * variable with embedded escape sequences — which would otherwise break
- * every plugin clone or pull. We drop offending entries before forwarding
- * the environment to git.
- */
-const GIT_UNSAFE_VALUE_RE = /[\0\r\n]/
-
-const GIT_NO_PROMPT_ENV = {
-  GIT_TERMINAL_PROMPT: '0', // Prevent terminal credential prompts
-  GIT_ASKPASS: '', // Disable askpass GUI programs
-}
-
-let warnedAboutDroppedEnvKeys = false
-
-/**
- * Returns a copy of `env` with any entries whose key OR value contains
- * a NUL/CR/LF removed. The list of dropped key names is returned so
- * callers can log it without exposing the (possibly secret) values.
- */
-export function sanitizeEnvForGit(
-  env: NodeJS.ProcessEnv,
-): { env: NodeJS.ProcessEnv; dropped: string[] } {
-  const sanitized: NodeJS.ProcessEnv = {}
-  const dropped: string[] = []
-  for (const [key, value] of Object.entries(env)) {
-    if (value === undefined) continue
-    if (GIT_UNSAFE_VALUE_RE.test(key) || GIT_UNSAFE_VALUE_RE.test(value)) {
-      dropped.push(key)
-      continue
-    }
-    sanitized[key] = value
-  }
-  return { env: sanitized, dropped }
-}
-
-/**
- * Build the environment object passed to a git child process. Merges
- * `process.env` with the no-prompt overrides and any caller extras,
- * then strips entries that would trigger git's unsafe-value check. The
- * first batch of dropped key names is logged once per process so the
- * user can clean them up in their shell.
- */
-export function buildGitChildEnv(
-  extras?: NodeJS.ProcessEnv,
-): NodeJS.ProcessEnv {
-  const merged = { ...process.env, ...GIT_NO_PROMPT_ENV, ...(extras ?? {}) }
-  const { env, dropped } = sanitizeEnvForGit(merged)
-  if (dropped.length > 0 && !warnedAboutDroppedEnvKeys) {
-    warnedAboutDroppedEnvKeys = true
-    logForDebugging(
-      `git child env: dropped ${dropped.length} key(s) containing control characters: ${dropped.join(', ')}. Git 2.30+ rejects them; clean these up in your shell to forward them to git.`,
-      { level: 'warn' },
-    )
-  }
-  return env
-}
-
-/**
- * Test-only escape hatch that resets the once-per-process warning flag
- * so unit tests can exercise the warning path repeatedly.
- */
-export function __resetGitEnvWarningForTesting(): void {
-  warnedAboutDroppedEnvKeys = false
-}

src/utils/plugins/marketplaceManager.ts

@@ -53,7 +53,6 @@ import {
   getAddDirExtraMarketplaces,
 } from './addDirPluginSettings.js'
 import { markPluginVersionOrphaned } from './cacheUtils.js'
-import { buildGitChildEnv } from './gitEnv.js'
 import { classifyFetchError, logPluginFetch } from './fetchTelemetry.js'
 import { removeAllPluginsForMarketplace } from './installedPluginsManager.js'
 import {
@@ -507,6 +506,11 @@ function seedDirFor(installLocation: string): string | undefined {
  * Provides helpful error messages for common failure scenarios.
  * If a ref is specified, fetches and checks out that specific branch or tag.
  */
+// Environment variables to prevent git from prompting for credentials
+const GIT_NO_PROMPT_ENV = {
+  GIT_TERMINAL_PROMPT: '0', // Prevent terminal credential prompts
+  GIT_ASKPASS: '', // Disable askpass GUI programs
+}
 
 const DEFAULT_PLUGIN_GIT_TIMEOUT_MS = 120 * 1000
 
@@ -527,7 +531,7 @@ export async function gitPull(
   options?: { disableCredentialHelper?: boolean; sparsePaths?: string[] },
 ): Promise<{ code: number; stderr: string }> {
   logForDebugging(`git pull: cwd=${cwd} ref=${ref ?? 'default'}`)
-  const env = buildGitChildEnv()
+  const env = { ...process.env, ...GIT_NO_PROMPT_ENV }
   const baseArgs = ['-c', 'core.hooksPath=/dev/null']
   const credentialArgs = options?.disableCredentialHelper
     ? ['-c', 'credential.helper=']
@@ -840,7 +844,7 @@ export async function gitClone(
   const result = await execFileNoThrowWithCwd(gitExe(), args, {
     timeout: timeoutMs,
     stdin: 'ignore',
-    env: buildGitChildEnv(),
+    env: { ...process.env, ...GIT_NO_PROMPT_ENV },
   })
 
   // Scrub credentials from execa's error/stderr fields before any logging or
@@ -866,7 +870,7 @@ export async function gitClone(
           cwd: targetPath,
           timeout: timeoutMs,
           stdin: 'ignore',
-          env: buildGitChildEnv(),
+          env: { ...process.env, ...GIT_NO_PROMPT_ENV },
         },
       )
       if (sparseResult.code !== 0) {
@@ -885,7 +889,7 @@ export async function gitClone(
           cwd: targetPath,
           timeout: timeoutMs,
           stdin: 'ignore',
-          env: buildGitChildEnv(),
+          env: { ...process.env, ...GIT_NO_PROMPT_ENV },
         },
       )
       if (checkoutResult.code !== 0) {
@@ -1036,7 +1040,7 @@ export async function reconcileSparseCheckout(
   cwd: string,
   sparsePaths: string[] | undefined,
 ): Promise<{ code: number; stderr: string }> {
-  const env = buildGitChildEnv()
+  const env = { ...process.env, ...GIT_NO_PROMPT_ENV }
 
   if (sparsePaths && sparsePaths.length > 0) {
     return execFileNoThrowWithCwd(

src/utils/plugins/pluginLoader.ts

@@ -87,7 +87,6 @@ import { getAddDirEnabledPlugins } from './addDirPluginSettings.js'
 import { verifyAndDemote } from './dependencyResolver.js'
 import { classifyFetchError, logPluginFetch } from './fetchTelemetry.js'
 import { checkGitAvailable } from './gitAvailability.js'
-import { buildGitChildEnv } from './gitEnv.js'
 import { getInMemoryInstalledPlugins } from './installedPluginsManager.js'
 import { getManagedPluginNames } from './managedPlugins.js'
 import {
@@ -561,9 +560,7 @@ export async function gitClone(
   args.push(gitUrl, targetPath)
 
   const cloneStarted = performance.now()
-  const cloneResult = await execFileNoThrow(gitExe(), args, {
-    env: buildGitChildEnv(),
-  })
+  const cloneResult = await execFileNoThrow(gitExe(), args)
 
   if (cloneResult.code !== 0) {
     logPluginFetch(
@@ -582,7 +579,7 @@ export async function gitClone(
     const shallowFetchResult = await execFileNoThrowWithCwd(
       gitExe(),
       ['fetch', '--depth', '1', 'origin', sha],
-      { cwd: targetPath, env: buildGitChildEnv() },
+      { cwd: targetPath },
     )
 
     if (shallowFetchResult.code !== 0) {
@@ -594,7 +591,7 @@ export async function gitClone(
       const unshallowResult = await execFileNoThrowWithCwd(
         gitExe(),
         ['fetch', '--unshallow'],
-        { cwd: targetPath, env: buildGitChildEnv() },
+        { cwd: targetPath },
       )
 
       if (unshallowResult.code !== 0) {
@@ -615,7 +612,7 @@ export async function gitClone(
     const checkoutResult = await execFileNoThrowWithCwd(
       gitExe(),
       ['checkout', sha],
-      { cwd: targetPath, env: buildGitChildEnv() },
+      { cwd: targetPath },
     )
 
     if (checkoutResult.code !== 0) {
@@ -748,9 +745,7 @@ export async function installFromGitSubdir(
   }
   cloneArgs.push(gitUrl, cloneDir)
 
-  const cloneResult = await execFileNoThrow(gitExe(), cloneArgs, {
-    env: buildGitChildEnv(),
-  })
+  const cloneResult = await execFileNoThrow(gitExe(), cloneArgs)
   if (cloneResult.code !== 0) {
     throw new Error(
       `Failed to clone repository for git-subdir source: ${cloneResult.stderr}`,
@@ -761,7 +756,7 @@ export async function installFromGitSubdir(
     const sparseResult = await execFileNoThrowWithCwd(
       gitExe(),
       ['sparse-checkout', 'set', '--cone', '--', subdirPath],
-      { cwd: cloneDir, env: buildGitChildEnv() },
+      { cwd: cloneDir },
     )
     if (sparseResult.code !== 0) {
       throw new Error(
@@ -780,7 +775,7 @@ export async function installFromGitSubdir(
       const fetchSha = await execFileNoThrowWithCwd(
         gitExe(),
         ['fetch', '--depth', '1', 'origin', sha],
-        { cwd: cloneDir, env: buildGitChildEnv() },
+        { cwd: cloneDir },
       )
       if (fetchSha.code !== 0) {
         logForDebugging(
@@ -789,7 +784,7 @@ export async function installFromGitSubdir(
         const unshallow = await execFileNoThrowWithCwd(
           gitExe(),
           ['fetch', '--unshallow'],
-          { cwd: cloneDir, env: buildGitChildEnv() },
+          { cwd: cloneDir },
         )
         if (unshallow.code !== 0) {
           throw new Error(`Failed to fetch commit ${sha}: ${unshallow.stderr}`)
@@ -798,7 +793,7 @@ export async function installFromGitSubdir(
       const checkout = await execFileNoThrowWithCwd(
         gitExe(),
         ['checkout', sha],
-        { cwd: cloneDir, env: buildGitChildEnv() },
+        { cwd: cloneDir },
       )
       if (checkout.code !== 0) {
         throw new Error(`Failed to checkout commit ${sha}: ${checkout.stderr}`)
@@ -813,11 +808,9 @@ export async function installFromGitSubdir(
       const [checkout, revParse] = await Promise.all([
         execFileNoThrowWithCwd(gitExe(), ['checkout', 'HEAD'], {
           cwd: cloneDir,
-          env: buildGitChildEnv(),
         }),
         execFileNoThrowWithCwd(gitExe(), ['rev-parse', 'HEAD'], {
           cwd: cloneDir,
-          env: buildGitChildEnv(),
         }),
       ])
       if (checkout.code !== 0) {