fix: gate startup checks strictly on first submission, remove grace period (issue #363)

As gnanam1990 pointed out, the 3s grace period still allows the failure
mode: if a user pauses for a few seconds before typing, startup checks
fire and recommendation dialogs steal focus. A grace period is still a
timing mitigation, not a reliable fix.

New approach: startup checks only run after the user has submitted their
first message (submitCount > 0). No grace period, no timeout. This
guarantees the prompt gets first interaction — no dialog can steal focus
before the user has actually used the CLI.

If the user never submits a message, startup checks never run. That's
acceptable because with no user interaction there's no need for plugin
installations or marketplace seeding.

src/commands/onboard-github/index.ts

@@ -2,6 +2,7 @@ import type { Command } from '../../commands.js'
 
 const onboardGithub: Command = {
   name: 'onboard-github',
+  aliases: ['onboarding-github', 'onboardgithub', 'onboardinggithub'],
   description:
     'Interactive setup for GitHub Models: device login or PAT, saved to secure storage',
   type: 'local-jsx',

src/commands/onboard-github/onboard-github.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  activateGithubOnboardingMode,
+  applyGithubOnboardingProcessEnv,
+  buildGithubOnboardingSettingsEnv,
+  hasExistingGithubModelsLoginToken,
+  shouldForceGithubRelogin,
+} from './onboard-github.js'
+
+describe('shouldForceGithubRelogin', () => {
+  test.each(['force', '--force', 'relogin', '--relogin', 'reauth', '--reauth'])(
+    'treats %s as force re-login',
+    arg => {
+      expect(shouldForceGithubRelogin(arg)).toBe(true)
+    },
+  )
+
+  test('returns false for empty or unknown args', () => {
+    expect(shouldForceGithubRelogin('')).toBe(false)
+    expect(shouldForceGithubRelogin(undefined)).toBe(false)
+    expect(shouldForceGithubRelogin('something-else')).toBe(false)
+  })
+
+  test('treats force flags as present in multi-word args', () => {
+    expect(shouldForceGithubRelogin('--force extra')).toBe(true)
+    expect(shouldForceGithubRelogin('foo --relogin bar')).toBe(true)
+    expect(shouldForceGithubRelogin('abc reauth xyz')).toBe(true)
+  })
+})
+
+describe('hasExistingGithubModelsLoginToken', () => {
+  test('returns true when GITHUB_TOKEN is present', () => {
+    expect(
+      hasExistingGithubModelsLoginToken({ GITHUB_TOKEN: 'token' }, ''),
+    ).toBe(true)
+  })
+
+  test('returns true when GH_TOKEN is present', () => {
+    expect(
+      hasExistingGithubModelsLoginToken({ GH_TOKEN: 'token' }, ''),
+    ).toBe(true)
+  })
+
+  test('returns true when stored token exists', () => {
+    expect(hasExistingGithubModelsLoginToken({}, 'stored-token')).toBe(true)
+  })
+
+  test('returns false when both env and stored token are missing', () => {
+    expect(hasExistingGithubModelsLoginToken({}, '')).toBe(false)
+  })
+})
+
+describe('onboarding auth precedence cleanup', () => {
+  test('clears preexisting OpenAI auth when switching to GitHub', () => {
+    const env: NodeJS.ProcessEnv = {
+      CLAUDE_CODE_USE_OPENAI: '1',
+      OPENAI_MODEL: 'gpt-4o',
+      OPENAI_API_KEY: 'sk-stale-openai-key',
+      OPENAI_ORG: 'org-old',
+      OPENAI_PROJECT: 'project-old',
+      OPENAI_ORGANIZATION: 'org-legacy',
+      OPENAI_BASE_URL: 'https://api.openai.com/v1',
+      OPENAI_API_BASE: 'https://api.openai.com/v1',
+      CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED: '1',
+      CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID: 'profile_old',
+    }
+
+    applyGithubOnboardingProcessEnv('github:copilot', env)
+
+    expect(env.CLAUDE_CODE_USE_GITHUB).toBe('1')
+    expect(env.OPENAI_MODEL).toBe('github:copilot')
+
+    expect(env.OPENAI_API_KEY).toBeUndefined()
+    expect(env.OPENAI_ORG).toBeUndefined()
+    expect(env.OPENAI_PROJECT).toBeUndefined()
+    expect(env.OPENAI_ORGANIZATION).toBeUndefined()
+    expect(env.OPENAI_BASE_URL).toBeUndefined()
+    expect(env.OPENAI_API_BASE).toBeUndefined()
+
+    expect(env.CLAUDE_CODE_USE_OPENAI).toBeUndefined()
+    expect(env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED).toBeUndefined()
+    expect(env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID).toBeUndefined()
+
+    const settingsEnv = buildGithubOnboardingSettingsEnv('github:copilot')
+    expect(settingsEnv.CLAUDE_CODE_USE_GITHUB).toBe('1')
+    expect(settingsEnv.OPENAI_MODEL).toBe('github:copilot')
+    expect(settingsEnv.OPENAI_API_KEY).toBeUndefined()
+    expect(settingsEnv.OPENAI_ORG).toBeUndefined()
+    expect(settingsEnv.OPENAI_PROJECT).toBeUndefined()
+    expect(settingsEnv.OPENAI_ORGANIZATION).toBeUndefined()
+  })
+})
+
+describe('activateGithubOnboardingMode', () => {
+  test('activates settings/env/hydration in order when merge succeeds', () => {
+    const calls: string[] = []
+
+    const result = activateGithubOnboardingMode('  github:copilot  ', {
+      mergeSettingsEnv: model => {
+        calls.push(`merge:${model}`)
+        return { ok: true }
+      },
+      applyProcessEnv: model => {
+        calls.push(`apply:${model}`)
+      },
+      hydrateToken: () => {
+        calls.push('hydrate')
+      },
+      onChangeAPIKey: () => {
+        calls.push('onChangeAPIKey')
+      },
+    })
+
+    expect(result).toEqual({ ok: true })
+    expect(calls).toEqual([
+      'merge:github:copilot',
+      'apply:github:copilot',
+      'hydrate',
+      'onChangeAPIKey',
+    ])
+  })
+
+  test('stops activation when settings merge fails', () => {
+    const calls: string[] = []
+
+    const result = activateGithubOnboardingMode(DEFAULT_MODEL_FOR_TESTS, {
+      mergeSettingsEnv: () => {
+        calls.push('merge')
+        return { ok: false, detail: 'settings write failed' }
+      },
+      applyProcessEnv: () => {
+        calls.push('apply')
+      },
+      hydrateToken: () => {
+        calls.push('hydrate')
+      },
+      onChangeAPIKey: () => {
+        calls.push('onChangeAPIKey')
+      },
+    })
+
+    expect(result).toEqual({ ok: false, detail: 'settings write failed' })
+    expect(calls).toEqual(['merge'])
+  })
+})
+
+const DEFAULT_MODEL_FOR_TESTS = 'github:copilot'

src/commands/onboard-github/onboard-github.tsx

@@ -12,11 +12,20 @@ import {
 import type { LocalJSXCommandCall } from '../../types/command.js'
 import {
   hydrateGithubModelsTokenFromSecureStorage,
+  readGithubModelsToken,
   saveGithubModelsToken,
 } from '../../utils/githubModelsCredentials.js'
 import { updateSettingsForSource } from '../../utils/settings/settings.js'
 
 const DEFAULT_MODEL = 'github:copilot'
+const FORCE_RELOGIN_ARGS = new Set([
+  'force',
+  '--force',
+  'relogin',
+  '--relogin',
+  'reauth',
+  '--reauth',
+])
 
 type Step =
   | 'menu'
@@ -24,17 +33,72 @@ type Step =
   | 'pat'
   | 'error'
 
+export function shouldForceGithubRelogin(args?: string): boolean {
+  const normalized = (args ?? '').trim().toLowerCase()
+  if (!normalized) {
+    return false
+  }
+  return normalized.split(/\s+/).some(arg => FORCE_RELOGIN_ARGS.has(arg))
+}
+
+export function hasExistingGithubModelsLoginToken(
+  env: NodeJS.ProcessEnv = process.env,
+  storedToken?: string,
+): boolean {
+  const envToken = env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim()
+  if (envToken) {
+    return true
+  }
+  const persisted = (storedToken ?? readGithubModelsToken())?.trim()
+  return Boolean(persisted)
+}
+
+export function buildGithubOnboardingSettingsEnv(
+  model: string,
+): Record<string, string | undefined> {
+  return {
+    CLAUDE_CODE_USE_GITHUB: '1',
+    OPENAI_MODEL: model,
+    OPENAI_API_KEY: undefined,
+    OPENAI_ORG: undefined,
+    OPENAI_PROJECT: undefined,
+    OPENAI_ORGANIZATION: undefined,
+    OPENAI_BASE_URL: undefined,
+    OPENAI_API_BASE: undefined,
+    CLAUDE_CODE_USE_OPENAI: undefined,
+    CLAUDE_CODE_USE_GEMINI: undefined,
+    CLAUDE_CODE_USE_BEDROCK: undefined,
+    CLAUDE_CODE_USE_VERTEX: undefined,
+    CLAUDE_CODE_USE_FOUNDRY: undefined,
+  }
+}
+
+export function applyGithubOnboardingProcessEnv(
+  model: string,
+  env: NodeJS.ProcessEnv = process.env,
+): void {
+  env.CLAUDE_CODE_USE_GITHUB = '1'
+  env.OPENAI_MODEL = model
+
+  delete env.OPENAI_API_KEY
+  delete env.OPENAI_ORG
+  delete env.OPENAI_PROJECT
+  delete env.OPENAI_ORGANIZATION
+  delete env.OPENAI_BASE_URL
+  delete env.OPENAI_API_BASE
+
+  delete env.CLAUDE_CODE_USE_OPENAI
+  delete env.CLAUDE_CODE_USE_GEMINI
+  delete env.CLAUDE_CODE_USE_BEDROCK
+  delete env.CLAUDE_CODE_USE_VERTEX
+  delete env.CLAUDE_CODE_USE_FOUNDRY
+  delete env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED
+  delete env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID
+}
+
 function mergeUserSettingsEnv(model: string): { ok: boolean; detail?: string } {
   const { error } = updateSettingsForSource('userSettings', {
-    env: {
-      CLAUDE_CODE_USE_GITHUB: '1',
-      OPENAI_MODEL: model,
-      CLAUDE_CODE_USE_OPENAI: undefined as any,
-      CLAUDE_CODE_USE_GEMINI: undefined as any,
-      CLAUDE_CODE_USE_BEDROCK: undefined as any,
-      CLAUDE_CODE_USE_VERTEX: undefined as any,
-      CLAUDE_CODE_USE_FOUNDRY: undefined as any,
-    },
+    env: buildGithubOnboardingSettingsEnv(model) as any,
   })
   if (error) {
     return { ok: false, detail: error.message }
@@ -42,6 +106,32 @@ function mergeUserSettingsEnv(model: string): { ok: boolean; detail?: string } {
   return { ok: true }
 }
 
+export function activateGithubOnboardingMode(
+  model: string = DEFAULT_MODEL,
+  options?: {
+    mergeSettingsEnv?: (model: string) => { ok: boolean; detail?: string }
+    applyProcessEnv?: (model: string) => void
+    hydrateToken?: () => void
+    onChangeAPIKey?: () => void
+  },
+): { ok: boolean; detail?: string } {
+  const normalizedModel = model.trim() || DEFAULT_MODEL
+  const mergeSettingsEnv = options?.mergeSettingsEnv ?? mergeUserSettingsEnv
+  const applyProcessEnv = options?.applyProcessEnv ?? applyGithubOnboardingProcessEnv
+  const hydrateToken =
+    options?.hydrateToken ?? hydrateGithubModelsTokenFromSecureStorage
+
+  const merged = mergeSettingsEnv(normalizedModel)
+  if (!merged.ok) {
+    return merged
+  }
+
+  applyProcessEnv(normalizedModel)
+  hydrateToken()
+  options?.onChangeAPIKey?.()
+  return { ok: true }
+}
+
 function OnboardGithub(props: {
   onDone: Parameters<LocalJSXCommandCall>[0]
   onChangeAPIKey: () => void
@@ -64,19 +154,17 @@ function OnboardGithub(props: {
         setStep('error')
         return
       }
-      const merged = mergeUserSettingsEnv(model.trim() || DEFAULT_MODEL)
-      if (!merged.ok) {
+      const activated = activateGithubOnboardingMode(model, {
+        onChangeAPIKey,
+      })
+      if (!activated.ok) {
         setErrorMsg(
-          `Token saved, but settings were not updated: ${merged.detail ?? 'unknown error'}. ` +
+          `Token saved, but settings were not updated: ${activated.detail ?? 'unknown error'}. ` +
             `Add env CLAUDE_CODE_USE_GITHUB=1 and OPENAI_MODEL to ~/.claude/settings.json manually.`,
         )
         setStep('error')
         return
       }
-      process.env.CLAUDE_CODE_USE_GITHUB = '1'
-      process.env.OPENAI_MODEL = model.trim() || DEFAULT_MODEL
-      hydrateGithubModelsTokenFromSecureStorage()
-      onChangeAPIKey()
       onDone(
         'GitHub Models onboard complete. Token stored in secure storage; user settings updated. Restart if the model does not switch.',
         { display: 'user' },
@@ -147,11 +235,11 @@ function OnboardGithub(props: {
               {deviceHint.verification_uri}
             </Text>
             <Text dimColor>
-              A browser window may have opened. Waiting for authorization…
+              A browser window may have opened. Waiting for authorization...
             </Text>
           </>
         ) : (
-          <Text dimColor>Requesting device code from GitHub…</Text>
+          <Text dimColor>Requesting device code from GitHub...</Text>
         )}
         <Spinner />
       </Box>
@@ -206,7 +294,7 @@ function OnboardGithub(props: {
       <Text bold>GitHub Models setup</Text>
       <Text dimColor>
         Stores your token in the OS credential store (macOS Keychain when available)
-        and enables CLAUDE_CODE_USE_GITHUB in your user settings — no export
+        and enables CLAUDE_CODE_USE_GITHUB in your user settings - no export
         GITHUB_TOKEN needed for future runs.
       </Text>
       <Select
@@ -227,7 +315,28 @@ function OnboardGithub(props: {
   )
 }
 
-export const call: LocalJSXCommandCall = async (onDone, context) => {
+export const call: LocalJSXCommandCall = async (onDone, context, args) => {
+  const forceRelogin = shouldForceGithubRelogin(args)
+  if (hasExistingGithubModelsLoginToken() && !forceRelogin) {
+    const activated = activateGithubOnboardingMode(DEFAULT_MODEL, {
+      onChangeAPIKey: context.onChangeAPIKey,
+    })
+    if (!activated.ok) {
+      onDone(
+        `GitHub token detected, but settings activation failed: ${activated.detail ?? 'unknown error'}. ` +
+          'Set CLAUDE_CODE_USE_GITHUB=1 and OPENAI_MODEL=github:copilot in user settings manually.',
+        { display: 'system' },
+      )
+      return null
+    }
+
+    onDone(
+      'GitHub Models already authorized. Activated GitHub Models mode using your existing token. Use /onboard-github --force to re-authenticate.',
+      { display: 'user' },
+    )
+    return null
+  }
+
   return (
     <OnboardGithub
       onDone={onDone}

src/commands/provider/provider.test.tsx

@@ -52,7 +52,11 @@ async function renderFinalFrame(node: React.ReactNode): Promise<string> {
     patchConsole: false,
   })
 
-  await instance.waitUntilExit()
+  // Timeout guard: if render throws before exit effect fires, don't hang
+  await Promise.race([
+    instance.waitUntilExit(),
+    new Promise<void>(resolve => setTimeout(resolve, 3000)),
+  ])
   return stripAnsi(extractLastFrame(getOutput()))
 }
 
@@ -275,6 +279,21 @@ test('buildCurrentProviderSummary does not relabel local gpt-5.4 providers as Co
   expect(summary.endpointLabel).toBe('http://127.0.0.1:8080/v1')
 })
 
+test('buildCurrentProviderSummary recognizes GitHub Models mode', () => {
+  const summary = buildCurrentProviderSummary({
+    processEnv: {
+      CLAUDE_CODE_USE_GITHUB: '1',
+      OPENAI_MODEL: 'github:copilot',
+      OPENAI_BASE_URL: 'https://models.github.ai/inference',
+    },
+    persisted: null,
+  })
+
+  expect(summary.providerLabel).toBe('GitHub Models')
+  expect(summary.modelLabel).toBe('github:copilot')
+  expect(summary.endpointLabel).toBe('https://models.github.ai/inference')
+})
+
 test('getProviderWizardDefaults ignores poisoned current provider values', () => {
   const defaults = getProviderWizardDefaults({
     OPENAI_API_KEY: 'sk-secret-12345678',

src/commands/provider/provider.tsx

@@ -178,6 +178,23 @@ export function buildCurrentProviderSummary(options?: {
     }
   }
 
+  if (isEnvTruthy(processEnv.CLAUDE_CODE_USE_GITHUB)) {
+    return {
+      providerLabel: 'GitHub Models',
+      modelLabel: getSafeDisplayValue(
+        processEnv.OPENAI_MODEL ?? 'github:copilot',
+        processEnv,
+      ),
+      endpointLabel: getSafeDisplayValue(
+        processEnv.OPENAI_BASE_URL ??
+          processEnv.OPENAI_API_BASE ??
+          'https://models.github.ai/inference',
+        processEnv,
+      ),
+      savedProfileLabel,
+    }
+  }
+
   if (isEnvTruthy(processEnv.CLAUDE_CODE_USE_OPENAI)) {
     const request = resolveProviderRequest({
       model: processEnv.OPENAI_MODEL,

src/components/ProviderManager.test.tsx

@@ -0,0 +1,305 @@
+import { PassThrough } from 'node:stream'
+
+import { afterEach, expect, mock, test } from 'bun:test'
+import React from 'react'
+import stripAnsi from 'strip-ansi'
+
+import { createRoot } from '../ink.js'
+import { AppStateProvider } from '../state/AppState.js'
+
+const SYNC_START = '\x1B[?2026h'
+const SYNC_END = '\x1B[?2026l'
+
+const ORIGINAL_ENV = {
+  CLAUDE_CODE_USE_GITHUB: process.env.CLAUDE_CODE_USE_GITHUB,
+  GITHUB_TOKEN: process.env.GITHUB_TOKEN,
+  GH_TOKEN: process.env.GH_TOKEN,
+}
+
+function extractLastFrame(output: string): string {
+  let lastFrame: string | null = null
+  let cursor = 0
+
+  while (cursor < output.length) {
+    const start = output.indexOf(SYNC_START, cursor)
+    if (start === -1) {
+      break
+    }
+
+    const contentStart = start + SYNC_START.length
+    const end = output.indexOf(SYNC_END, contentStart)
+    if (end === -1) {
+      break
+    }
+
+    const frame = output.slice(contentStart, end)
+    if (frame.trim().length > 0) {
+      lastFrame = frame
+    }
+    cursor = end + SYNC_END.length
+  }
+
+  return lastFrame ?? output
+}
+
+function createTestStreams(): {
+  stdout: PassThrough
+  stdin: PassThrough & {
+    isTTY: boolean
+    setRawMode: (mode: boolean) => void
+    ref: () => void
+    unref: () => void
+  }
+  getOutput: () => string
+} {
+  let output = ''
+  const stdout = new PassThrough()
+  const stdin = new PassThrough() as PassThrough & {
+    isTTY: boolean
+    setRawMode: (mode: boolean) => void
+    ref: () => void
+    unref: () => void
+  }
+
+  stdin.isTTY = true
+  stdin.setRawMode = () => {}
+  stdin.ref = () => {}
+  stdin.unref = () => {}
+  ;(stdout as unknown as { columns: number }).columns = 120
+  stdout.on('data', chunk => {
+    output += chunk.toString()
+  })
+
+  return {
+    stdout,
+    stdin,
+    getOutput: () => output,
+  }
+}
+
+async function waitForCondition(
+  predicate: () => boolean,
+  options?: { timeoutMs?: number; intervalMs?: number },
+): Promise<void> {
+  const timeoutMs = options?.timeoutMs ?? 2000
+  const intervalMs = options?.intervalMs ?? 10
+  const startedAt = Date.now()
+
+  while (Date.now() - startedAt < timeoutMs) {
+    if (predicate()) {
+      return
+    }
+    await Bun.sleep(intervalMs)
+  }
+
+  throw new Error('Timed out waiting for ProviderManager test condition')
+}
+
+function createDeferred<T>(): {
+  promise: Promise<T>
+  resolve: (value: T) => void
+} {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>(r => {
+    resolve = r
+  })
+  return { promise, resolve }
+}
+
+function mockProviderProfilesModule(): void {
+  mock.module('../utils/providerProfiles.js', () => ({
+    addProviderProfile: () => null,
+    applyActiveProviderProfileFromConfig: () => {},
+    deleteProviderProfile: () => ({ removed: false, activeProfileId: null }),
+    getActiveProviderProfile: () => null,
+    getProviderPresetDefaults: () => ({
+      provider: 'openai',
+      name: 'Mock provider',
+      baseUrl: 'http://localhost:11434/v1',
+      model: 'mock-model',
+      apiKey: '',
+    }),
+    getProviderProfiles: () => [],
+    setActiveProviderProfile: () => null,
+    updateProviderProfile: () => null,
+  }))
+}
+
+function mockProviderManagerDependencies(
+  syncRead: () => string | undefined,
+  asyncRead: () => Promise<string | undefined>,
+): void {
+  mockProviderProfilesModule()
+
+  mock.module('../utils/githubModelsCredentials.js', () => ({
+    clearGithubModelsToken: () => ({ success: true }),
+    GITHUB_MODELS_HYDRATED_ENV_MARKER: 'CLAUDE_CODE_GITHUB_TOKEN_HYDRATED',
+    hydrateGithubModelsTokenFromSecureStorage: () => {},
+    readGithubModelsToken: syncRead,
+    readGithubModelsTokenAsync: asyncRead,
+  }))
+
+  mock.module('../utils/settings/settings.js', () => ({
+    updateSettingsForSource: () => ({ error: null }),
+  }))
+}
+
+async function waitForFrameOutput(
+  getOutput: () => string,
+  predicate: (output: string) => boolean,
+  timeoutMs = 2500,
+): Promise<string> {
+  let output = ''
+
+  await waitForCondition(() => {
+    output = stripAnsi(extractLastFrame(getOutput()))
+    return predicate(output)
+  }, { timeoutMs })
+
+  return output
+}
+
+async function mountProviderManager(
+  ProviderManager: React.ComponentType<{
+    mode: 'first-run' | 'manage'
+    onDone: () => void
+  }>,
+): Promise<{
+  getOutput: () => string
+  dispose: () => Promise<void>
+}> {
+  const { stdout, stdin, getOutput } = createTestStreams()
+  const root = await createRoot({
+    stdout: stdout as unknown as NodeJS.WriteStream,
+    stdin: stdin as unknown as NodeJS.ReadStream,
+    patchConsole: false,
+  })
+
+  root.render(
+    <AppStateProvider>
+      <ProviderManager
+        mode="manage"
+        onDone={() => {}}
+      />
+    </AppStateProvider>,
+  )
+
+  return {
+    getOutput,
+    dispose: async () => {
+      root.unmount()
+      stdin.end()
+      stdout.end()
+      await Bun.sleep(0)
+    },
+  }
+}
+
+async function renderProviderManagerFrame(
+  ProviderManager: React.ComponentType<{
+    mode: 'first-run' | 'manage'
+    onDone: () => void
+  }>,
+  options?: {
+    waitForOutput?: (output: string) => boolean
+    timeoutMs?: number
+  },
+): Promise<string> {
+  const mounted = await mountProviderManager(ProviderManager)
+  const output = await waitForFrameOutput(
+    mounted.getOutput,
+    frame => {
+      if (!options?.waitForOutput) {
+        return frame.includes('Provider manager')
+      }
+      return options.waitForOutput(frame)
+    },
+    options?.timeoutMs ?? 2500,
+  )
+
+  await mounted.dispose()
+  return output
+}
+
+afterEach(() => {
+  mock.restore()
+
+  for (const [key, value] of Object.entries(ORIGINAL_ENV)) {
+    if (value === undefined) {
+      delete process.env[key as keyof typeof ORIGINAL_ENV]
+    } else {
+      process.env[key as keyof typeof ORIGINAL_ENV] = value
+    }
+  }
+})
+
+test('ProviderManager resolves GitHub virtual provider from async storage without sync reads in render flow', async () => {
+  delete process.env.CLAUDE_CODE_USE_GITHUB
+  delete process.env.GITHUB_TOKEN
+  delete process.env.GH_TOKEN
+
+  const syncRead = mock(() => {
+    throw new Error('sync credential read should not run in ProviderManager render flow')
+  })
+  const asyncRead = mock(async () => 'stored-token')
+
+  mockProviderManagerDependencies(syncRead, asyncRead)
+
+  const nonce = `${Date.now()}-${Math.random()}`
+  const { ProviderManager } = await import(`./ProviderManager.js?ts=${nonce}`)
+  const output = await renderProviderManagerFrame(ProviderManager, {
+    waitForOutput: frame =>
+      frame.includes('Provider manager') &&
+      frame.includes('GitHub Models') &&
+      frame.includes('token stored'),
+  })
+
+  expect(output).toContain('Provider manager')
+  expect(output).toContain('GitHub Models')
+  expect(output).toContain('token stored')
+  expect(output).not.toContain('No provider profiles configured yet.')
+
+  expect(syncRead).not.toHaveBeenCalled()
+  expect(asyncRead).toHaveBeenCalled()
+})
+
+test('ProviderManager avoids first-frame false negative while stored-token lookup is pending', async () => {
+  delete process.env.CLAUDE_CODE_USE_GITHUB
+  delete process.env.GITHUB_TOKEN
+  delete process.env.GH_TOKEN
+
+  const syncRead = mock(() => {
+    throw new Error('sync credential read should not run in ProviderManager render flow')
+  })
+  const deferredStoredToken = createDeferred<string | undefined>()
+  const asyncRead = mock(async () => deferredStoredToken.promise)
+
+  mockProviderManagerDependencies(syncRead, asyncRead)
+
+  const nonce = `${Date.now()}-${Math.random()}`
+  const { ProviderManager } = await import(`./ProviderManager.js?ts=${nonce}`)
+  const mounted = await mountProviderManager(ProviderManager)
+
+  const firstFrame = await waitForFrameOutput(
+    mounted.getOutput,
+    frame => frame.includes('Provider manager'),
+  )
+
+  expect(firstFrame).toContain('Checking GitHub Models credentials...')
+  expect(firstFrame).not.toContain('No provider profiles configured yet.')
+
+  deferredStoredToken.resolve('stored-token')
+
+  const resolvedFrame = await waitForFrameOutput(
+    mounted.getOutput,
+    frame => frame.includes('GitHub Models') && frame.includes('token stored'),
+  )
+
+  expect(resolvedFrame).toContain('GitHub Models')
+  expect(resolvedFrame).toContain('token stored')
+
+  await mounted.dispose()
+
+  expect(syncRead).not.toHaveBeenCalled()
+  expect(asyncRead).toHaveBeenCalled()
+})

src/components/ProviderManager.tsx

@@ -5,6 +5,7 @@ import { useKeybinding } from '../keybindings/useKeybinding.js'
 import type { ProviderProfile } from '../utils/config.js'
 import {
   addProviderProfile,
+  applyActiveProviderProfileFromConfig,
   deleteProviderProfile,
   getActiveProviderProfile,
   getProviderPresetDefaults,
@@ -14,6 +15,15 @@ import {
   type ProviderProfileInput,
   updateProviderProfile,
 } from '../utils/providerProfiles.js'
+import {
+  clearGithubModelsToken,
+  GITHUB_MODELS_HYDRATED_ENV_MARKER,
+  hydrateGithubModelsTokenFromSecureStorage,
+  readGithubModelsToken,
+  readGithubModelsTokenAsync,
+} from '../utils/githubModelsCredentials.js'
+import { isEnvTruthy } from '../utils/envUtils.js'
+import { updateSettingsForSource } from '../utils/settings/settings.js'
 import { Select } from './CustomSelect/index.js'
 import { Pane } from './design-system/Pane.js'
 import TextInput from './TextInput.js'
@@ -75,6 +85,13 @@ const FORM_STEPS: Array<{
   },
 ]
 
+const GITHUB_PROVIDER_ID = '__github_models__'
+const GITHUB_PROVIDER_LABEL = 'GitHub Models'
+const GITHUB_PROVIDER_DEFAULT_MODEL = 'github:copilot'
+const GITHUB_PROVIDER_DEFAULT_BASE_URL = 'https://models.github.ai/inference'
+
+type GithubCredentialSource = 'stored' | 'env' | 'none'
+
 function toDraft(profile: ProviderProfile): ProviderDraft {
   return {
     name: profile.name,
@@ -102,11 +119,83 @@ function profileSummary(profile: ProviderProfile, isActive: boolean): string {
   return `${providerKind} · ${profile.baseUrl} · ${profile.model} · ${keyInfo}${activeSuffix}`
 }
 
+function getGithubCredentialSourceFromEnv(
+  processEnv: NodeJS.ProcessEnv = process.env,
+): GithubCredentialSource {
+  if (processEnv.GITHUB_TOKEN?.trim() || processEnv.GH_TOKEN?.trim()) {
+    return 'env'
+  }
+  return 'none'
+}
+
+async function resolveGithubCredentialSource(
+  processEnv: NodeJS.ProcessEnv = process.env,
+): Promise<GithubCredentialSource> {
+  const envSource = getGithubCredentialSourceFromEnv(processEnv)
+  if (envSource !== 'none') {
+    return envSource
+  }
+
+  if (await readGithubModelsTokenAsync()) {
+    return 'stored'
+  }
+
+  return 'none'
+}
+
+function isGithubProviderAvailable(
+  credentialSource: GithubCredentialSource,
+  processEnv: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (isEnvTruthy(processEnv.CLAUDE_CODE_USE_GITHUB)) {
+    return true
+  }
+  return credentialSource !== 'none'
+}
+
+function getGithubProviderModel(
+  processEnv: NodeJS.ProcessEnv = process.env,
+): string {
+  if (isEnvTruthy(processEnv.CLAUDE_CODE_USE_GITHUB)) {
+    return processEnv.OPENAI_MODEL?.trim() || GITHUB_PROVIDER_DEFAULT_MODEL
+  }
+  return GITHUB_PROVIDER_DEFAULT_MODEL
+}
+
+function getGithubProviderSummary(
+  isActive: boolean,
+  credentialSource: GithubCredentialSource,
+  processEnv: NodeJS.ProcessEnv = process.env,
+): string {
+  const credentialSummary =
+    credentialSource === 'stored'
+      ? 'token stored'
+      : credentialSource === 'env'
+        ? 'token via env'
+        : 'no token found'
+  const activeSuffix = isActive ? ' (active)' : ''
+  return `github-models · ${GITHUB_PROVIDER_DEFAULT_BASE_URL} · ${getGithubProviderModel(processEnv)} · ${credentialSummary}${activeSuffix}`
+}
+
 export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
+  const initialGithubCredentialSource = getGithubCredentialSourceFromEnv()
+  const initialIsGithubActive = isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+  const initialHasGithubCredential = initialGithubCredentialSource !== 'none'
+
   const [profiles, setProfiles] = React.useState(() => getProviderProfiles())
   const [activeProfileId, setActiveProfileId] = React.useState(
     () => getActiveProviderProfile()?.id,
   )
+  const [githubProviderAvailable, setGithubProviderAvailable] = React.useState(
+    () => isGithubProviderAvailable(initialGithubCredentialSource),
+  )
+  const [githubCredentialSource, setGithubCredentialSource] = React.useState<GithubCredentialSource>(
+    () => initialGithubCredentialSource,
+  )
+  const [isGithubActive, setIsGithubActive] = React.useState(() => initialIsGithubActive)
+  const [isGithubCredentialSourceResolved, setIsGithubCredentialSourceResolved] =
+    React.useState(() => initialHasGithubCredential || initialIsGithubActive)
+  const githubRefreshEpochRef = React.useRef(0)
   const [screen, setScreen] = React.useState<Screen>(
     mode === 'first-run' ? 'select-preset' : 'menu',
   )
@@ -126,16 +215,155 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
   const currentStepKey = currentStep.key
   const currentValue = draft[currentStepKey]
 
+  const refreshGithubProviderState = React.useCallback((): void => {
+    const envCredentialSource = getGithubCredentialSourceFromEnv()
+    const githubActive = isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+    const canResolveFromEnv = githubActive || envCredentialSource !== 'none'
+
+    if (canResolveFromEnv) {
+      githubRefreshEpochRef.current += 1
+      setGithubCredentialSource(envCredentialSource)
+      setGithubProviderAvailable(isGithubProviderAvailable(envCredentialSource))
+      setIsGithubActive(githubActive)
+      setIsGithubCredentialSourceResolved(true)
+      return
+    }
+
+    setIsGithubCredentialSourceResolved(false)
+    const refreshEpoch = ++githubRefreshEpochRef.current
+    void (async () => {
+      const credentialSource = await resolveGithubCredentialSource()
+      if (refreshEpoch !== githubRefreshEpochRef.current) {
+        return
+      }
+
+      setGithubCredentialSource(credentialSource)
+      setGithubProviderAvailable(isGithubProviderAvailable(credentialSource))
+      setIsGithubActive(isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB))
+      setIsGithubCredentialSourceResolved(true)
+    })()
+  }, [])
+
+  React.useEffect(() => {
+    refreshGithubProviderState()
+
+    return () => {
+      githubRefreshEpochRef.current += 1
+    }
+  }, [refreshGithubProviderState])
+
   function refreshProfiles(): void {
     const nextProfiles = getProviderProfiles()
     setProfiles(nextProfiles)
     setActiveProfileId(getActiveProviderProfile()?.id)
+    refreshGithubProviderState()
+  }
+
+  function clearStartupProviderOverrideFromUserSettings(): string | null {
+    const { error } = updateSettingsForSource('userSettings', {
+      env: {
+        CLAUDE_CODE_USE_OPENAI: undefined as any,
+        CLAUDE_CODE_USE_GEMINI: undefined as any,
+        CLAUDE_CODE_USE_GITHUB: undefined as any,
+        CLAUDE_CODE_USE_BEDROCK: undefined as any,
+        CLAUDE_CODE_USE_VERTEX: undefined as any,
+        CLAUDE_CODE_USE_FOUNDRY: undefined as any,
+      },
+    })
+    return error ? error.message : null
   }
 
   function closeWithCancelled(message: string): void {
     onDone({ action: 'cancelled', message })
   }
 
+  function activateGithubProvider(): string | null {
+    const { error } = updateSettingsForSource('userSettings', {
+      env: {
+        CLAUDE_CODE_USE_GITHUB: '1',
+        OPENAI_MODEL: GITHUB_PROVIDER_DEFAULT_MODEL,
+        OPENAI_API_KEY: undefined as any,
+        OPENAI_ORG: undefined as any,
+        OPENAI_PROJECT: undefined as any,
+        OPENAI_ORGANIZATION: undefined as any,
+        OPENAI_BASE_URL: undefined as any,
+        OPENAI_API_BASE: undefined as any,
+        CLAUDE_CODE_USE_OPENAI: undefined as any,
+        CLAUDE_CODE_USE_GEMINI: undefined as any,
+        CLAUDE_CODE_USE_BEDROCK: undefined as any,
+        CLAUDE_CODE_USE_VERTEX: undefined as any,
+        CLAUDE_CODE_USE_FOUNDRY: undefined as any,
+      },
+    })
+    if (error) {
+      return error.message
+    }
+
+    process.env.CLAUDE_CODE_USE_GITHUB = '1'
+    process.env.OPENAI_MODEL = GITHUB_PROVIDER_DEFAULT_MODEL
+    delete process.env.OPENAI_API_KEY
+    delete process.env.OPENAI_ORG
+    delete process.env.OPENAI_PROJECT
+    delete process.env.OPENAI_ORGANIZATION
+    delete process.env.OPENAI_BASE_URL
+    delete process.env.OPENAI_API_BASE
+    delete process.env.CLAUDE_CODE_USE_OPENAI
+    delete process.env.CLAUDE_CODE_USE_GEMINI
+    delete process.env.CLAUDE_CODE_USE_BEDROCK
+    delete process.env.CLAUDE_CODE_USE_VERTEX
+    delete process.env.CLAUDE_CODE_USE_FOUNDRY
+    delete process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED
+    delete process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID
+    delete process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER]
+
+    hydrateGithubModelsTokenFromSecureStorage()
+    return null
+  }
+
+  function deleteGithubProvider(): string | null {
+    const storedTokenBeforeClear = readGithubModelsToken()?.trim()
+    const cleared = clearGithubModelsToken()
+    if (!cleared.success) {
+      return cleared.warning ?? 'Could not clear GitHub credentials.'
+    }
+
+    const { error } = updateSettingsForSource('userSettings', {
+      env: {
+        CLAUDE_CODE_USE_GITHUB: undefined as any,
+        OPENAI_MODEL: undefined as any,
+        OPENAI_BASE_URL: undefined as any,
+        OPENAI_API_BASE: undefined as any,
+      },
+    })
+    if (error) {
+      return error.message
+    }
+
+    const hydratedTokenInSession = process.env.GITHUB_TOKEN?.trim()
+    if (
+      process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER] === '1' &&
+      hydratedTokenInSession &&
+      (!storedTokenBeforeClear || hydratedTokenInSession === storedTokenBeforeClear)
+    ) {
+      delete process.env.GITHUB_TOKEN
+    }
+
+    delete process.env.CLAUDE_CODE_USE_GITHUB
+    delete process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER]
+    delete process.env.OPENAI_MODEL
+    delete process.env.OPENAI_API_KEY
+    delete process.env.OPENAI_ORG
+    delete process.env.OPENAI_PROJECT
+    delete process.env.OPENAI_ORGANIZATION
+    delete process.env.OPENAI_BASE_URL
+    delete process.env.OPENAI_API_BASE
+
+    // Restore active provider profile immediately when one exists.
+    applyActiveProviderProfileFromConfig()
+
+    return null
+  }
+
   function startCreateFromPreset(preset: ProviderPreset): void {
     const defaults = getProviderPresetDefaults(preset)
     const nextDraft = {
@@ -187,11 +415,20 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
       return
     }
 
+    const isActiveSavedProfile = getActiveProviderProfile()?.id === saved.id
+    const settingsOverrideError = isActiveSavedProfile
+      ? clearStartupProviderOverrideFromUserSettings()
+      : null
+
     refreshProfiles()
-    setStatusMessage(
+    const successMessage =
       editingProfileId
         ? `Updated provider: ${saved.name}`
-        : `Added provider: ${saved.name} (now active)`,
+        : `Added provider: ${saved.name} (now active)`
+    setStatusMessage(
+      settingsOverrideError
+        ? `${successMessage}. Warning: could not clear startup provider override (${settingsOverrideError}).`
+        : successMessage,
     )
 
     if (mode === 'first-run') {
@@ -413,6 +650,7 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
 
   function renderMenu(): React.ReactNode {
     const hasProfiles = profiles.length > 0
+    const hasSelectableProviders = hasProfiles || githubProviderAvailable
 
     const options = [
       {
@@ -424,7 +662,7 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
         value: 'activate',
         label: 'Set active provider',
         description: 'Switch the active provider profile',
-        disabled: !hasProfiles,
+        disabled: !hasSelectableProviders,
       },
       {
         value: 'edit',
@@ -436,7 +674,7 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
         value: 'delete',
         label: 'Delete provider',
         description: 'Remove a provider profile',
-        disabled: !hasProfiles,
+        disabled: !hasSelectableProviders,
       },
       {
         value: 'done',
@@ -455,14 +693,29 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
         </Text>
         {statusMessage && <Text>{statusMessage}</Text>}
         <Box flexDirection="column">
-          {profiles.length === 0 ? (
-            <Text dimColor>No provider profiles configured yet.</Text>
+          {profiles.length === 0 && !githubProviderAvailable ? (
+            isGithubCredentialSourceResolved ? (
+              <Text dimColor>No provider profiles configured yet.</Text>
+            ) : (
+              <Text dimColor>Checking GitHub Models credentials...</Text>
+            )
           ) : (
-            profiles.map(profile => (
-              <Text key={profile.id} dimColor>
-                - {profile.name}: {profileSummary(profile, profile.id === activeProfileId)}
-              </Text>
-            ))
+            <>
+              {profiles.map(profile => (
+                <Text key={profile.id} dimColor>
+                  - {profile.name}: {profileSummary(profile, profile.id === activeProfileId)}
+                </Text>
+              ))}
+              {githubProviderAvailable ? (
+                <Text dimColor>
+                  - {GITHUB_PROVIDER_LABEL}:{' '}
+                  {getGithubProviderSummary(
+                    isGithubActive,
+                    githubCredentialSource,
+                  )}
+                </Text>
+              ) : null}
+            </>
           )}
         </Box>
         <Select
@@ -474,7 +727,7 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
                 setScreen('select-preset')
                 break
               case 'activate':
-                if (profiles.length > 0) {
+                if (hasSelectableProviders) {
                   setScreen('select-active')
                 }
                 break
@@ -484,7 +737,7 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
                 }
                 break
               case 'delete':
-                if (profiles.length > 0) {
+                if (hasSelectableProviders) {
                   setScreen('select-delete')
                 }
                 break
@@ -504,8 +757,29 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
     title: string,
     emptyMessage: string,
     onSelect: (profileId: string) => void,
+    options?: { includeGithub?: boolean },
   ): React.ReactNode {
-    if (profiles.length === 0) {
+    const includeGithub = options?.includeGithub ?? false
+    const selectOptions = profiles.map(profile => ({
+      value: profile.id,
+      label:
+        profile.id === activeProfileId
+          ? `${profile.name} (active)`
+          : profile.name,
+      description: `${profile.provider === 'anthropic' ? 'anthropic' : 'openai-compatible'} · ${profile.baseUrl} · ${profile.model}`,
+    }))
+
+    if (includeGithub && githubProviderAvailable) {
+      selectOptions.push({
+        value: GITHUB_PROVIDER_ID,
+        label: isGithubActive
+          ? `${GITHUB_PROVIDER_LABEL} (active)`
+          : GITHUB_PROVIDER_LABEL,
+        description: `github-models · ${GITHUB_PROVIDER_DEFAULT_BASE_URL} · ${getGithubProviderModel()}`,
+      })
+    }
+
+    if (selectOptions.length === 0) {
       return (
         <Box flexDirection="column" gap={1}>
           <Text color="remember" bold>
@@ -528,25 +802,16 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
       )
     }
 
-    const options = profiles.map(profile => ({
-      value: profile.id,
-      label:
-        profile.id === activeProfileId
-          ? `${profile.name} (active)`
-          : profile.name,
-      description: `${profile.provider === 'anthropic' ? 'anthropic' : 'openai-compatible'} · ${profile.baseUrl} · ${profile.model}`,
-    }))
-
     return (
       <Box flexDirection="column" gap={1}>
         <Text color="remember" bold>
           {title}
         </Text>
         <Select
-          options={options}
+          options={selectOptions}
           onChange={onSelect}
           onCancel={() => setScreen('menu')}
-          visibleOptionCount={Math.min(10, Math.max(2, options.length))}
+          visibleOptionCount={Math.min(10, Math.max(2, selectOptions.length))}
         />
       </Box>
     )
@@ -566,16 +831,36 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
         'Set active provider',
         'No providers available. Add one first.',
         profileId => {
+          if (profileId === GITHUB_PROVIDER_ID) {
+            const githubError = activateGithubProvider()
+            if (githubError) {
+              setErrorMessage(`Could not activate GitHub provider: ${githubError}`)
+              setScreen('menu')
+              return
+            }
+            refreshProfiles()
+            setStatusMessage(`Active provider: ${GITHUB_PROVIDER_LABEL}`)
+            setScreen('menu')
+            return
+          }
+
           const active = setActiveProviderProfile(profileId)
           if (!active) {
             setErrorMessage('Could not change active provider.')
             setScreen('menu')
             return
           }
+          const settingsOverrideError =
+            clearStartupProviderOverrideFromUserSettings()
           refreshProfiles()
-          setStatusMessage(`Active provider: ${active.name}`)
+          setStatusMessage(
+            settingsOverrideError
+              ? `Active provider: ${active.name}. Warning: could not clear startup provider override (${settingsOverrideError}).`
+              : `Active provider: ${active.name}`,
+          )
           setScreen('menu')
         },
+          { includeGithub: true },
       )
       break
     case 'select-edit':
@@ -592,15 +877,35 @@ export function ProviderManager({ mode, onDone }: Props): React.ReactNode {
         'Delete provider',
         'No providers available. Add one first.',
         profileId => {
+          if (profileId === GITHUB_PROVIDER_ID) {
+            const githubDeleteError = deleteGithubProvider()
+            if (githubDeleteError) {
+              setErrorMessage(`Could not delete GitHub provider: ${githubDeleteError}`)
+            } else {
+              refreshProfiles()
+              setStatusMessage('GitHub provider deleted')
+            }
+            setScreen('menu')
+            return
+          }
+
           const result = deleteProviderProfile(profileId)
           if (!result.removed) {
             setErrorMessage('Could not delete provider.')
           } else {
+            const settingsOverrideError = result.activeProfileId
+              ? clearStartupProviderOverrideFromUserSettings()
+              : null
             refreshProfiles()
-            setStatusMessage('Provider deleted')
+            setStatusMessage(
+              settingsOverrideError
+                ? `Provider deleted. Warning: could not clear startup provider override (${settingsOverrideError}).`
+                : 'Provider deleted',
+            )
           }
           setScreen('menu')
         },
+        { includeGithub: true },
       )
       break
     case 'menu':

src/components/agents/generateAgent.ts

@@ -68,11 +68,11 @@ When a user describes what they want an agent to do, you will:
       assistant: "Now let me use the test-runner agent to run the tests"
     </example>
     - <example>
-      Context: User is creating an agent to respond to the word "hello" with a friendly jok.
-      user: "Hello"
-      assistant: "I'm going to use the ${AGENT_TOOL_NAME} tool to launch the greeting-responder agent to respond with a friendly joke"
+      Context: User is creating an agent for Claude Code product questions.
+      user: "How do I configure Claude Code hooks?"
+      assistant: "I'm going to use the ${AGENT_TOOL_NAME} tool to launch the claude-code-guide agent to answer the question"
       <commentary>
-      Since the user is greeting, use the greeting-responder agent to respond with a friendly joke. 
+      Since the user is asking how to use Claude Code, use the claude-code-guide agent.
       </commentary>
     </example>
   - If the user mentioned or implied that the agent should be used proactively, you should include examples of this.

src/entrypoints/cli.tsx

@@ -8,6 +8,34 @@ import {
   validateProviderEnvOrExit,
 } from '../utils/providerValidation.js'
 
+// OpenClaude: polyfill globalThis.File for Node < 20.
+// undici v7 references `File` at module evaluation time (webidl type
+// assertions). Node 18 lacks the global, causing a ReferenceError inside
+// the bundled __commonJS require chain which deadlocks the process when a
+// proxy is configured (configureGlobalAgents → require_undici).
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+if (typeof globalThis.File === 'undefined') {
+  try {
+    // Node 18.13+ exposes File in node:buffer but not as a global.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { File: NodeFile } = require('node:buffer')
+    // @ts-expect-error -- polyfilling missing global
+    globalThis.File = NodeFile
+  } catch {
+    // Absolute fallback: stub so `MakeTypeAssertion(File)` doesn't throw.
+    // @ts-expect-error -- minimal polyfill
+    globalThis.File = class File extends Blob {
+      name: string
+      lastModified: number
+      constructor(parts: BlobPart[], name: string, opts?: FilePropertyBag) {
+        super(parts, opts)
+        this.name = name
+        this.lastModified = opts?.lastModified ?? Date.now()
+      }
+    }
+  }
+}
+
 // OpenClaude: disable experimental API betas by default.
 // Tool search (defer_loading), global cache scope, and context management
 // require internal API support not available to external accounts → 500.

src/grpc/server.ts

@@ -40,7 +40,7 @@ export class GrpcServer {
       grpc.ServerCredentials.createInsecure(),
       (error, boundPort) => {
         if (error) {
-          console.error('Failed to start gRPC server', error)
+          console.error('Failed to start gRPC server')
           return
         }
         console.log(`gRPC Server running at ${host}:${boundPort}`)
@@ -225,7 +225,7 @@ export class GrpcServer {
           call.end()
         }
       } catch (err: any) {
-        console.error("Error processing stream:", err)
+        console.error('Error processing stream')
         call.write({
           error: {
             message: err.message || "Internal server error",

src/ink/reconciler.ts

@@ -366,14 +366,12 @@ const reconciler = createReconciler<
   createTextInstance(
     text: string,
     _root: DOMElement,
-    hostContext: HostContext,
+    _hostContext: HostContext,
   ): TextNode {
-    if (!hostContext.isInsideText) {
-      throw new Error(
-        `Text string "${text}" must be rendered inside <Text> component`,
-      )
-    }
-
+    // react-compiler memoization can reuse cached <Text> elements without
+    // re-traversing getChildHostContext, so hostContext.isInsideText may be
+    // stale. Always create the text node — Ink will render it correctly
+    // regardless of the context tracking state.
     return createTextNode(text)
   },
   resetTextContent() {},

src/ink/termio/osc.test.ts

@@ -27,6 +27,21 @@ async function flushClipboardCopy(): Promise<void> {
   await new Promise(resolve => setTimeout(resolve, 0))
 }
 
+async function waitForExecCall(
+  command: string,
+  attempts = 20,
+): Promise<(typeof execFileNoThrowMock.mock.calls)[number] | undefined> {
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    const call = execFileNoThrowMock.mock.calls.find(([cmd]) => cmd === command)
+    if (call) {
+      return call
+    }
+    await flushClipboardCopy()
+  }
+
+  return undefined
+}
+
 describe('Windows clipboard fallback', () => {
   beforeEach(() => {
     execFileNoThrowMock.mockClear()
@@ -62,9 +77,7 @@ describe('Windows clipboard fallback', () => {
     await setClipboard('Привет мир')
     await flushClipboardCopy()
 
-    const windowsCall = execFileNoThrowMock.mock.calls.find(
-      ([cmd]) => cmd === 'powershell',
-    )
+    const windowsCall = await waitForExecCall('powershell')
 
     expect(windowsCall?.[2]).toMatchObject({
       stdin: 'ignore',

src/screens/REPL.tsx

@@ -237,6 +237,8 @@ import { useOfficialMarketplaceNotification } from 'src/hooks/useOfficialMarketp
 import { usePromptsFromClaudeInChrome } from 'src/hooks/usePromptsFromClaudeInChrome.js';
 import { getTipToShowOnSpinner, recordShownTip } from 'src/services/tips/tipScheduler.js';
 import type { Theme } from 'src/utils/theme.js';
+import { isPromptTypingSuppressionActive } from './replInputSuppression.js';
+import { shouldRunStartupChecks } from './replStartupGates.js';
 import { checkAndDisableBypassPermissionsIfNeeded, checkAndDisableAutoModeIfNeeded, useKickOffCheckAndDisableBypassPermissionsIfNeeded, useKickOffCheckAndDisableAutoModeIfNeeded } from 'src/utils/permissions/bypassPermissionsKillswitch.js';
 import { SandboxManager } from 'src/utils/sandbox/sandbox-adapter.js';
 import { SANDBOX_NETWORK_ACCESS_TOOL_NAME } from 'src/cli/structuredIO.js';
@@ -791,10 +793,8 @@ export function REPL({
   // accepts, and only then is the REPL component mounted and this effect runs.
   // This ensures that plugin installations from repository and user settings only
   // happen after explicit user consent to trust the current working directory.
-  useEffect(() => {
-    if (isRemoteSession) return;
-    void performStartupChecks(setAppState);
-  }, [setAppState, isRemoteSession]);
+  // Deferring startup checks is handled below (after promptTypingSuppressionActive
+  // is declared) to avoid temporal dead zone issues.
 
   // Allow Claude in Chrome MCP to send prompts through MCP notifications
   // and sync permission mode changes to the Chrome extension
@@ -1336,6 +1336,7 @@ export function REPL({
   const [inputValue, setInputValueRaw] = useState(() => consumeEarlyInput());
   const inputValueRef = useRef(inputValue);
   inputValueRef.current = inputValue;
+  const promptTypingSuppressionActive = isPromptTypingSuppressionActive(isPromptInputActive, inputValue);
   const insertTextRef = useRef<{
     insert: (text: string) => void;
     setInputWithCursor: (value: string, cursor: number) => void;
@@ -1427,6 +1428,25 @@ export function REPL({
   const activeRemote = sshRemote.isRemoteMode ? sshRemote : directConnect.isRemoteMode ? directConnect : remoteSession;
   const [pastedContents, setPastedContents] = useState<Record<number, PastedContent>>({});
   const [submitCount, setSubmitCount] = useState(0);
+
+  // Defer startup checks until the user has submitted their first message.
+  // A timeout or grace period is insufficient (issue #363): if the user pauses
+  // before typing, startup checks can still fire and recommendation dialogs
+  // steal focus. Only the user's first submission guarantees the prompt was
+  // the first thing they interacted with.
+  const startupChecksStartedRef = React.useRef(false);
+  const hasHadFirstSubmission = (submitCount ?? 0) > 0;
+  useEffect(() => {
+    if (isRemoteSession) return;
+    if (startupChecksStartedRef.current) return;
+    if (!shouldRunStartupChecks({
+      isRemoteSession,
+      hasStarted: startupChecksStartedRef.current,
+      hasHadFirstSubmission,
+    })) return;
+    startupChecksStartedRef.current = true;
+    void performStartupChecks(setAppState);
+  }, [setAppState, isRemoteSession, hasHadFirstSubmission]);
   // Ref instead of state to avoid triggering React re-renders on every
   // streaming text_delta. The spinner reads this via its animation timer.
   const responseLengthRef = useRef(0);
@@ -2028,7 +2048,7 @@ export function REPL({
     if (isMessageSelectorVisible) return 'message-selector';
 
     // Suppress interrupt dialogs while user is actively typing
-    if (isPromptInputActive) return undefined;
+    if (promptTypingSuppressionActive) return undefined;
     if (sandboxPermissionRequestQueue[0]) return 'sandbox-permission';
 
     // Permission/interactive dialogs (show unless blocked by toolJSX)
@@ -2059,19 +2079,20 @@ export function REPL({
     if (allowDialogsWithAnimation && showRemoteCallout) return 'remote-callout';
 
     // LSP plugin recommendation (lowest priority - non-blocking suggestion)
-    if (allowDialogsWithAnimation && lspRecommendation) return 'lsp-recommendation';
+    // Suppress during startup window to prevent stealing focus from the prompt (issue #363)
+    if (allowDialogsWithAnimation && lspRecommendation && startupChecksStartedRef.current) return 'lsp-recommendation';
 
     // Plugin hint from CLI/SDK stderr (same priority band as LSP rec)
-    if (allowDialogsWithAnimation && hintRecommendation) return 'plugin-hint';
+    if (allowDialogsWithAnimation && hintRecommendation && startupChecksStartedRef.current) return 'plugin-hint';
 
     // Desktop app upsell (max 3 launches, lowest priority)
-    if (allowDialogsWithAnimation && showDesktopUpsellStartup) return 'desktop-upsell';
+    if (allowDialogsWithAnimation && showDesktopUpsellStartup && startupChecksStartedRef.current) return 'desktop-upsell';
     return undefined;
   }
   const focusedInputDialog = getFocusedInputDialog();
 
   // True when permission prompts exist but are hidden because the user is typing
-  const hasSuppressedDialogs = isPromptInputActive && (sandboxPermissionRequestQueue[0] || toolUseConfirmQueue[0] || promptQueue[0] || workerSandboxPermissions.queue[0] || elicitation.queue[0] || showingCostDialog);
+  const hasSuppressedDialogs = promptTypingSuppressionActive && (sandboxPermissionRequestQueue[0] || toolUseConfirmQueue[0] || promptQueue[0] || workerSandboxPermissions.queue[0] || elicitation.queue[0] || showingCostDialog);
 
   // Keep ref in sync so timer callbacks can read the current value
   focusedInputDialogRef.current = focusedInputDialog;

src/screens/replInputSuppression.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'bun:test'
+
+import { isPromptTypingSuppressionActive } from './replInputSuppression.js'
+
+describe('isPromptTypingSuppressionActive', () => {
+  it('suppresses dialogs when early input already exists', () => {
+    expect(isPromptTypingSuppressionActive(false, 'hello')).toBe(true)
+  })
+
+  it('does not suppress dialogs for empty or whitespace-only input', () => {
+    expect(isPromptTypingSuppressionActive(false, '')).toBe(false)
+    expect(isPromptTypingSuppressionActive(false, '   ')).toBe(false)
+  })
+
+  it('keeps suppression active while the typing flag is set', () => {
+    expect(isPromptTypingSuppressionActive(true, '')).toBe(true)
+  })
+})

src/screens/replInputSuppression.ts

@@ -0,0 +1,6 @@
+export function isPromptTypingSuppressionActive(
+  isPromptInputActive: boolean,
+  inputValue: string,
+): boolean {
+  return isPromptInputActive || inputValue.trim().length > 0
+}

src/screens/replStartupGates.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from 'bun:test'
+
+import { shouldRunStartupChecks } from './replStartupGates.js'
+
+describe('shouldRunStartupChecks', () => {
+  test('runs checks after first message submission', () => {
+    expect(shouldRunStartupChecks({
+      isRemoteSession: false,
+      hasStarted: false,
+      hasHadFirstSubmission: true,
+    })).toBe(true)
+  })
+
+  test('skips checks in remote sessions even after submission', () => {
+    expect(shouldRunStartupChecks({
+      isRemoteSession: true,
+      hasStarted: false,
+      hasHadFirstSubmission: true,
+    })).toBe(false)
+  })
+
+  test('skips checks if already started', () => {
+    expect(shouldRunStartupChecks({
+      isRemoteSession: false,
+      hasStarted: true,
+      hasHadFirstSubmission: true,
+    })).toBe(false)
+  })
+
+  test('does not run checks before first submission', () => {
+    expect(shouldRunStartupChecks({
+      isRemoteSession: false,
+      hasStarted: false,
+      hasHadFirstSubmission: false,
+    })).toBe(false)
+  })
+
+  test('does not run checks when idle before first submission', () => {
+    expect(shouldRunStartupChecks({
+      isRemoteSession: false,
+      hasStarted: false,
+      hasHadFirstSubmission: false,
+    })).toBe(false)
+  })
+
+  test('skips checks in remote session regardless of other conditions', () => {
+    expect(shouldRunStartupChecks({
+      isRemoteSession: true,
+      hasStarted: false,
+      hasHadFirstSubmission: false,
+    })).toBe(false)
+  })
+})

src/screens/replStartupGates.ts

@@ -0,0 +1,35 @@
+/**
+ * Startup gates for the REPL.
+ *
+ * Prevents startup plugin checks and recommendation dialogs from stealing
+ * focus before the user has interacted with the prompt.
+ *
+ * This addresses the root cause of issue #363: on mount, performStartupChecks
+ * triggers plugin loading, which populates trackedFiles, which triggers
+ * useLspPluginRecommendation to surface an LSP recommendation dialog. Since
+ * promptTypingSuppressionActive is false before the user has typed anything,
+ * getFocusedInputDialog() returns the dialog, unmounting PromptInput entirely.
+ *
+ * The fix gates startup checks on actual prompt interaction. A pure timeout
+ * or grace period is insufficient because pausing before typing would still
+ * allow dialogs to steal focus. Only the user's first submission guarantees
+ * the prompt is no longer in the vulnerable pre-interaction window.
+ */
+
+/**
+ * Determines whether startup checks should run.
+ *
+ * Startup checks are deferred until the user has submitted their first
+ * message. This guarantees the prompt was the first thing the user interacted
+ * with, so no recommendation dialog can steal focus before the first keystroke.
+ */
+export function shouldRunStartupChecks(options: {
+  isRemoteSession: boolean;
+  hasStarted: boolean;
+  hasHadFirstSubmission: boolean;
+}): boolean {
+  if (options.isRemoteSession) return false;
+  if (options.hasStarted) return false;
+  if (!options.hasHadFirstSubmission) return false;
+  return true;
+}

src/services/api/codexShim.test.ts

@@ -201,6 +201,117 @@ describe('Codex request translation', () => {
     ])
   })
 
+  test('preserves Grep tool pattern field in Codex strict schemas', () => {
+    const tools = convertToolsToResponsesTools([
+      {
+        name: 'Grep',
+        description: 'Search file contents',
+        input_schema: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Search pattern' },
+            path: { type: 'string' },
+          },
+          required: ['pattern'],
+          additionalProperties: false,
+        },
+      },
+    ])
+
+    expect(tools).toEqual([
+      {
+        type: 'function',
+        name: 'Grep',
+        description: 'Search file contents',
+        parameters: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Search pattern' },
+            path: { type: 'string' },
+          },
+          required: ['pattern', 'path'],
+          additionalProperties: false,
+        },
+        strict: true,
+      },
+    ])
+  })
+
+  test('preserves Glob tool pattern field in Codex strict schemas', () => {
+    const tools = convertToolsToResponsesTools([
+      {
+        name: 'Glob',
+        description: 'Find files by pattern',
+        input_schema: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Glob pattern' },
+            path: { type: 'string' },
+          },
+          required: ['pattern'],
+          additionalProperties: false,
+        },
+      },
+    ])
+
+    expect(tools).toEqual([
+      {
+        type: 'function',
+        name: 'Glob',
+        description: 'Find files by pattern',
+        parameters: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Glob pattern' },
+            path: { type: 'string' },
+          },
+          required: ['pattern', 'path'],
+          additionalProperties: false,
+        },
+        strict: true,
+      },
+    ])
+  })
+
+  test('strips validator pattern keyword but keeps string field named pattern in Codex schemas', () => {
+    const tools = convertToolsToResponsesTools([
+      {
+        name: 'RegexProbe',
+        description: 'Probe regex schema handling',
+        input_schema: {
+          type: 'object',
+          properties: {
+            pattern: {
+              type: 'string',
+              pattern: '^[a-z]+$',
+            },
+          },
+          required: ['pattern'],
+          additionalProperties: false,
+        },
+      },
+    ])
+
+    expect(tools).toEqual([
+      {
+        type: 'function',
+        name: 'RegexProbe',
+        description: 'Probe regex schema handling',
+        parameters: {
+          type: 'object',
+          properties: {
+            pattern: {
+              type: 'string',
+            },
+          },
+          required: ['pattern'],
+          additionalProperties: false,
+        },
+        strict: true,
+      },
+    ])
+  })
+
   test('removes unsupported uri format from strict Responses schemas', () => {
     const tools = convertToolsToResponsesTools([
       {

src/services/api/openaiShim.ts

@@ -42,6 +42,10 @@ import {
 } from './providerConfig.js'
 import { sanitizeSchemaForOpenAICompat } from '../../utils/schemaSanitizer.js'
 import { redactSecretValueForDisplay } from '../../utils/providerProfile.js'
+import {
+  normalizeToolArguments,
+  hasToolFieldMapping,
+} from './toolArgumentNormalization.js'
 
 type SecretValueSource = Partial<{
   OPENAI_API_KEY: string
@@ -56,11 +60,22 @@ const GITHUB_API_VERSION = '2022-11-28'
 const GITHUB_429_MAX_RETRIES = 3
 const GITHUB_429_BASE_DELAY_SEC = 1
 const GITHUB_429_MAX_DELAY_SEC = 32
+const GEMINI_API_HOST = 'generativelanguage.googleapis.com'
 
 function isGithubModelsMode(): boolean {
   return isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
 }
 
+function hasGeminiApiHost(baseUrl: string | undefined): boolean {
+  if (!baseUrl) return false
+
+  try {
+    return new URL(baseUrl).hostname.toLowerCase() === GEMINI_API_HOST
+  } catch {
+    return false
+  }
+}
+
 function formatRetryAfterHint(response: Response): string {
   const ra = response.headers.get('retry-after')
   return ra ? ` (Retry-After: ${ra})` : ''
@@ -180,10 +195,12 @@ function convertContentBlocks(
         // handled separately
         break
       case 'thinking':
-        // Append thinking as text with a marker for models that support reasoning
-        if (block.thinking) {
-          parts.push({ type: 'text', text: `<thinking>${block.thinking}</thinking>` })
-        }
+      case 'redacted_thinking':
+        // Strip thinking blocks for OpenAI-compatible providers.
+        // These are Anthropic-specific content types that 3P providers
+        // don't understand. Serializing them as <thinking> text corrupts
+        // multi-turn context: the model sees the tags as part of its
+        // previous reply and may mimic or misattribute them.
         break
       default:
         if (block.text) {
@@ -197,6 +214,13 @@ function convertContentBlocks(
   return parts
 }
 
+function isGeminiMode(): boolean {
+  return (
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI) ||
+    hasGeminiApiHost(process.env.OPENAI_BASE_URL)
+  )
+}
+
 function convertMessages(
   messages: Array<{ role: string; message?: { role?: string; content?: unknown }; content?: unknown }>,
   system: unknown,
@@ -248,6 +272,7 @@ function convertMessages(
       // Check for tool_use blocks
       if (Array.isArray(content)) {
         const toolUses = content.filter((b: { type?: string }) => b.type === 'tool_use')
+        const thinkingBlock = content.find((b: { type?: string }) => b.type === 'thinking')
         const textContent = content.filter(
           (b: { type?: string }) => b.type !== 'tool_use' && b.type !== 'thinking',
         )
@@ -267,18 +292,46 @@ function convertMessages(
               name?: string
               input?: unknown
               extra_content?: Record<string, unknown>
-            }) => ({
-              id: tu.id ?? `call_${crypto.randomUUID().replace(/-/g, '')}`,
-              type: 'function' as const,
-              function: {
-                name: tu.name ?? 'unknown',
-                arguments:
-                  typeof tu.input === 'string'
-                    ? tu.input
-                    : JSON.stringify(tu.input ?? {}),
-              },
-              ...(tu.extra_content ? { extra_content: tu.extra_content } : {}),
-            }),
+              signature?: string
+            }, index) => {
+              const toolCall: NonNullable<OpenAIMessage['tool_calls']>[number] = {
+                id: tu.id ?? `call_${crypto.randomUUID().replace(/-/g, '')}`,
+                type: 'function' as const,
+                function: {
+                  name: tu.name ?? 'unknown',
+                  arguments:
+                    typeof tu.input === 'string'
+                      ? tu.input
+                      : JSON.stringify(tu.input ?? {}),
+                },
+              }
+
+              // Preserve existing extra_content if present
+              if (tu.extra_content) {
+                toolCall.extra_content = { ...tu.extra_content }
+              }
+
+              // Handle Gemini thought_signature
+              if (isGeminiMode()) {
+                // If the model provided a signature in the tool_use block itself (e.g. from a previous Turn/Step)
+                // Use thinkingBlock.signature for ALL tool calls in the same assistant turn if available.
+                // The API requires the same signature on every replayed function call part in a parallel set.
+                const signature = tu.signature ?? (thinkingBlock as any)?.signature
+
+                // Merge into existing google-specific metadata if present
+                const existingGoogle = (toolCall.extra_content?.google as Record<string, unknown>) ?? {}
+
+                toolCall.extra_content = {
+                  ...toolCall.extra_content,
+                  google: {
+                    ...existingGoogle,
+                    thought_signature: signature ?? "skip_thought_signature_validator"
+                  }
+                }
+              }
+
+              return toolCall
+            },
           )
         }
 
@@ -397,7 +450,7 @@ function normalizeSchemaForOpenAI(
 function convertTools(
   tools: Array<{ name: string; description?: string; input_schema?: Record<string, unknown> }>,
 ): OpenAITool[] {
-  const isGemini = isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
+  const isGemini = isGeminiMode()
 
   return tools
     .filter(t => t.name !== 'ToolSearchTool') // Not relevant for OpenAI
@@ -439,6 +492,7 @@ interface OpenAIStreamChunk {
     delta: {
       role?: string
       content?: string | null
+      reasoning_content?: string | null
       tool_calls?: Array<{
         index: number
         id?: string
@@ -476,6 +530,30 @@ function convertChunkUsage(
   }
 }
 
+const JSON_REPAIR_SUFFIXES = [
+  '}', '"}', ']}', '"]}', '}}', '"}}', ']}}', '"]}}', '"]}]}', '}]}'
+]
+
+function repairPossiblyTruncatedObjectJson(raw: string): string | null {
+  try {
+    const parsed = JSON.parse(raw)
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? raw
+      : null
+  } catch {
+    for (const combo of JSON_REPAIR_SUFFIXES) {
+      try {
+        const repaired = raw + combo
+        const parsed = JSON.parse(repaired)
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+          return repaired
+        }
+      } catch {}
+    }
+    return null
+  }
+}
+
 /**
  * Async generator that transforms an OpenAI SSE stream into
  * Anthropic-format BetaRawMessageStreamEvent objects.
@@ -486,8 +564,19 @@ async function* openaiStreamToAnthropic(
 ): AsyncGenerator<AnthropicStreamEvent> {
   const messageId = makeMessageId()
   let contentBlockIndex = 0
-  const activeToolCalls = new Map<number, { id: string; name: string; index: number; jsonBuffer: string }>()
+  const activeToolCalls = new Map<
+    number,
+    {
+      id: string
+      name: string
+      index: number
+      jsonBuffer: string
+      normalizeAtStop: boolean
+    }
+  >()
   let hasEmittedContentStart = false
+  let hasEmittedThinkingStart = false
+  let hasClosedThinking = false
   let lastStopReason: 'tool_use' | 'max_tokens' | 'end_turn' | null = null
   let hasEmittedFinalUsage = false
   let hasProcessedFinishReason = false
@@ -544,9 +633,34 @@ async function* openaiStreamToAnthropic(
       for (const choice of chunk.choices ?? []) {
         const delta = choice.delta
 
+        // Reasoning models (e.g. GLM-5, DeepSeek) may stream chain-of-thought
+        // in `reasoning_content` before the actual reply appears in `content`.
+        // Emit reasoning as a thinking block and content as a text block.
+        if (delta.reasoning_content != null && delta.reasoning_content !== '') {
+          if (!hasEmittedThinkingStart) {
+            yield {
+              type: 'content_block_start',
+              index: contentBlockIndex,
+              content_block: { type: 'thinking', thinking: '' },
+            }
+            hasEmittedThinkingStart = true
+          }
+          yield {
+            type: 'content_block_delta',
+            index: contentBlockIndex,
+            delta: { type: 'thinking_delta', thinking: delta.reasoning_content },
+          }
+        }
+
         // Text content — use != null to distinguish absent field from empty string,
         // some providers send "" as first delta to signal streaming start
-        if (delta.content != null) {
+        if (delta.content != null && delta.content !== '') {
+          // Close thinking block if transitioning from reasoning to content
+          if (hasEmittedThinkingStart && !hasClosedThinking) {
+            yield { type: 'content_block_stop', index: contentBlockIndex }
+            contentBlockIndex++
+            hasClosedThinking = true
+          }
           if (!hasEmittedContentStart) {
             yield {
               type: 'content_block_start',
@@ -566,7 +680,12 @@ async function* openaiStreamToAnthropic(
         if (delta.tool_calls) {
           for (const tc of delta.tool_calls) {
             if (tc.id && tc.function?.name) {
-              // New tool call starting
+              // New tool call starting — close any open thinking block first
+              if (hasEmittedThinkingStart && !hasClosedThinking) {
+                yield { type: 'content_block_stop', index: contentBlockIndex }
+                contentBlockIndex++
+                hasClosedThinking = true
+              }
               if (hasEmittedContentStart) {
                 yield {
                   type: 'content_block_stop',
@@ -577,11 +696,14 @@ async function* openaiStreamToAnthropic(
               }
 
               const toolBlockIndex = contentBlockIndex
+              const initialArguments = tc.function.arguments ?? ''
+              const normalizeAtStop = hasToolFieldMapping(tc.function.name)
               activeToolCalls.set(tc.index, {
                 id: tc.id,
                 name: tc.function.name,
                 index: toolBlockIndex,
-                jsonBuffer: tc.function.arguments ?? '',
+                jsonBuffer: initialArguments,
+                normalizeAtStop,
               })
 
               yield {
@@ -593,12 +715,19 @@ async function* openaiStreamToAnthropic(
                   name: tc.function.name,
                   input: {},
                   ...(tc.extra_content ? { extra_content: tc.extra_content } : {}),
+                  // Extract Gemini signature from extra_content
+                  ...((tc.extra_content?.google as any)?.thought_signature
+                    ? {
+                        signature: (tc.extra_content.google as any)
+                          .thought_signature,
+                      }
+                    : {}),
                 },
               }
               contentBlockIndex++
 
               // Emit any initial arguments
-              if (tc.function.arguments) {
+              if (tc.function.arguments && !normalizeAtStop) {
                 yield {
                   type: 'content_block_delta',
                   index: toolBlockIndex,
@@ -615,6 +744,11 @@ async function* openaiStreamToAnthropic(
                 if (tc.function.arguments) {
                   active.jsonBuffer += tc.function.arguments
                 }
+
+                if (active.normalizeAtStop) {
+                  continue
+                }
+
                 yield {
                   type: 'content_block_delta',
                   index: active.index,
@@ -633,6 +767,12 @@ async function* openaiStreamToAnthropic(
         if (choice.finish_reason && !hasProcessedFinishReason) {
           hasProcessedFinishReason = true
 
+          // Close any open thinking block that wasn't closed by content transition
+          if (hasEmittedThinkingStart && !hasClosedThinking) {
+            yield { type: 'content_block_stop', index: contentBlockIndex }
+            contentBlockIndex++
+            hasClosedThinking = true
+          }
           // Close any open content blocks
           if (hasEmittedContentStart) {
             yield {
@@ -642,16 +782,44 @@ async function* openaiStreamToAnthropic(
           }
           // Close active tool calls
           for (const [, tc] of activeToolCalls) {
+            if (tc.normalizeAtStop) {
+              let partialJson: string
+              if (choice.finish_reason === 'length') {
+                // Truncated by max tokens — preserve raw buffer to avoid
+                // turning an incomplete tool call into an executable command
+                partialJson = tc.jsonBuffer
+              } else {
+                const repairedStructuredJson = repairPossiblyTruncatedObjectJson(
+                  tc.jsonBuffer,
+                )
+                if (repairedStructuredJson) {
+                  partialJson = repairedStructuredJson
+                } else {
+                  partialJson = JSON.stringify(
+                    normalizeToolArguments(tc.name, tc.jsonBuffer),
+                  )
+                }
+              }
+
+              yield {
+                type: 'content_block_delta',
+                index: tc.index,
+                delta: {
+                  type: 'input_json_delta',
+                  partial_json: partialJson,
+                },
+              }
+              yield { type: 'content_block_stop', index: tc.index }
+              continue
+            }
+
             let suffixToAdd = ''
             if (tc.jsonBuffer) {
               try {
                 JSON.parse(tc.jsonBuffer)
               } catch {
                 const str = tc.jsonBuffer.trimEnd()
-                const combinations = [
-                  '}', '"}', ']}', '"]}', '}}', '"}}', ']}}', '"]}}', '"]}]}', '}]}'
-                ]
-                for (const combo of combinations) {
+                for (const combo of JSON_REPAIR_SUFFIXES) {
                   try {
                     JSON.parse(str + combo)
                     suffixToAdd = combo
@@ -930,7 +1098,7 @@ class OpenAIShimMessages {
       ...(options?.headers ?? {}),
     }
 
-    const isGemini = isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
+    const isGemini = isGeminiMode()
     const apiKey =
       this.providerOverride?.apiKey ?? process.env.OPENAI_API_KEY ?? ''
     // Detect Azure endpoints by hostname (not raw URL) to prevent bypass via
@@ -1043,6 +1211,7 @@ class OpenAIShimMessages {
             | string
             | null
             | Array<{ type?: string; text?: string }>
+          reasoning_content?: string | null
           tool_calls?: Array<{
             id: string
             function: { name: string; arguments: string }
@@ -1064,7 +1233,17 @@ class OpenAIShimMessages {
     const choice = data.choices?.[0]
     const content: Array<Record<string, unknown>> = []
 
-    const rawContent = choice?.message?.content
+    // Some reasoning models (e.g. GLM-5) put their reply in reasoning_content
+    // while content stays null — emit reasoning as a thinking block, then
+    // fall back to it for visible text if content is empty.
+    const reasoningText = choice?.message?.reasoning_content
+    if (typeof reasoningText === 'string' && reasoningText) {
+      content.push({ type: 'thinking', thinking: reasoningText })
+    }
+    const rawContent =
+      choice?.message?.content !== '' && choice?.message?.content != null
+        ? choice?.message?.content
+        : choice?.message?.reasoning_content
     if (typeof rawContent === 'string' && rawContent) {
       content.push({ type: 'text', text: rawContent })
     } else if (Array.isArray(rawContent) && rawContent.length > 0) {
@@ -1087,18 +1266,20 @@ class OpenAIShimMessages {
 
     if (choice?.message?.tool_calls) {
       for (const tc of choice.message.tool_calls) {
-        let input: unknown
-        try {
-          input = JSON.parse(tc.function.arguments)
-        } catch {
-          input = { raw: tc.function.arguments }
-        }
+        const input = normalizeToolArguments(
+          tc.function.name,
+          tc.function.arguments,
+        )
         content.push({
           type: 'tool_use',
           id: tc.id,
           name: tc.function.name,
           input,
           ...(tc.extra_content ? { extra_content: tc.extra_content } : {}),
+          // Extract Gemini signature from extra_content
+          ...((tc.extra_content?.google as any)?.thought_signature
+            ? { signature: (tc.extra_content.google as any).thought_signature }
+            : {}),
         })
       }
     }

src/services/api/toolArgumentNormalization.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, test } from 'bun:test'
+import { normalizeToolArguments } from './toolArgumentNormalization'
+
+describe('normalizeToolArguments', () => {
+  describe('Bash tool', () => {
+    test('wraps plain string into { command }', () => {
+      expect(normalizeToolArguments('Bash', 'pwd')).toEqual({ command: 'pwd' })
+    })
+
+    test('wraps multi-word command', () => {
+      expect(normalizeToolArguments('Bash', 'ls -la /tmp')).toEqual({
+        command: 'ls -la /tmp',
+      })
+    })
+
+    test('passes through structured JSON object', () => {
+      expect(
+        normalizeToolArguments('Bash', '{"command":"echo hi"}'),
+      ).toEqual({ command: 'echo hi' })
+    })
+
+    test('returns empty object for blank string', () => {
+      expect(normalizeToolArguments('Bash', '')).toEqual({})
+      expect(normalizeToolArguments('Bash', '   ')).toEqual({})
+    })
+
+    test('returns parsed blank for JSON-encoded blank string', () => {
+      expect(normalizeToolArguments('Bash', '""')).toEqual('')
+      expect(normalizeToolArguments('Bash', '"  "')).toEqual('  ')
+    })
+
+    test('returns empty object for malformed structured object literal', () => {
+      expect(normalizeToolArguments('Bash', '{ "command": "pwd"')).toEqual({})
+    })
+
+    test.each([
+      ['{command:"pwd"}'],
+      ["{'command':'pwd'}"],
+      ['{command: pwd}'],
+    ])(
+      'returns empty object for malformed object-shaped string %s (does not wrap into command)',
+      (input) => {
+        expect(normalizeToolArguments('Bash', input)).toEqual({})
+      },
+    )
+
+    test.each([
+      ['false', false],
+      ['null', null],
+      ['[]', [] as unknown[]],
+      ['0', 0],
+      ['true', true],
+      ['123', 123],
+    ])(
+      'preserves JSON literal %s as-is (does not wrap into command)',
+      (input, expected) => {
+        expect(normalizeToolArguments('Bash', input)).toEqual(expected)
+      },
+    )
+
+    test('wraps JSON-encoded string into { command }', () => {
+      expect(normalizeToolArguments('Bash', '"pwd"')).toEqual({
+        command: 'pwd',
+      })
+    })
+  })
+
+  describe('undefined arguments', () => {
+    test('returns empty object for undefined', () => {
+      expect(normalizeToolArguments('Bash', undefined)).toEqual({})
+      expect(normalizeToolArguments('UnknownTool', undefined)).toEqual({})
+    })
+  })
+
+  describe('Read tool', () => {
+    test('wraps plain string into { file_path }', () => {
+      expect(normalizeToolArguments('Read', '/home/user/file.txt')).toEqual({
+        file_path: '/home/user/file.txt',
+      })
+    })
+
+    test('wraps JSON-encoded string into { file_path }', () => {
+      expect(normalizeToolArguments('Read', '"/home/user/file.txt"')).toEqual({
+        file_path: '/home/user/file.txt',
+      })
+    })
+
+    test('passes through structured JSON object', () => {
+      expect(
+        normalizeToolArguments('Read', '{"file_path":"/tmp/f.txt","limit":10}'),
+      ).toEqual({ file_path: '/tmp/f.txt', limit: 10 })
+    })
+  })
+
+  describe('Write tool', () => {
+    test('wraps plain string into { file_path }', () => {
+      expect(normalizeToolArguments('Write', '/tmp/out.txt')).toEqual({
+        file_path: '/tmp/out.txt',
+      })
+    })
+
+    test('passes through structured JSON object', () => {
+      expect(
+        normalizeToolArguments(
+          'Write',
+          '{"file_path":"/tmp/out.txt","content":"hello"}',
+        ),
+      ).toEqual({ file_path: '/tmp/out.txt', content: 'hello' })
+    })
+  })
+
+  describe('Edit tool', () => {
+    test('wraps plain string into { file_path }', () => {
+      expect(normalizeToolArguments('Edit', '/tmp/edit.ts')).toEqual({
+        file_path: '/tmp/edit.ts',
+      })
+    })
+
+    test('passes through structured JSON object', () => {
+      expect(
+        normalizeToolArguments(
+          'Edit',
+          '{"file_path":"/tmp/f.ts","old_string":"a","new_string":"b"}',
+        ),
+      ).toEqual({ file_path: '/tmp/f.ts', old_string: 'a', new_string: 'b' })
+    })
+  })
+
+  describe('Glob tool', () => {
+    test('wraps plain string into { pattern }', () => {
+      expect(normalizeToolArguments('Glob', '**/*.ts')).toEqual({
+        pattern: '**/*.ts',
+      })
+    })
+
+    test('passes through structured JSON object', () => {
+      expect(
+        normalizeToolArguments('Glob', '{"pattern":"*.js","path":"/src"}'),
+      ).toEqual({ pattern: '*.js', path: '/src' })
+    })
+  })
+
+  describe('Grep tool', () => {
+    test('wraps plain string into { pattern }', () => {
+      expect(normalizeToolArguments('Grep', 'TODO')).toEqual({
+        pattern: 'TODO',
+      })
+    })
+
+    test('passes through structured JSON object', () => {
+      expect(
+        normalizeToolArguments('Grep', '{"pattern":"fixme","path":"/src"}'),
+      ).toEqual({ pattern: 'fixme', path: '/src' })
+    })
+  })
+
+  describe('unknown tools', () => {
+    test('returns empty object for plain string (no known field mapping)', () => {
+      expect(normalizeToolArguments('UnknownTool', 'some value')).toEqual({})
+    })
+
+    test('passes through structured JSON object', () => {
+      expect(
+        normalizeToolArguments('UnknownTool', '{"key":"val"}'),
+      ).toEqual({ key: 'val' })
+    })
+
+    test('preserves JSON literals as-is', () => {
+      expect(normalizeToolArguments('UnknownTool', 'false')).toEqual(false)
+      expect(normalizeToolArguments('UnknownTool', 'null')).toEqual(null)
+      expect(normalizeToolArguments('UnknownTool', '[]')).toEqual([])
+    })
+
+    test('returns parsed string for JSON-encoded string on unknown tools', () => {
+      expect(normalizeToolArguments('UnknownTool', '"hello"')).toEqual(
+        'hello',
+      )
+    })
+  })
+})

src/services/api/toolArgumentNormalization.ts

@@ -0,0 +1,69 @@
+const STRING_ARGUMENT_TOOL_FIELDS: Record<string, string> = {
+  Bash: 'command',
+  Read: 'file_path',
+  Write: 'file_path',
+  Edit: 'file_path',
+  Glob: 'pattern',
+  Grep: 'pattern',
+}
+
+function isBlankString(value: string): boolean {
+  return value.trim().length === 0
+}
+
+function isLikelyStructuredObjectLiteral(value: string): boolean {
+  // Match object-like patterns with key-value syntax:
+  // {"key":, {key:, {'key':, { "key" :, etc.
+  // But NOT bash compound commands like { pwd; } or { echo hi; }
+  return /^\s*\{\s*['"]?\w+['"]?\s*:/.test(value)
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function getPlainStringToolArgumentField(toolName: string): string | null {
+  return STRING_ARGUMENT_TOOL_FIELDS[toolName] ?? null
+}
+
+export function hasToolFieldMapping(toolName: string): boolean {
+  return toolName in STRING_ARGUMENT_TOOL_FIELDS
+}
+
+function wrapPlainStringToolArguments(
+  toolName: string,
+  value: string,
+): Record<string, string> | null {
+  const field = getPlainStringToolArgumentField(toolName)
+  if (!field) return null
+  return { [field]: value }
+}
+
+export function normalizeToolArguments(
+  toolName: string,
+  rawArguments: string | undefined,
+): unknown {
+  if (rawArguments === undefined) return {}
+
+  try {
+    const parsed = JSON.parse(rawArguments)
+    if (isRecord(parsed)) {
+      return parsed
+    }
+    // Parsed as a non-object JSON value (string, number, boolean, null, array)
+    if (typeof parsed === 'string' && !isBlankString(parsed)) {
+      return wrapPlainStringToolArguments(toolName, parsed) ?? parsed
+    }
+    // For blank strings, booleans, null, arrays — pass through as-is
+    // and let Zod schema validation produce a meaningful error
+    return parsed
+  } catch {
+    // rawArguments is not valid JSON — treat as a plain string
+    if (isBlankString(rawArguments) || isLikelyStructuredObjectLiteral(rawArguments)) {
+      // Blank or looks like a malformed object literal — don't wrap into
+      // a tool field to avoid turning garbage into executable input
+      return {}
+    }
+    return wrapPlainStringToolArguments(toolName, rawArguments) ?? {}
+  }
+}

src/services/compact/microCompact.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from 'bun:test'
+
+import type { Message } from '../../types/message.js'
+import { createAssistantMessage, createUserMessage } from '../../utils/messages.js'
+
+// We test the exported collectCompactableToolIds behavior indirectly via
+// the public microcompactMessages + time-based path. But first we need to
+// verify the core predicate: MCP tools (prefixed 'mcp__') should be
+// compactable alongside the built-in tool set.
+
+// Import internals we can test
+import { evaluateTimeBasedTrigger } from './microCompact.js'
+
+/**
+ * Helper: build a minimal assistant message with a tool_use block.
+ */
+function assistantWithToolUse(toolName: string, toolId: string): Message {
+  return createAssistantMessage({
+    content: [
+      {
+        type: 'tool_use' as const,
+        id: toolId,
+        name: toolName,
+        input: {},
+      },
+    ],
+  })
+}
+
+/**
+ * Helper: build a user message with a tool_result block.
+ */
+function userWithToolResult(toolId: string, output: string): Message {
+  return createUserMessage({
+    content: [
+      {
+        type: 'tool_result' as const,
+        tool_use_id: toolId,
+        content: output,
+      },
+    ],
+  })
+}
+
+describe('microCompact MCP tool compaction', () => {
+  // We can't easily unit-test the private isCompactableTool directly,
+  // but we can test the full time-based microcompact path which exercises
+  // collectCompactableToolIds → isCompactableTool under the hood.
+  // The time-based path is the simplest to trigger: it content-clears
+  // old tool results when the gap since last assistant message exceeds
+  // the threshold.
+
+  // However, evaluateTimeBasedTrigger depends on config (GrowthBook).
+  // So instead, let's test the observable behavior by importing the
+  // microcompactMessages function and checking that MCP tool_use blocks
+  // are collected.
+
+  // Since collectCompactableToolIds is not exported, we test the predicate
+  // behavior by verifying that the module loads without error and that
+  // built-in and MCP tools are treated consistently.
+
+  test('module exports load correctly', async () => {
+    const mod = await import('./microCompact.js')
+    expect(mod.microcompactMessages).toBeFunction()
+    expect(mod.estimateMessageTokens).toBeFunction()
+    expect(mod.evaluateTimeBasedTrigger).toBeFunction()
+  })
+
+  test('estimateMessageTokens counts MCP tool_use blocks', async () => {
+    const { estimateMessageTokens } = await import('./microCompact.js')
+
+    const builtinMessages: Message[] = [
+      assistantWithToolUse('Read', 'tool-builtin-1'),
+      userWithToolResult('tool-builtin-1', 'file contents here'),
+    ]
+
+    const mcpMessages: Message[] = [
+      assistantWithToolUse('mcp__github__get_file_contents', 'tool-mcp-1'),
+      userWithToolResult('tool-mcp-1', 'file contents here'),
+    ]
+
+    const builtinTokens = estimateMessageTokens(builtinMessages)
+    const mcpTokens = estimateMessageTokens(mcpMessages)
+
+    // Both should produce non-zero estimates
+    expect(builtinTokens).toBeGreaterThan(0)
+    expect(mcpTokens).toBeGreaterThan(0)
+
+    // The tool_result content is identical, so token estimates should be
+    // similar (tool_use name differs slightly, so not exactly equal)
+    expect(Math.abs(builtinTokens - mcpTokens)).toBeLessThan(50)
+  })
+
+  test('microcompactMessages processes MCP tools without error', async () => {
+    const { microcompactMessages } = await import('./microCompact.js')
+
+    const messages: Message[] = [
+      assistantWithToolUse('mcp__slack__send_message', 'tool-mcp-2'),
+      userWithToolResult('tool-mcp-2', 'Message sent successfully'),
+      assistantWithToolUse('mcp__github__create_pull_request', 'tool-mcp-3'),
+      userWithToolResult('tool-mcp-3', JSON.stringify({ number: 42, url: 'https://github.com/org/repo/pull/42' })),
+    ]
+
+    // Should not throw — MCP tools should be handled gracefully
+    const result = await microcompactMessages(messages)
+    expect(result).toBeDefined()
+    expect(result.messages).toBeDefined()
+    expect(result.messages.length).toBe(messages.length)
+  })
+
+  test('microcompactMessages processes mixed built-in and MCP tools', async () => {
+    const { microcompactMessages } = await import('./microCompact.js')
+
+    const messages: Message[] = [
+      assistantWithToolUse('Read', 'tool-read-1'),
+      userWithToolResult('tool-read-1', 'some file content'),
+      assistantWithToolUse('mcp__playwright__screenshot', 'tool-mcp-4'),
+      userWithToolResult('tool-mcp-4', 'base64-encoded-screenshot-data'.repeat(100)),
+      assistantWithToolUse('Bash', 'tool-bash-1'),
+      userWithToolResult('tool-bash-1', 'command output'),
+    ]
+
+    const result = await microcompactMessages(messages)
+    expect(result).toBeDefined()
+    expect(result.messages.length).toBe(messages.length)
+  })
+})

src/services/compact/microCompact.ts

@@ -37,7 +37,7 @@ export const TIME_BASED_MC_CLEARED_MESSAGE = '[Old tool result content cleared]'
 
 const IMAGE_MAX_TOKEN_SIZE = 2000
 
-// Only compact these tools
+// Only compact these built-in tools (MCP tools are also compactable via prefix match)
 const COMPACTABLE_TOOLS = new Set<string>([
   FILE_READ_TOOL_NAME,
   ...SHELL_TOOL_NAMES,
@@ -49,7 +49,13 @@ const COMPACTABLE_TOOLS = new Set<string>([
   FILE_WRITE_TOOL_NAME,
 ])
 
-// --- Cached microcompact state (internal-only, gated by feature('CACHED_MICROCOMPACT')) ---
+const MCP_TOOL_PREFIX = 'mcp__'
+
+function isCompactableTool(name: string): boolean {
+  return COMPACTABLE_TOOLS.has(name) || name.startsWith(MCP_TOOL_PREFIX)
+}
+
+// --- Cached microcompact state (gated by feature('CACHED_MICROCOMPACT')) ---
 
 // Lazy-initialized cached MC module and state to avoid importing in external builds.
 // The imports and state live inside feature() checks for dead code elimination.
@@ -231,7 +237,7 @@ function collectCompactableToolIds(messages: Message[]): string[] {
       Array.isArray(message.message.content)
     ) {
       for (const block of message.message.content) {
-        if (block.type === 'tool_use' && COMPACTABLE_TOOLS.has(block.name)) {
+        if (block.type === 'tool_use' && isCompactableTool(block.name)) {
           ids.push(block.id)
         }
       }

src/services/github/deviceFlow.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, mock, test } from 'bun:test'
 
 import {
+  DEFAULT_GITHUB_DEVICE_SCOPE,
   GitHubDeviceFlowError,
   pollAccessToken,
   requestDeviceCode,
@@ -48,6 +49,81 @@ describe('requestDeviceCode', () => {
       requestDeviceCode({ clientId: 'x', fetchImpl: globalThis.fetch }),
     ).rejects.toThrow(GitHubDeviceFlowError)
   })
+
+  test('uses OAuth-safe default scope', async () => {
+    let capturedScope = ''
+    globalThis.fetch = mock((_url: RequestInfo | URL, init?: RequestInit) => {
+      const body = init?.body
+      if (body instanceof URLSearchParams) {
+        capturedScope = body.get('scope') ?? ''
+      } else {
+        capturedScope = new URLSearchParams(String(body ?? '')).get('scope') ?? ''
+      }
+
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            device_code: 'abc',
+            user_code: 'ABCD-1234',
+            verification_uri: 'https://github.com/login/device',
+          }),
+          { status: 200 },
+        ),
+      )
+    })
+
+    await requestDeviceCode({ clientId: 'test-client', fetchImpl: globalThis.fetch })
+    expect(capturedScope).toBe(DEFAULT_GITHUB_DEVICE_SCOPE)
+    expect(capturedScope).toBe('read:user')
+  })
+
+  test('retries with OAuth-safe scope on invalid_scope', async () => {
+    const scopesSeen: string[] = []
+    let callCount = 0
+
+    globalThis.fetch = mock((_url: RequestInfo | URL, init?: RequestInit) => {
+      const body = init?.body
+      const scope =
+        body instanceof URLSearchParams
+          ? body.get('scope') ?? ''
+          : new URLSearchParams(String(body ?? '')).get('scope') ?? ''
+      scopesSeen.push(scope)
+      callCount++
+
+      if (callCount === 1) {
+        return Promise.resolve(
+          new Response(
+            JSON.stringify({
+              error: 'invalid_scope',
+              error_description: 'invalid models scope',
+            }),
+            { status: 400 },
+          ),
+        )
+      }
+
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            device_code: 'abc',
+            user_code: 'ABCD-1234',
+            verification_uri: 'https://github.com/login/device',
+          }),
+          { status: 200 },
+        ),
+      )
+    })
+
+    const result = await requestDeviceCode({
+      clientId: 'test-client',
+      scope: 'read:user,models:read',
+      fetchImpl: globalThis.fetch,
+    })
+
+    expect(result.device_code).toBe('abc')
+    expect(callCount).toBe(2)
+    expect(scopesSeen).toEqual(['read:user,models:read', 'read:user'])
+  })
 })
 
 describe('pollAccessToken', () => {

src/services/github/deviceFlow.ts

@@ -10,8 +10,10 @@ export const GITHUB_DEVICE_CODE_URL = 'https://github.com/login/device/code'
 export const GITHUB_DEVICE_ACCESS_TOKEN_URL =
   'https://github.com/login/oauth/access_token'
 
-/** Match runtime devsper github_oauth DEFAULT_SCOPE */
-export const DEFAULT_GITHUB_DEVICE_SCOPE = 'read:user,models:read'
+// OAuth app device flow does not accept the GitHub Models permission token
+// scope (models:read). Use an OAuth-safe default.
+const OAUTH_SAFE_GITHUB_DEVICE_SCOPE = 'read:user'
+export const DEFAULT_GITHUB_DEVICE_SCOPE = OAUTH_SAFE_GITHUB_DEVICE_SCOPE
 
 export class GitHubDeviceFlowError extends Error {
   constructor(message: string) {
@@ -51,38 +53,61 @@ export async function requestDeviceCode(options?: {
     )
   }
   const fetchFn = options?.fetchImpl ?? fetch
-  const res = await fetchFn(GITHUB_DEVICE_CODE_URL, {
-    method: 'POST',
-    headers: { Accept: 'application/json' },
-    body: new URLSearchParams({
-      client_id: clientId,
-      scope: options?.scope ?? DEFAULT_GITHUB_DEVICE_SCOPE,
-    }),
-  })
-  if (!res.ok) {
-    const text = await res.text().catch(() => '')
-    throw new GitHubDeviceFlowError(
-      `Device code request failed: ${res.status} ${text}`,
-    )
-  }
-  const data = (await res.json()) as Record<string, unknown>
-  const device_code = data.device_code
-  const user_code = data.user_code
-  const verification_uri = data.verification_uri
-  if (
-    typeof device_code !== 'string' ||
-    typeof user_code !== 'string' ||
-    typeof verification_uri !== 'string'
-  ) {
-    throw new GitHubDeviceFlowError('Malformed device code response from GitHub')
-  }
-  return {
-    device_code,
-    user_code,
-    verification_uri,
-    expires_in: typeof data.expires_in === 'number' ? data.expires_in : 900,
-    interval: typeof data.interval === 'number' ? data.interval : 5,
+  const requestedScope =
+    options?.scope?.trim() || DEFAULT_GITHUB_DEVICE_SCOPE
+  const scopesToTry =
+    requestedScope === OAUTH_SAFE_GITHUB_DEVICE_SCOPE
+      ? [requestedScope]
+      : [requestedScope, OAUTH_SAFE_GITHUB_DEVICE_SCOPE]
+
+  let lastError = 'Device code request failed.'
+
+  for (const scope of scopesToTry) {
+    const res = await fetchFn(GITHUB_DEVICE_CODE_URL, {
+      method: 'POST',
+      headers: { Accept: 'application/json' },
+      body: new URLSearchParams({
+        client_id: clientId,
+        scope,
+      }),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      lastError = `Device code request failed: ${res.status} ${text}`
+      const isInvalidScope = /invalid_scope/i.test(text)
+      const canRetryWithFallback =
+        scope !== OAUTH_SAFE_GITHUB_DEVICE_SCOPE && isInvalidScope
+      if (canRetryWithFallback) {
+        continue
+      }
+      throw new GitHubDeviceFlowError(lastError)
+    }
+
+    const data = (await res.json()) as Record<string, unknown>
+    const device_code = data.device_code
+    const user_code = data.user_code
+    const verification_uri = data.verification_uri
+    if (
+      typeof device_code !== 'string' ||
+      typeof user_code !== 'string' ||
+      typeof verification_uri !== 'string'
+    ) {
+      throw new GitHubDeviceFlowError(
+        'Malformed device code response from GitHub',
+      )
+    }
+
+    return {
+      device_code,
+      user_code,
+      verification_uri,
+      expires_in: typeof data.expires_in === 'number' ? data.expires_in : 900,
+      interval: typeof data.interval === 'number' ? data.interval : 5,
+    }
   }
+
+  throw new GitHubDeviceFlowError(lastError)
 }
 
 export type PollOptions = {

src/services/tools/toolExecution.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from 'bun:test'
+
+import { SkillTool } from '../../tools/SkillTool/SkillTool.js'
+import {
+  getSchemaValidationErrorOverride,
+  getSchemaValidationToolUseResult,
+} from './toolExecution.js'
+
+describe('getSchemaValidationErrorOverride', () => {
+  test('returns actionable missing-skill error for SkillTool', () => {
+    expect(getSchemaValidationErrorOverride(SkillTool, {})).toBe(
+      'Missing skill name. Pass the slash command name as the skill parameter (e.g., skill: "commit" for /commit, skill: "review-pr" for /review-pr).',
+    )
+  })
+
+  test('does not override unrelated tool schema failures', () => {
+    expect(getSchemaValidationErrorOverride({ name: 'Read' } as never, {})).toBe(
+      null,
+    )
+  })
+
+  test('does not override SkillTool when skill is present', () => {
+    expect(
+      getSchemaValidationErrorOverride(SkillTool, { skill: 'commit' }),
+    ).toBe(null)
+  })
+
+  test('uses the actionable override for structured toolUseResult too', () => {
+    expect(getSchemaValidationToolUseResult(SkillTool, {} as never)).toBe(
+      'InputValidationError: Missing skill name. Pass the slash command name as the skill parameter (e.g., skill: "commit" for /commit, skill: "review-pr" for /review-pr).',
+    )
+  })
+})

src/services/tools/toolExecution.ts

@@ -43,6 +43,7 @@ import { FILE_READ_TOOL_NAME } from '../../tools/FileReadTool/prompt.js'
 import { FILE_WRITE_TOOL_NAME } from '../../tools/FileWriteTool/prompt.js'
 import { NOTEBOOK_EDIT_TOOL_NAME } from '../../tools/NotebookEditTool/constants.js'
 import { POWERSHELL_TOOL_NAME } from '../../tools/PowerShellTool/toolName.js'
+import { SKILL_TOOL_NAME } from '../../tools/SkillTool/constants.js'
 import { parseGitCommitId } from '../../tools/shared/gitOperationTracking.js'
 import {
   isDeferredTool,
@@ -596,6 +597,31 @@ export function buildSchemaNotSentHint(
   )
 }
 
+export function getSchemaValidationErrorOverride(
+  tool: Tool,
+  input: unknown,
+): string | null {
+  if (tool.name !== SKILL_TOOL_NAME || !input || typeof input !== 'object') {
+    return null
+  }
+
+  const skill = (input as { skill?: unknown }).skill
+  if (skill === undefined || skill === null) {
+    return 'Missing skill name. Pass the slash command name as the skill parameter (e.g., skill: "commit" for /commit, skill: "review-pr" for /review-pr).'
+  }
+
+  return null
+}
+
+export function getSchemaValidationToolUseResult(
+  tool: Tool,
+  input: unknown,
+  fallbackMessage?: string,
+): string {
+  const override = getSchemaValidationErrorOverride(tool, input)
+  return `InputValidationError: ${override ?? fallbackMessage ?? ''}`
+}
+
 async function checkPermissionsAndCallTool(
   tool: Tool,
   toolUseID: string,
@@ -614,7 +640,9 @@ async function checkPermissionsAndCallTool(
   // Validate input types with zod (surprisingly, the model is not great at generating valid input)
   const parsedInput = tool.inputSchema.safeParse(input)
   if (!parsedInput.success) {
-    let errorContent = formatZodValidationError(tool.name, parsedInput.error)
+    const fallbackErrorContent = formatZodValidationError(tool.name, parsedInput.error)
+    let errorContent =
+      getSchemaValidationErrorOverride(tool, input) ?? fallbackErrorContent
 
     const schemaHint = buildSchemaNotSentHint(
       tool,
@@ -672,7 +700,11 @@ async function checkPermissionsAndCallTool(
               tool_use_id: toolUseID,
             },
           ],
-          toolUseResult: `InputValidationError: ${parsedInput.error.message}`,
+          toolUseResult: getSchemaValidationToolUseResult(
+            tool,
+            input,
+            parsedInput.error.message,
+          ),
           sourceToolAssistantUUID: assistantMessage.uuid,
         }),
       },

src/state/onChangeAppState.ts

@@ -9,6 +9,7 @@ import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
 import { toError } from '../utils/errors.js'
 import { logError } from '../utils/log.js'
 import { applyConfigEnvironmentVariables } from '../utils/managedEnv.js'
+import { persistActiveProviderProfileModel } from '../utils/providerProfiles.js'
 import {
   permissionModeFromString,
   toExternalPermissionMode,
@@ -110,6 +111,12 @@ export function onChangeAppState({
     // Save to settings
     updateSettingsForSource('userSettings', { model: newState.mainLoopModel })
     setMainLoopModelOverride(newState.mainLoopModel)
+
+    // Keep active provider profiles in sync with /model choices so restarts
+    // keep using the last selected model instead of the profile's old default.
+    if (process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED === '1') {
+      persistActiveProviderProfileModel(newState.mainLoopModel)
+    }
   }
 
   // expandedView → persist as showExpandedTodos + showSpinnerTree for backwards compat

src/tools/AgentTool/prompt.ts

@@ -156,34 +156,24 @@ ${AGENT_TOOL_NAME}({
   const currentExamples = `Example usage:
 
 <example_agent_descriptions>
-"test-runner": use this agent after you are done writing code to run tests
-"greeting-responder": use this agent to respond to user greetings with a friendly joke
+"claude-code-guide": use this agent when the user asks how Claude Code works or how to use its features
+"statusline-setup": use this agent to configure the user's Claude Code status line setting
 </example_agent_descriptions>
 
 <example>
-user: "Please write a function that checks if a number is prime"
-assistant: I'm going to use the ${FILE_WRITE_TOOL_NAME} tool to write the following code:
-<code>
-function isPrime(n) {
-  if (n <= 1) return false
-  for (let i = 2; i * i <= n; i++) {
-    if (n % i === 0) return false
-  }
-  return true
-}
-</code>
+user: "How do I configure Claude Code hooks?"
 <commentary>
-Since a significant piece of code was written and the task was completed, now use the test-runner agent to run the tests
+This is a Claude Code usage question, so use the claude-code-guide agent
 </commentary>
-assistant: Uses the ${AGENT_TOOL_NAME} tool to launch the test-runner agent
+assistant: Uses the ${AGENT_TOOL_NAME} tool to launch the claude-code-guide agent
 </example>
 
 <example>
-user: "Hello"
+user: "Set up my Claude Code status line"
 <commentary>
-Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+This matches the statusline-setup agent, so use it to configure the setting
 </commentary>
-assistant: "I'm going to use the ${AGENT_TOOL_NAME} tool to launch the greeting-responder agent"
+assistant: "I'm going to use the ${AGENT_TOOL_NAME} tool to launch the statusline-setup agent"
 </example>
 `
 

src/tools/SkillTool/SkillTool.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'bun:test'
+
+import { SkillTool } from './SkillTool.js'
+
+describe('SkillTool missing parameter handling', () => {
+  test('missing skill stays required at the schema level', async () => {
+    const parsed = SkillTool.inputSchema.safeParse({})
+
+    expect(parsed.success).toBe(false)
+  })
+
+  test('validateInput still returns an actionable error when called with missing skill', async () => {
+    const result = await SkillTool.validateInput?.({} as never, {
+      options: { tools: [] },
+      messages: [],
+    } as never)
+
+    expect(result).toEqual({
+      result: false,
+      message:
+        'Missing skill name. Pass the slash command name as the skill parameter (e.g., skill: "commit" for /commit, skill: "review-pr" for /review-pr).',
+      errorCode: 1,
+    })
+  })
+
+  test('valid skill input still parses and validates', async () => {
+    const parsed = SkillTool.inputSchema.safeParse({ skill: 'commit' })
+
+    expect(parsed.success).toBe(true)
+  })
+})

src/tools/SkillTool/SkillTool.ts

@@ -352,6 +352,16 @@ export const SkillTool: Tool<InputSchema, Output, Progress> = buildTool({
   toAutoClassifierInput: ({ skill }) => skill ?? '',
 
   async validateInput({ skill }, context): Promise<ValidationResult> {
+    if (!skill || typeof skill !== 'string') {
+      return {
+        result: false,
+        message:
+          'Missing skill name. Pass the slash command name as the skill parameter ' +
+          '(e.g., skill: "commit" for /commit, skill: "review-pr" for /review-pr).',
+        errorCode: 1,
+      }
+    }
+
     // Skills are just skill names, no arguments
     const trimmed = skill.trim()
     if (!trimmed) {
@@ -434,7 +444,7 @@ export const SkillTool: Tool<InputSchema, Output, Progress> = buildTool({
     context,
   ): Promise<PermissionDecision> {
     // Skills are just skill names, no arguments
-    const trimmed = skill.trim()
+    const trimmed = skill ?? ''
 
     // Remove leading slash if present (for compatibility)
     const commandName = trimmed.startsWith('/') ? trimmed.substring(1) : trimmed
@@ -592,7 +602,7 @@ export const SkillTool: Tool<InputSchema, Output, Progress> = buildTool({
     // - Skill is a prompt-based skill
 
     // Skills are just names, with optional arguments
-    const trimmed = skill.trim()
+    const trimmed = skill ?? ''
 
     // Remove leading slash if present (for compatibility)
     const commandName = trimmed.startsWith('/') ? trimmed.substring(1) : trimmed

src/utils/api.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from 'bun:test'
 import { z } from 'zod/v4'
 import { getEmptyToolPermissionContext, type Tool, type Tools } from '../Tool.js'
+import { SkillTool } from '../tools/SkillTool/SkillTool.js'
 import { toolToAPISchema } from './api.js'
 
 test('toolToAPISchema preserves provider-specific schema keywords in input_schema', async () => {
@@ -64,3 +65,16 @@ test('toolToAPISchema preserves provider-specific schema keywords in input_schem
     },
   })
 })
+
+test('toolToAPISchema keeps skill required for SkillTool', async () => {
+  const schema = await toolToAPISchema(SkillTool, {
+    getToolPermissionContext: async () => getEmptyToolPermissionContext(),
+    tools: [] as unknown as Tools,
+    agents: [],
+  })
+
+  expect((schema as { input_schema: unknown }).input_schema).toMatchObject({
+    type: 'object',
+    required: ['skill'],
+  })
+})

src/utils/context.test.ts

@@ -94,3 +94,22 @@ test('gpt-5.4 family keeps large max output overrides within provider limits', (
   expect(getMaxOutputTokensForModel('gpt-5.4-mini')).toBe(128_000)
   expect(getMaxOutputTokensForModel('gpt-5.4-nano')).toBe(128_000)
 })
+
+test('MiniMax-M2.7 uses explicit provider-specific context and output caps', () => {
+  process.env.CLAUDE_CODE_USE_OPENAI = '1'
+  delete process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS
+
+  expect(getContextWindowForModel('MiniMax-M2.7')).toBe(204_800)
+  expect(getModelMaxOutputTokens('MiniMax-M2.7')).toEqual({
+    default: 131_072,
+    upperLimit: 131_072,
+  })
+  expect(getMaxOutputTokensForModel('MiniMax-M2.7')).toBe(131_072)
+})
+
+test('unknown openai-compatible models still use the conservative fallback window', () => {
+  process.env.CLAUDE_CODE_USE_OPENAI = '1'
+  delete process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS
+
+  expect(getContextWindowForModel('some-unknown-3p-model')).toBe(8_000)
+})

src/utils/context.ts

@@ -72,16 +72,23 @@ export function getContextWindowForModel(
     return 1_000_000
   }
 
-  // OpenAI-compatible provider — use known context windows for the model
-  if (
+  // OpenAI-compatible provider — use known context windows for the model.
+  // Unknown models get a conservative 8k default so auto-compact triggers
+  // before hitting a hard context_window_exceeded error.
+  const isOpenAIProvider =
     isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI) ||
     isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI) ||
     isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
-  ) {
+  if (isOpenAIProvider) {
     const openaiWindow = getOpenAIContextWindow(model)
     if (openaiWindow !== undefined) {
       return openaiWindow
     }
+    console.error(
+      `[context] Warning: model "${model}" not in context window table — using conservative 8k default. ` +
+      'Add it to src/utils/model/openaiContextWindows.ts for accurate compaction.',
+    )
+    return 8_000
   }
 
   const cap = getModelCapability(model)

src/utils/conversationRecovery.hooks.test.ts

@@ -69,3 +69,93 @@ test('loadConversationForResume rejects oversized transcripts before resume hook
   )
   expect(hookSpy).not.toHaveBeenCalled()
 })
+
+test('deserializeMessagesWithInterruptDetection strips thinking blocks only for OpenAI-compatible providers', async () => {
+  const serializedMessages = [
+    user(id(10), 'hello'),
+    {
+      type: 'assistant',
+      uuid: id(11),
+      parentUuid: id(10),
+      timestamp: ts,
+      cwd: '/tmp',
+      sessionId,
+      version: 'test',
+      message: {
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: 'secret reasoning' },
+          { type: 'text', text: 'visible reply' },
+        ],
+      },
+    },
+    {
+      type: 'assistant',
+      uuid: id(12),
+      parentUuid: id(11),
+      timestamp: ts,
+      cwd: '/tmp',
+      sessionId,
+      version: 'test',
+      message: {
+        role: 'assistant',
+        content: [{ type: 'thinking', thinking: 'only hidden reasoning' }],
+      },
+    },
+    user(id(13), 'follow up'),
+  ]
+
+  mock.module('./model/providers.js', () => ({
+    getAPIProvider: () => 'openai',
+    isOpenAICompatibleProvider: (provider: string) =>
+      provider === 'openai' ||
+      provider === 'gemini' ||
+      provider === 'github' ||
+      provider === 'codex',
+  }))
+
+  const openaiModule = await import(`./conversationRecovery.ts?provider=openai-${Date.now()}`)
+  const thirdParty = openaiModule.deserializeMessagesWithInterruptDetection(serializedMessages as never[])
+  const thirdPartyAssistantMessages = thirdParty.messages.filter(
+    message => message.type === 'assistant',
+  )
+
+  expect(thirdPartyAssistantMessages).toHaveLength(2)
+  expect(thirdPartyAssistantMessages[0]?.message?.content).toEqual([
+    { type: 'text', text: 'visible reply' },
+  ])
+  expect(
+    JSON.stringify(thirdPartyAssistantMessages.map(message => message.message?.content)),
+  ).not.toContain('secret reasoning')
+  expect(
+    JSON.stringify(thirdPartyAssistantMessages.map(message => message.message?.content)),
+  ).not.toContain('only hidden reasoning')
+
+  mock.restore()
+  mock.module('./model/providers.js', () => ({
+    getAPIProvider: () => 'bedrock',
+    isOpenAICompatibleProvider: (provider: string) =>
+      provider === 'openai' ||
+      provider === 'gemini' ||
+      provider === 'github' ||
+      provider === 'codex',
+  }))
+
+  const bedrockModule = await import(`./conversationRecovery.ts?provider=bedrock-${Date.now()}`)
+  const anthropicCompatible = bedrockModule.deserializeMessagesWithInterruptDetection(serializedMessages as never[])
+  const anthropicAssistantMessages = anthropicCompatible.messages.filter(
+    message => message.type === 'assistant',
+  )
+
+  expect(anthropicAssistantMessages).toHaveLength(2)
+  expect(anthropicAssistantMessages[0]?.message?.content).toEqual([
+    { type: 'thinking', thinking: 'secret reasoning' },
+    { type: 'text', text: 'visible reply' },
+  ])
+  expect(
+    JSON.stringify(anthropicAssistantMessages.map(message => message.message?.content)),
+  ).toContain('secret reasoning')
+  expect(
+    JSON.stringify(anthropicAssistantMessages.map(message => message.message?.content)),
+  ).not.toContain('only hidden reasoning')
+})

src/utils/conversationRecovery.test.ts

@@ -13,6 +13,7 @@ const originalSimple = process.env.CLAUDE_CODE_SIMPLE
 const sessionId = '00000000-0000-4000-8000-000000001999'
 const ts = '2026-04-02T00:00:00.000Z'
 
+
 function id(n: number): string {
   return `00000000-0000-4000-8000-${String(n).padStart(12, '0')}`
 }
@@ -76,4 +77,3 @@ test('loadConversationForResume rejects oversized reconstructed transcripts', as
     'Reconstructed transcript is too large to resume safely',
   )
 })
-

src/utils/conversationRecovery.ts

@@ -24,6 +24,7 @@ import {
   type FileHistorySnapshot,
 } from './fileHistory.js'
 import { logError } from './log.js'
+import { getAPIProvider } from './model/providers.js'
 import {
   createAssistantMessage,
   createUserMessage,
@@ -177,6 +178,25 @@ export type DeserializeResult = {
   turnInterruptionState: TurnInterruptionState
 }
 
+/**
+ * Remove thinking/redacted_thinking content blocks from assistant messages.
+ * Messages that become empty after stripping are removed entirely.
+ */
+function stripThinkingBlocks(messages: NormalizedMessage[]): NormalizedMessage[] {
+  return messages.reduce<NormalizedMessage[]>((acc, msg) => {
+    if (msg.type !== 'assistant' || !Array.isArray(msg.message?.content)) {
+      acc.push(msg)
+      return acc
+    }
+    const filtered = msg.message.content.filter(
+      (block: { type?: string }) => block.type !== 'thinking' && block.type !== 'redacted_thinking',
+    )
+    if (filtered.length === 0) return acc
+    acc.push({ ...msg, message: { ...msg.message, content: filtered } })
+    return acc
+  }, [])
+}
+
 /**
  * Deserializes messages from a log file into the format expected by the REPL.
  * Filters unresolved tool uses, orphaned thinking messages, and appends a
@@ -227,10 +247,19 @@ export function deserializeMessagesWithInterruptDetection(
       filteredToolUses,
     ) as NormalizedMessage[]
 
+    // Strip thinking/redacted_thinking content blocks from assistant messages
+    // when resuming against a 3P provider. These Anthropic-specific blocks cause
+    // 400 errors or context corruption on OpenAI-compatible providers (issue #248 finding 5).
+    const provider = getAPIProvider()
+    const isThirdPartyProvider = provider !== 'firstParty' && provider !== 'bedrock' && provider !== 'vertex' && provider !== 'foundry'
+    const thinkingStripped = isThirdPartyProvider
+      ? stripThinkingBlocks(filteredThinking)
+      : filteredThinking
+
     // Filter out assistant messages with only whitespace text content.
     // This can happen when model outputs "\n\n" before thinking, user cancels mid-stream.
     const filteredMessages = filterWhitespaceOnlyAssistantMessages(
-      filteredThinking,
+      thinkingStripped,
     ) as NormalizedMessage[]
 
     const internalState = detectTurnInterruption(filteredMessages)

src/utils/dragDropPaths.test.ts

@@ -4,6 +4,10 @@ import { tmpdir } from 'os'
 import { join } from 'path'
 import { extractDraggedFilePaths } from './dragDropPaths.js'
 
+function escapeFinderDraggedPath(filePath: string): string {
+  return filePath.replace(/([\\ ])/g, '\\$1')
+}
+
 describe('extractDraggedFilePaths', () => {
   // Paths that exist on any system.
   const thisFile = import.meta.path
@@ -80,6 +84,12 @@ describe('extractDraggedFilePaths', () => {
     })
   })
 
+  test('escapeFinderDraggedPath escapes spaces and backslashes', () => {
+    expect(escapeFinderDraggedPath('/tmp/my\\notes file.txt')).toBe(
+      '/tmp/my\\\\notes\\ file.txt',
+    )
+  })
+
   // Backslash-escaped paths are a Finder/macOS + Linux convention — on
   // Windows the shell-escape step is skipped, so these cases do not apply.
   if (process.platform !== 'win32') {
@@ -92,7 +102,7 @@ describe('extractDraggedFilePaths', () => {
 
       test('resolves an escaped real file with a space in its name', () => {
         // Raw form matches what a terminal delivers on Finder drag.
-        const escaped = spacedFile.replace(/ /g, '\\ ')
+        const escaped = escapeFinderDraggedPath(spacedFile)
         expect(extractDraggedFilePaths(escaped)).toEqual([spacedFile])
       })
     })

src/utils/githubModelsCredentials.hydrate.test.ts

@@ -10,6 +10,8 @@ describe('hydrateGithubModelsTokenFromSecureStorage', () => {
     CLAUDE_CODE_USE_GITHUB: process.env.CLAUDE_CODE_USE_GITHUB,
     GITHUB_TOKEN: process.env.GITHUB_TOKEN,
     GH_TOKEN: process.env.GH_TOKEN,
+    CLAUDE_CODE_GITHUB_TOKEN_HYDRATED:
+      process.env.CLAUDE_CODE_GITHUB_TOKEN_HYDRATED,
     CLAUDE_CODE_SIMPLE: process.env.CLAUDE_CODE_SIMPLE,
   }
 
@@ -39,15 +41,17 @@ describe('hydrateGithubModelsTokenFromSecureStorage', () => {
     }))
 
     const { hydrateGithubModelsTokenFromSecureStorage } = await import(
-      './githubModelsCredentials.js'
+      './githubModelsCredentials.js?hydrate=sets-token'
     )
     hydrateGithubModelsTokenFromSecureStorage()
     expect(process.env.GITHUB_TOKEN).toBe('stored-secret')
+    expect(process.env.CLAUDE_CODE_GITHUB_TOKEN_HYDRATED).toBe('1')
   })
 
   test('does not override existing GITHUB_TOKEN', async () => {
     process.env.CLAUDE_CODE_USE_GITHUB = '1'
     process.env.GITHUB_TOKEN = 'already'
+    delete process.env.CLAUDE_CODE_GITHUB_TOKEN_HYDRATED
 
     mock.module('./secureStorage/index.js', () => ({
       getSecureStorage: () => ({
@@ -58,9 +62,10 @@ describe('hydrateGithubModelsTokenFromSecureStorage', () => {
     }))
 
     const { hydrateGithubModelsTokenFromSecureStorage } = await import(
-      './githubModelsCredentials.js'
+      './githubModelsCredentials.js?hydrate=preserve-existing'
     )
     hydrateGithubModelsTokenFromSecureStorage()
     expect(process.env.GITHUB_TOKEN).toBe('already')
+    expect(process.env.CLAUDE_CODE_GITHUB_TOKEN_HYDRATED).toBeUndefined()
   })
 })

src/utils/githubModelsCredentials.test.ts

@@ -1,13 +1,11 @@
 import { describe, expect, test } from 'bun:test'
 
-import {
-  clearGithubModelsToken,
-  readGithubModelsToken,
-  saveGithubModelsToken,
-} from './githubModelsCredentials.js'
-
 describe('readGithubModelsToken', () => {
-  test('returns undefined in bare mode', () => {
+  test('returns undefined in bare mode', async () => {
+    const { readGithubModelsToken } = await import(
+      './githubModelsCredentials.js?read-bare-mode'
+    )
+
     const prev = process.env.CLAUDE_CODE_SIMPLE
     process.env.CLAUDE_CODE_SIMPLE = '1'
     expect(readGithubModelsToken()).toBeUndefined()
@@ -20,7 +18,11 @@ describe('readGithubModelsToken', () => {
 })
 
 describe('saveGithubModelsToken / clearGithubModelsToken', () => {
-  test('save returns failure in bare mode', () => {
+  test('save returns failure in bare mode', async () => {
+    const { saveGithubModelsToken } = await import(
+      './githubModelsCredentials.js?save-bare-mode'
+    )
+
     const prev = process.env.CLAUDE_CODE_SIMPLE
     process.env.CLAUDE_CODE_SIMPLE = '1'
     const r = saveGithubModelsToken('abc')
@@ -33,7 +35,11 @@ describe('saveGithubModelsToken / clearGithubModelsToken', () => {
     }
   })
 
-  test('clear succeeds in bare mode', () => {
+  test('clear succeeds in bare mode', async () => {
+    const { clearGithubModelsToken } = await import(
+      './githubModelsCredentials.js?clear-bare-mode'
+    )
+
     const prev = process.env.CLAUDE_CODE_SIMPLE
     process.env.CLAUDE_CODE_SIMPLE = '1'
     expect(clearGithubModelsToken().success).toBe(true)

src/utils/githubModelsCredentials.ts

@@ -3,6 +3,8 @@ import { getSecureStorage } from './secureStorage/index.js'
 
 /** JSON key in the shared OpenClaude secure storage blob. */
 export const GITHUB_MODELS_STORAGE_KEY = 'githubModels' as const
+export const GITHUB_MODELS_HYDRATED_ENV_MARKER =
+  'CLAUDE_CODE_GITHUB_TOKEN_HYDRATED' as const
 
 export type GithubModelsCredentialBlob = {
   accessToken: string
@@ -21,24 +23,47 @@ export function readGithubModelsToken(): string | undefined {
   }
 }
 
+export async function readGithubModelsTokenAsync(): Promise<string | undefined> {
+  if (isBareMode()) return undefined
+  try {
+    const data = (await getSecureStorage().readAsync()) as
+      | ({ githubModels?: GithubModelsCredentialBlob } & Record<string, unknown>)
+      | null
+    const t = data?.githubModels?.accessToken?.trim()
+    return t || undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * If GitHub Models mode is on and no token is in the environment, copy the
  * stored token into process.env so the OpenAI shim and validation see it.
  */
 export function hydrateGithubModelsTokenFromSecureStorage(): void {
   if (!isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)) {
+    delete process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER]
     return
   }
-  if (process.env.GITHUB_TOKEN?.trim() || process.env.GH_TOKEN?.trim()) {
+  if (process.env.GH_TOKEN?.trim()) {
+    delete process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER]
+    return
+  }
+  if (process.env.GITHUB_TOKEN?.trim()) {
+    delete process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER]
     return
   }
   if (isBareMode()) {
+    delete process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER]
     return
   }
   const t = readGithubModelsToken()
   if (t) {
     process.env.GITHUB_TOKEN = t
+    process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER] = '1'
+    return
   }
+  delete process.env[GITHUB_MODELS_HYDRATED_ENV_MARKER]
 }
 
 export function saveGithubModelsToken(token: string): {

src/utils/model/model.ts

@@ -80,7 +80,9 @@ export function getUserSpecifiedModelSetting(): ModelSetting | undefined {
     const provider = getAPIProvider()
     specifiedModel =
       (provider === 'gemini' ? process.env.GEMINI_MODEL : undefined) ||
-      (provider === 'openai' || provider === 'gemini' ? process.env.OPENAI_MODEL : undefined) ||
+      (provider === 'openai' || provider === 'gemini' || provider === 'github'
+        ? process.env.OPENAI_MODEL
+        : undefined) ||
       (provider === 'firstParty' ? process.env.ANTHROPIC_MODEL : undefined) ||
       settings.model ||
       undefined
@@ -237,6 +239,10 @@ export function getDefaultMainLoopModelSetting(): ModelName | ModelAlias {
   if (getAPIProvider() === 'openai') {
     return process.env.OPENAI_MODEL || 'gpt-4o'
   }
+  // GitHub provider: always use the configured GitHub model
+  if (getAPIProvider() === 'github') {
+    return process.env.OPENAI_MODEL || 'github:copilot'
+  }
   // Codex provider: always use the configured Codex model (default gpt-5.4)
   if (getAPIProvider() === 'codex') {
     return process.env.OPENAI_MODEL || 'gpt-5.4'

src/utils/model/modelOptions.github.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, beforeEach, expect, mock, test } from 'bun:test'
+
+import { resetModelStringsForTestingOnly } from '../../bootstrap/state.js'
+import { saveGlobalConfig } from '../config.js'
+
+async function importFreshModelOptionsModule() {
+  mock.restore()
+  mock.module('./providers.js', () => ({
+    getAPIProvider: () => 'github',
+  }))
+  const nonce = `${Date.now()}-${Math.random()}`
+  return import(`./modelOptions.js?ts=${nonce}`)
+}
+
+const originalEnv = {
+  CLAUDE_CODE_USE_GITHUB: process.env.CLAUDE_CODE_USE_GITHUB,
+  CLAUDE_CODE_USE_OPENAI: process.env.CLAUDE_CODE_USE_OPENAI,
+  CLAUDE_CODE_USE_GEMINI: process.env.CLAUDE_CODE_USE_GEMINI,
+  CLAUDE_CODE_USE_BEDROCK: process.env.CLAUDE_CODE_USE_BEDROCK,
+  CLAUDE_CODE_USE_VERTEX: process.env.CLAUDE_CODE_USE_VERTEX,
+  CLAUDE_CODE_USE_FOUNDRY: process.env.CLAUDE_CODE_USE_FOUNDRY,
+  OPENAI_MODEL: process.env.OPENAI_MODEL,
+  OPENAI_BASE_URL: process.env.OPENAI_BASE_URL,
+  ANTHROPIC_CUSTOM_MODEL_OPTION: process.env.ANTHROPIC_CUSTOM_MODEL_OPTION,
+}
+
+beforeEach(() => {
+  mock.restore()
+  delete process.env.CLAUDE_CODE_USE_GITHUB
+  delete process.env.CLAUDE_CODE_USE_OPENAI
+  delete process.env.CLAUDE_CODE_USE_GEMINI
+  delete process.env.CLAUDE_CODE_USE_BEDROCK
+  delete process.env.CLAUDE_CODE_USE_VERTEX
+  delete process.env.CLAUDE_CODE_USE_FOUNDRY
+  delete process.env.OPENAI_MODEL
+  delete process.env.OPENAI_BASE_URL
+  delete process.env.ANTHROPIC_CUSTOM_MODEL_OPTION
+  resetModelStringsForTestingOnly()
+})
+
+afterEach(() => {
+  process.env.CLAUDE_CODE_USE_GITHUB = originalEnv.CLAUDE_CODE_USE_GITHUB
+  process.env.CLAUDE_CODE_USE_OPENAI = originalEnv.CLAUDE_CODE_USE_OPENAI
+  process.env.CLAUDE_CODE_USE_GEMINI = originalEnv.CLAUDE_CODE_USE_GEMINI
+  process.env.CLAUDE_CODE_USE_BEDROCK = originalEnv.CLAUDE_CODE_USE_BEDROCK
+  process.env.CLAUDE_CODE_USE_VERTEX = originalEnv.CLAUDE_CODE_USE_VERTEX
+  process.env.CLAUDE_CODE_USE_FOUNDRY = originalEnv.CLAUDE_CODE_USE_FOUNDRY
+  process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
+  process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
+  process.env.ANTHROPIC_CUSTOM_MODEL_OPTION =
+    originalEnv.ANTHROPIC_CUSTOM_MODEL_OPTION
+  saveGlobalConfig(current => ({
+    ...current,
+    additionalModelOptionsCache: [],
+    additionalModelOptionsCacheScope: undefined,
+    openaiAdditionalModelOptionsCache: [],
+    openaiAdditionalModelOptionsCacheByProfile: {},
+    providerProfiles: [],
+    activeProviderProfileId: undefined,
+  }))
+  resetModelStringsForTestingOnly()
+})
+
+test('GitHub provider exposes only default + GitHub model in /model options', async () => {
+  process.env.CLAUDE_CODE_USE_GITHUB = '1'
+  delete process.env.CLAUDE_CODE_USE_OPENAI
+  delete process.env.CLAUDE_CODE_USE_GEMINI
+  delete process.env.CLAUDE_CODE_USE_BEDROCK
+  delete process.env.CLAUDE_CODE_USE_VERTEX
+  delete process.env.CLAUDE_CODE_USE_FOUNDRY
+
+  process.env.OPENAI_MODEL = 'github:copilot'
+  delete process.env.ANTHROPIC_CUSTOM_MODEL_OPTION
+
+  const { getModelOptions } = await importFreshModelOptionsModule()
+  const options = getModelOptions(false)
+  const nonDefault = options.filter(
+    (option: { value: unknown }) => option.value !== null,
+  )
+
+  expect(nonDefault.length).toBe(1)
+  expect(nonDefault[0]?.value).toBe('github:copilot')
+})

src/utils/model/modelOptions.ts

@@ -352,6 +352,18 @@ function getCodexModelOptions(): ModelOption[] {
 // @[MODEL LAUNCH]: Update the model picker lists below to include/reorder options for the new model.
 // Each user tier (ant, Max/Team Premium, Pro/Team Standard/Enterprise, PAYG 1P, PAYG 3P) has its own list.
 function getModelOptionsBase(fastMode = false): ModelOption[] {
+  if (getAPIProvider() === 'github') {
+    const githubModel = process.env.OPENAI_MODEL?.trim() || 'github:copilot'
+    return [
+      getDefaultOptionForUser(fastMode),
+      {
+        value: githubModel,
+        label: githubModel,
+        description: 'GitHub Models default',
+      },
+    ]
+  }
+
   // When using Ollama, show models from the Ollama server instead of Claude models
   if (getAPIProvider() === 'openai' && isOllamaProvider()) {
     const defaultOption = getDefaultOptionForUser(fastMode)
@@ -579,6 +591,10 @@ function getKnownModelOption(model: string): ModelOption | null {
 }
 
 export function getModelOptions(fastMode = false): ModelOption[] {
+  if (getAPIProvider() === 'github') {
+    return filterModelOptionsByAllowlist(getModelOptionsBase(fastMode))
+  }
+
   const options = getModelOptionsBase(fastMode)
 
   // Add the custom model from the ANTHROPIC_CUSTOM_MODEL_OPTION env var

src/utils/model/modelStrings.github.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, expect, test } from 'bun:test'
+
+import { resetModelStringsForTestingOnly } from '../../bootstrap/state.js'
+import { parseUserSpecifiedModel } from './model.js'
+import { getModelStrings } from './modelStrings.js'
+
+const originalEnv = {
+  CLAUDE_CODE_USE_GITHUB: process.env.CLAUDE_CODE_USE_GITHUB,
+  CLAUDE_CODE_USE_OPENAI: process.env.CLAUDE_CODE_USE_OPENAI,
+  CLAUDE_CODE_USE_GEMINI: process.env.CLAUDE_CODE_USE_GEMINI,
+  CLAUDE_CODE_USE_BEDROCK: process.env.CLAUDE_CODE_USE_BEDROCK,
+  CLAUDE_CODE_USE_VERTEX: process.env.CLAUDE_CODE_USE_VERTEX,
+  CLAUDE_CODE_USE_FOUNDRY: process.env.CLAUDE_CODE_USE_FOUNDRY,
+}
+
+function clearProviderFlags(): void {
+  delete process.env.CLAUDE_CODE_USE_GITHUB
+  delete process.env.CLAUDE_CODE_USE_OPENAI
+  delete process.env.CLAUDE_CODE_USE_GEMINI
+  delete process.env.CLAUDE_CODE_USE_BEDROCK
+  delete process.env.CLAUDE_CODE_USE_VERTEX
+  delete process.env.CLAUDE_CODE_USE_FOUNDRY
+}
+
+afterEach(() => {
+  process.env.CLAUDE_CODE_USE_GITHUB = originalEnv.CLAUDE_CODE_USE_GITHUB
+  process.env.CLAUDE_CODE_USE_OPENAI = originalEnv.CLAUDE_CODE_USE_OPENAI
+  process.env.CLAUDE_CODE_USE_GEMINI = originalEnv.CLAUDE_CODE_USE_GEMINI
+  process.env.CLAUDE_CODE_USE_BEDROCK = originalEnv.CLAUDE_CODE_USE_BEDROCK
+  process.env.CLAUDE_CODE_USE_VERTEX = originalEnv.CLAUDE_CODE_USE_VERTEX
+  process.env.CLAUDE_CODE_USE_FOUNDRY = originalEnv.CLAUDE_CODE_USE_FOUNDRY
+  resetModelStringsForTestingOnly()
+})
+
+test('GitHub provider model strings are concrete IDs', () => {
+  clearProviderFlags()
+  process.env.CLAUDE_CODE_USE_GITHUB = '1'
+
+  const modelStrings = getModelStrings()
+
+  for (const value of Object.values(modelStrings)) {
+    expect(typeof value).toBe('string')
+    expect(value.trim().length).toBeGreaterThan(0)
+  }
+})
+
+test('GitHub provider model strings are safe to parse', () => {
+  clearProviderFlags()
+  process.env.CLAUDE_CODE_USE_GITHUB = '1'
+
+  const modelStrings = getModelStrings()
+
+  expect(() => parseUserSpecifiedModel(modelStrings.sonnet46 as any)).not.toThrow()
+})

src/utils/model/modelStrings.ts

@@ -25,7 +25,7 @@ const MODEL_KEYS = Object.keys(ALL_MODEL_CONFIGS) as ModelKey[]
 function getBuiltinModelStrings(provider: APIProvider): ModelStrings {
   // Codex piggybacks on the OpenAI provider transport for Anthropic tier aliases.
   // Reuse OpenAI mappings so model string lookups never return undefined.
-  const providerKey = provider === 'codex' ? 'openai' : provider
+  const providerKey = provider === 'codex' || provider === 'github' ? 'openai' : provider
   const out = {} as ModelStrings
   for (const key of MODEL_KEYS) {
     out[key] = ALL_MODEL_CONFIGS[key][providerKey]

src/utils/model/openaiContextWindows.ts

@@ -44,6 +44,10 @@ const OPENAI_CONTEXT_WINDOWS: Record<string, number> = {
   'mistral-large-latest':     131_072,
   'mistral-small-latest':     131_072,
 
+  // MiniMax
+  'MiniMax-M2.7':             204_800,
+  'minimax-m2.7':             204_800,
+
   // Google (via OpenRouter)
   'google/gemini-2.0-flash':1_048_576,
   'google/gemini-2.5-pro':  1_048_576,
@@ -110,6 +114,10 @@ const OPENAI_MAX_OUTPUT_TOKENS: Record<string, number> = {
   'mistral-large-latest':     32_768,
   'mistral-small-latest':     32_768,
 
+  // MiniMax
+  'MiniMax-M2.7':            131_072,
+  'minimax-m2.7':            131_072,
+
   // Google (via OpenRouter)
   'google/gemini-2.0-flash':   8_192,
   'google/gemini-2.5-pro':    65_536,

src/utils/providerFlag.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, afterEach } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import {
   parseProviderFlag,
   applyProviderFlag,
@@ -8,18 +8,26 @@ import {
 
 const originalEnv = { ...process.env }
 
+const RESET_KEYS = [
+  'CLAUDE_CODE_USE_OPENAI',
+  'CLAUDE_CODE_USE_GEMINI',
+  'CLAUDE_CODE_USE_GITHUB',
+  'CLAUDE_CODE_USE_BEDROCK',
+  'CLAUDE_CODE_USE_VERTEX',
+  'OPENAI_BASE_URL',
+  'OPENAI_API_KEY',
+  'OPENAI_MODEL',
+  'GEMINI_MODEL',
+] as const
+
+beforeEach(() => {
+  for (const key of RESET_KEYS) {
+    delete process.env[key]
+  }
+})
+
 afterEach(() => {
-  for (const key of [
-    'CLAUDE_CODE_USE_OPENAI',
-    'CLAUDE_CODE_USE_GEMINI',
-    'CLAUDE_CODE_USE_GITHUB',
-    'CLAUDE_CODE_USE_BEDROCK',
-    'CLAUDE_CODE_USE_VERTEX',
-    'OPENAI_BASE_URL',
-    'OPENAI_API_KEY',
-    'OPENAI_MODEL',
-    'GEMINI_MODEL',
-  ]) {
+  for (const key of RESET_KEYS) {
     if (originalEnv[key] === undefined) delete process.env[key]
     else process.env[key] = originalEnv[key]
   }

src/utils/providerProfile.test.ts

@@ -485,6 +485,26 @@ test('buildStartupEnvFromProfile leaves explicit provider selections untouched',
   assert.equal(env.OPENAI_API_KEY, undefined)
 })
 
+test('buildStartupEnvFromProfile leaves profile-managed env untouched', async () => {
+  const processEnv = {
+    CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED: '1',
+    ANTHROPIC_BASE_URL: 'https://api.anthropic.com',
+    ANTHROPIC_MODEL: 'claude-sonnet-4-6',
+  }
+
+  const env = await buildStartupEnvFromProfile({
+    persisted: profile('openai', {
+      OPENAI_API_KEY: 'sk-persisted',
+      OPENAI_MODEL: 'gpt-4o',
+    }),
+    processEnv,
+  })
+
+  assert.equal(env, processEnv)
+  assert.equal(env.ANTHROPIC_MODEL, 'claude-sonnet-4-6')
+  assert.equal(env.OPENAI_MODEL, undefined)
+})
+
 test('buildStartupEnvFromProfile treats explicit falsey provider flags as user intent', async () => {
   const processEnv = {
     CLAUDE_CODE_USE_OPENAI: '0',

src/utils/providerProfile.ts

@@ -407,6 +407,11 @@ export function deleteProfileFile(options?: ProfileFileLocation): string {
 export function hasExplicitProviderSelection(
   processEnv: NodeJS.ProcessEnv = process.env,
 ): boolean {
+  // If env was already applied from a provider profile, preserve it.
+  if (processEnv.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED === '1') {
+    return true
+  }
+
   return (
     processEnv.CLAUDE_CODE_USE_OPENAI !== undefined ||
     processEnv.CLAUDE_CODE_USE_GITHUB !== undefined ||

src/utils/providerProfiles.test.ts

@@ -2,10 +2,15 @@ import { afterEach, describe, expect, mock, test } from 'bun:test'
 
 import type { ProviderProfile } from './config.js'
 
+async function importFreshProvidersModule() {
+  return import(`./model/providers.ts?ts=${Date.now()}-${Math.random()}`)
+}
+
 const originalEnv = { ...process.env }
 
 const RESTORED_KEYS = [
   'CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED',
+  'CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID',
   'CLAUDE_CODE_USE_OPENAI',
   'CLAUDE_CODE_USE_GEMINI',
   'CLAUDE_CODE_USE_GITHUB',
@@ -21,8 +26,35 @@ const RESTORED_KEYS = [
   'ANTHROPIC_API_KEY',
 ] as const
 
+type MockConfigState = {
+  providerProfiles: ProviderProfile[]
+  activeProviderProfileId?: string
+  openaiAdditionalModelOptionsCache: unknown[]
+  openaiAdditionalModelOptionsCacheByProfile: Record<string, unknown[]>
+  additionalModelOptionsCache?: unknown[]
+  additionalModelOptionsCacheScope?: string
+}
+
+function createMockConfigState(): MockConfigState {
+  return {
+    providerProfiles: [],
+    activeProviderProfileId: undefined,
+    openaiAdditionalModelOptionsCache: [],
+    openaiAdditionalModelOptionsCacheByProfile: {},
+    additionalModelOptionsCache: [],
+    additionalModelOptionsCacheScope: undefined,
+  }
+}
+
+let mockConfigState: MockConfigState = createMockConfigState()
+
+function saveMockGlobalConfig(
+  updater: (current: MockConfigState) => MockConfigState,
+): void {
+  mockConfigState = updater(mockConfigState)
+}
+
 afterEach(() => {
-  mock.restore()
   for (const key of RESTORED_KEYS) {
     if (originalEnv[key] === undefined) {
       delete process.env[key]
@@ -30,8 +62,31 @@ afterEach(() => {
       process.env[key] = originalEnv[key]
     }
   }
+
+  mock.restore()
+  mockConfigState = createMockConfigState()
 })
 
+async function importFreshProviderProfileModules() {
+  mock.restore()
+  mock.module('./config.js', () => ({
+    getGlobalConfig: () => mockConfigState,
+    saveGlobalConfig: (
+      updater: (current: MockConfigState) => MockConfigState,
+    ) => {
+      mockConfigState = updater(mockConfigState)
+    },
+  }))
+  const nonce = `${Date.now()}-${Math.random()}`
+  const providers = await import(`./model/providers.js?ts=${nonce}`)
+  const providerProfiles = await import(`./providerProfiles.js?ts=${nonce}`)
+
+  return {
+    ...providers,
+    ...providerProfiles,
+  }
+}
+
 function buildProfile(overrides: Partial<ProviderProfile> = {}): ProviderProfile {
   return {
     id: 'provider_test',
@@ -43,57 +98,31 @@ function buildProfile(overrides: Partial<ProviderProfile> = {}): ProviderProfile
   }
 }
 
-async function importFreshProviderModules() {
-  mock.restore()
-  let configState = {
-    providerProfiles: [] as ProviderProfile[],
-    activeProviderProfileId: undefined as string | undefined,
-    openaiAdditionalModelOptionsCache: [] as any[],
-    openaiAdditionalModelOptionsCacheByProfile: {} as Record<string, any[]>,
-  }
-
-  mock.module('./config.js', () => ({
-    getGlobalConfig: () => configState,
-    saveGlobalConfig: (
-      updater: (current: typeof configState) => typeof configState,
-    ) => {
-      configState = updater(configState)
-    },
-  }))
-
-  const providerProfiles = await import(
-    `./providerProfiles.js?ts=${Date.now()}-${Math.random()}`
-  )
-  const providers = await import(
-    `./model/providers.js?ts=${Date.now()}-${Math.random()}`
-  )
-
-  return {
-    ...providerProfiles,
-    ...providers,
-  }
-}
-
 describe('applyProviderProfileToProcessEnv', () => {
   test('openai profile clears competing gemini/github flags', async () => {
+    const { applyProviderProfileToProcessEnv } =
+      await importFreshProviderProfileModules()
     process.env.CLAUDE_CODE_USE_GEMINI = '1'
     process.env.CLAUDE_CODE_USE_GITHUB = '1'
-    const { applyProviderProfileToProcessEnv, getAPIProvider } =
-      await importFreshProviderModules()
 
     applyProviderProfileToProcessEnv(buildProfile())
+    const { getAPIProvider: getFreshAPIProvider } =
+      await importFreshProvidersModule()
 
     expect(process.env.CLAUDE_CODE_USE_GEMINI).toBeUndefined()
     expect(process.env.CLAUDE_CODE_USE_GITHUB).toBeUndefined()
-    expect(process.env.CLAUDE_CODE_USE_OPENAI).toBe('1')
-    expect(getAPIProvider()).toBe('openai')
+    expect(String(process.env.CLAUDE_CODE_USE_OPENAI)).toBe('1')
+    expect(process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID).toBe(
+      'provider_test',
+    )
+    expect(getFreshAPIProvider()).toBe('openai')
   })
 
   test('anthropic profile clears competing gemini/github flags', async () => {
+    const { applyProviderProfileToProcessEnv } =
+      await importFreshProviderProfileModules()
     process.env.CLAUDE_CODE_USE_GEMINI = '1'
     process.env.CLAUDE_CODE_USE_GITHUB = '1'
-    const { applyProviderProfileToProcessEnv, getAPIProvider } =
-      await importFreshProviderModules()
 
     applyProviderProfileToProcessEnv(
       buildProfile({
@@ -102,21 +131,23 @@ describe('applyProviderProfileToProcessEnv', () => {
         model: 'claude-sonnet-4-6',
       }),
     )
+    const { getAPIProvider: getFreshAPIProvider } =
+      await importFreshProvidersModule()
 
     expect(process.env.CLAUDE_CODE_USE_GEMINI).toBeUndefined()
     expect(process.env.CLAUDE_CODE_USE_GITHUB).toBeUndefined()
     expect(process.env.CLAUDE_CODE_USE_OPENAI).toBeUndefined()
-    expect(getAPIProvider()).toBe('firstParty')
+    expect(getFreshAPIProvider()).toBe('firstParty')
   })
 })
 
 describe('applyActiveProviderProfileFromConfig', () => {
   test('does not override explicit startup provider selection', async () => {
+    const { applyActiveProviderProfileFromConfig } =
+      await importFreshProviderProfileModules()
     process.env.CLAUDE_CODE_USE_OPENAI = '1'
     process.env.OPENAI_BASE_URL = 'http://localhost:11434/v1'
     process.env.OPENAI_MODEL = 'qwen2.5:3b'
-    const { applyActiveProviderProfileFromConfig } =
-      await importFreshProviderModules()
 
     const applied = applyActiveProviderProfileFromConfig({
       providerProfiles: [
@@ -135,12 +166,12 @@ describe('applyActiveProviderProfileFromConfig', () => {
   })
 
   test('does not override explicit startup selection when profile marker is stale', async () => {
+    const { applyActiveProviderProfileFromConfig } =
+      await importFreshProviderProfileModules()
     process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED = '1'
     process.env.CLAUDE_CODE_USE_OPENAI = '1'
     process.env.OPENAI_BASE_URL = 'http://localhost:11434/v1'
     process.env.OPENAI_MODEL = 'qwen2.5:3b'
-    const { applyActiveProviderProfileFromConfig } =
-      await importFreshProviderModules()
 
     const applied = applyActiveProviderProfileFromConfig({
       providerProfiles: [
@@ -154,12 +185,74 @@ describe('applyActiveProviderProfileFromConfig', () => {
     } as any)
 
     expect(applied).toBeUndefined()
-    expect(process.env.CLAUDE_CODE_USE_OPENAI).toBe('1')
+    expect(String(process.env.CLAUDE_CODE_USE_OPENAI)).toBe('1')
     expect(process.env.OPENAI_BASE_URL).toBe('http://localhost:11434/v1')
     expect(process.env.OPENAI_MODEL).toBe('qwen2.5:3b')
   })
 
+  test('re-applies active profile when profile-managed env drifts', async () => {
+    const { applyActiveProviderProfileFromConfig, applyProviderProfileToProcessEnv } =
+      await importFreshProviderProfileModules()
+    applyProviderProfileToProcessEnv(
+      buildProfile({
+        id: 'saved_openai',
+        baseUrl: 'http://192.168.33.108:11434/v1',
+        model: 'kimi-k2.5:cloud',
+      }),
+    )
+
+    // Simulate settings/env merge clobbering the model while profile flags remain.
+    process.env.OPENAI_MODEL = 'github:copilot'
+
+    const applied = applyActiveProviderProfileFromConfig({
+      providerProfiles: [
+        buildProfile({
+          id: 'saved_openai',
+          baseUrl: 'http://192.168.33.108:11434/v1',
+          model: 'kimi-k2.5:cloud',
+        }),
+      ],
+      activeProviderProfileId: 'saved_openai',
+    } as any)
+
+    expect(applied?.id).toBe('saved_openai')
+    expect(process.env.OPENAI_MODEL).toBe('kimi-k2.5:cloud')
+    expect(process.env.OPENAI_BASE_URL).toBe('http://192.168.33.108:11434/v1')
+  })
+
+  test('does not re-apply active profile when flags conflict with current provider', async () => {
+    const { applyActiveProviderProfileFromConfig, applyProviderProfileToProcessEnv } =
+      await importFreshProviderProfileModules()
+    applyProviderProfileToProcessEnv(
+      buildProfile({
+        id: 'saved_openai',
+        baseUrl: 'http://192.168.33.108:11434/v1',
+        model: 'kimi-k2.5:cloud',
+      }),
+    )
+
+    process.env.CLAUDE_CODE_USE_GITHUB = '1'
+    process.env.OPENAI_MODEL = 'github:copilot'
+
+    const applied = applyActiveProviderProfileFromConfig({
+      providerProfiles: [
+        buildProfile({
+          id: 'saved_openai',
+          baseUrl: 'http://192.168.33.108:11434/v1',
+          model: 'kimi-k2.5:cloud',
+        }),
+      ],
+      activeProviderProfileId: 'saved_openai',
+    } as any)
+
+    expect(applied).toBeUndefined()
+    expect(process.env.CLAUDE_CODE_USE_GITHUB).toBe('1')
+    expect(process.env.OPENAI_MODEL).toBe('github:copilot')
+  })
+
   test('applies active profile when no explicit provider is selected', async () => {
+    const { applyActiveProviderProfileFromConfig } =
+      await importFreshProviderProfileModules()
     delete process.env.CLAUDE_CODE_USE_OPENAI
     delete process.env.CLAUDE_CODE_USE_GEMINI
     delete process.env.CLAUDE_CODE_USE_GITHUB
@@ -169,8 +262,6 @@ describe('applyActiveProviderProfileFromConfig', () => {
 
     process.env.OPENAI_BASE_URL = 'http://localhost:11434/v1'
     process.env.OPENAI_MODEL = 'qwen2.5:3b'
-    const { applyActiveProviderProfileFromConfig } =
-      await importFreshProviderModules()
 
     const applied = applyActiveProviderProfileFromConfig({
       providerProfiles: [
@@ -184,16 +275,82 @@ describe('applyActiveProviderProfileFromConfig', () => {
     } as any)
 
     expect(applied?.id).toBe('saved_openai')
-    expect(process.env.CLAUDE_CODE_USE_OPENAI).toBe('1')
+    expect(String(process.env.CLAUDE_CODE_USE_OPENAI)).toBe('1')
     expect(process.env.OPENAI_BASE_URL).toBe('https://api.openai.com/v1')
     expect(process.env.OPENAI_MODEL).toBe('gpt-4o')
   })
 })
 
+describe('persistActiveProviderProfileModel', () => {
+  test('updates active profile model and current env for profile-managed sessions', async () => {
+    const {
+      applyProviderProfileToProcessEnv,
+      getProviderProfiles,
+      persistActiveProviderProfileModel,
+    } = await importFreshProviderProfileModules()
+    const activeProfile = buildProfile({
+      id: 'saved_openai',
+      baseUrl: 'http://192.168.33.108:11434/v1',
+      model: 'kimi-k2.5:cloud',
+    })
+
+    saveMockGlobalConfig(current => ({
+      ...current,
+      providerProfiles: [activeProfile],
+      activeProviderProfileId: activeProfile.id,
+    }))
+    applyProviderProfileToProcessEnv(activeProfile)
+
+    const updated = persistActiveProviderProfileModel('minimax-m2.5:cloud')
+
+    expect(updated?.id).toBe(activeProfile.id)
+    expect(updated?.model).toBe('minimax-m2.5:cloud')
+    expect(process.env.OPENAI_MODEL).toBe('minimax-m2.5:cloud')
+    expect(process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID).toBe(
+      activeProfile.id,
+    )
+
+    const saved = getProviderProfiles().find(
+      (profile: ProviderProfile) => profile.id === activeProfile.id,
+    )
+    expect(saved?.model).toBe('minimax-m2.5:cloud')
+  })
+
+  test('does not mutate process env when session is not profile-managed', async () => {
+    const {
+      getProviderProfiles,
+      persistActiveProviderProfileModel,
+    } = await importFreshProviderProfileModules()
+    const activeProfile = buildProfile({
+      id: 'saved_openai',
+      model: 'kimi-k2.5:cloud',
+    })
+
+    saveMockGlobalConfig(current => ({
+      ...current,
+      providerProfiles: [activeProfile],
+      activeProviderProfileId: activeProfile.id,
+    }))
+
+    process.env.CLAUDE_CODE_USE_OPENAI = '1'
+    process.env.OPENAI_MODEL = 'cli-model'
+    delete process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED
+    delete process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID
+
+    persistActiveProviderProfileModel('minimax-m2.5:cloud')
+
+    expect(process.env.OPENAI_MODEL).toBe('cli-model')
+    const saved = getProviderProfiles().find(
+      (profile: ProviderProfile) => profile.id === activeProfile.id,
+    )
+    expect(saved?.model).toBe('minimax-m2.5:cloud')
+  })
+})
+
 describe('getProviderPresetDefaults', () => {
   test('ollama preset defaults to a local Ollama model', async () => {
+    const { getProviderPresetDefaults } = await importFreshProviderProfileModules()
     delete process.env.OPENAI_MODEL
-    const { getProviderPresetDefaults } = await importFreshProviderModules()
 
     const defaults = getProviderPresetDefaults('ollama')
 
@@ -205,21 +362,25 @@ describe('getProviderPresetDefaults', () => {
 describe('deleteProviderProfile', () => {
   test('deleting final profile clears provider env when active profile applied it', async () => {
     const {
-      addProviderProfile,
+      applyProviderProfileToProcessEnv,
       deleteProviderProfile,
-    } =
-      await importFreshProviderModules()
-    const profile = addProviderProfile({
-      name: 'Only Profile',
-      provider: 'openai',
-      baseUrl: 'https://api.openai.com/v1',
-      model: 'gpt-4o',
-      apiKey: 'sk-test',
-    })
+    } = await importFreshProviderProfileModules()
+    applyProviderProfileToProcessEnv(
+      buildProfile({
+        id: 'only_profile',
+        baseUrl: 'https://api.openai.com/v1',
+        model: 'gpt-4o',
+        apiKey: 'sk-test',
+      }),
+    )
 
-    expect(profile).not.toBeNull()
+    saveMockGlobalConfig(current => ({
+      ...current,
+      providerProfiles: [buildProfile({ id: 'only_profile' })],
+      activeProviderProfileId: 'only_profile',
+    }))
 
-    const result = deleteProviderProfile(profile!.id)
+    const result = deleteProviderProfile('only_profile')
 
     expect(result.removed).toBe(true)
     expect(result.activeProfileId).toBeUndefined()
@@ -244,30 +405,24 @@ describe('deleteProviderProfile', () => {
   })
 
   test('deleting final profile preserves explicit startup provider env', async () => {
-    const { addProviderProfile, deleteProviderProfile } =
-      await importFreshProviderModules()
-    const profile = addProviderProfile({
-      name: 'Only Profile',
-      provider: 'openai',
-      baseUrl: 'https://api.openai.com/v1',
-      model: 'gpt-4o',
-    })
-
-    expect(profile).not.toBeNull()
-
-    process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED = undefined
-    delete process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED
+    const { deleteProviderProfile } = await importFreshProviderProfileModules()
     process.env.CLAUDE_CODE_USE_OPENAI = '1'
     process.env.OPENAI_BASE_URL = 'http://localhost:11434/v1'
     process.env.OPENAI_MODEL = 'qwen2.5:3b'
 
-    const result = deleteProviderProfile(profile!.id)
+    saveMockGlobalConfig(current => ({
+      ...current,
+      providerProfiles: [buildProfile({ id: 'only_profile' })],
+      activeProviderProfileId: 'only_profile',
+    }))
+
+    const result = deleteProviderProfile('only_profile')
 
     expect(result.removed).toBe(true)
     expect(result.activeProfileId).toBeUndefined()
 
     expect(process.env.CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED).toBeUndefined()
-    expect(process.env.CLAUDE_CODE_USE_OPENAI).toBe('1')
+    expect(String(process.env.CLAUDE_CODE_USE_OPENAI)).toBe('1')
     expect(process.env.OPENAI_BASE_URL).toBe('http://localhost:11434/v1')
     expect(process.env.OPENAI_MODEL).toBe('qwen2.5:3b')
   })

src/utils/providerProfiles.ts

@@ -37,6 +37,7 @@ export type ProviderPresetDefaults = Omit<ProviderProfileInput, 'provider'> & {
 const DEFAULT_OLLAMA_BASE_URL = 'http://localhost:11434/v1'
 const DEFAULT_OLLAMA_MODEL = 'llama3.1:8b'
 const PROFILE_ENV_APPLIED_FLAG = 'CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED'
+const PROFILE_ENV_APPLIED_ID = 'CLAUDE_CODE_PROVIDER_PROFILE_ENV_APPLIED_ID'
 
 function trimValue(value: string | undefined): string {
   return value?.trim() ?? ''
@@ -264,6 +265,23 @@ function hasProviderSelectionFlags(
   )
 }
 
+function hasConflictingProviderFlagsForProfile(
+  processEnv: NodeJS.ProcessEnv,
+  profile: ProviderProfile,
+): boolean {
+  if (profile.provider === 'anthropic') {
+    return hasProviderSelectionFlags(processEnv)
+  }
+
+  return (
+    processEnv.CLAUDE_CODE_USE_GEMINI !== undefined ||
+    processEnv.CLAUDE_CODE_USE_GITHUB !== undefined ||
+    processEnv.CLAUDE_CODE_USE_BEDROCK !== undefined ||
+    processEnv.CLAUDE_CODE_USE_VERTEX !== undefined ||
+    processEnv.CLAUDE_CODE_USE_FOUNDRY !== undefined
+  )
+}
+
 function sameOptionalEnvValue(
   left: string | undefined,
   right: string | undefined,
@@ -284,6 +302,10 @@ function isProcessEnvAlignedWithProfile(
     return false
   }
 
+  if (trimOrUndefined(processEnv[PROFILE_ENV_APPLIED_ID]) !== profile.id) {
+    return false
+  }
+
   if (profile.provider === 'anthropic') {
     return (
       !hasProviderSelectionFlags(processEnv) &&
@@ -339,11 +361,13 @@ export function clearProviderProfileEnvFromProcessEnv(
   delete processEnv.ANTHROPIC_MODEL
   delete processEnv.ANTHROPIC_API_KEY
   delete processEnv[PROFILE_ENV_APPLIED_FLAG]
+  delete processEnv[PROFILE_ENV_APPLIED_ID]
 }
 
 export function applyProviderProfileToProcessEnv(profile: ProviderProfile): void {
   clearProviderProfileEnvFromProcessEnv()
   process.env[PROFILE_ENV_APPLIED_FLAG] = '1'
+  process.env[PROFILE_ENV_APPLIED_ID] = profile.id
 
   process.env.ANTHROPIC_MODEL = profile.model
   if (profile.provider === 'anthropic') {
@@ -386,12 +410,24 @@ export function applyActiveProviderProfileFromConfig(
     return undefined
   }
 
+  const isCurrentEnvProfileManaged =
+    processEnv[PROFILE_ENV_APPLIED_FLAG] === '1' &&
+    trimOrUndefined(processEnv[PROFILE_ENV_APPLIED_ID]) === activeProfile.id
+
   if (!options?.force && hasProviderSelectionFlags(processEnv)) {
-    // Respect explicit startup provider intent. Re-apply only when the
-    // current process env is already profile-managed and aligned.
-    if (!isProcessEnvAlignedWithProfile(processEnv, activeProfile)) {
+    // Respect explicit startup provider intent. Auto-heal only when this
+    // exact active profile previously applied the current env.
+    if (!isCurrentEnvProfileManaged) {
       return undefined
     }
+
+    if (hasConflictingProviderFlagsForProfile(processEnv, activeProfile)) {
+      return undefined
+    }
+
+    if (isProcessEnvAlignedWithProfile(processEnv, activeProfile)) {
+      return activeProfile
+    }
   }
 
   applyProviderProfileToProcessEnv(activeProfile)
@@ -496,6 +532,61 @@ export function updateProviderProfile(
   return updatedProfile
 }
 
+export function persistActiveProviderProfileModel(
+  model: string,
+): ProviderProfile | null {
+  const nextModel = trimOrUndefined(model)
+  if (!nextModel) {
+    return null
+  }
+
+  const activeProfile = getActiveProviderProfile()
+  if (!activeProfile) {
+    return null
+  }
+
+  saveGlobalConfig(current => {
+    const currentProfiles = getProviderProfiles(current)
+    const profileIndex = currentProfiles.findIndex(
+      profile => profile.id === activeProfile.id,
+    )
+
+    if (profileIndex < 0) {
+      return current
+    }
+
+    const currentProfile = currentProfiles[profileIndex]
+    if (currentProfile.model === nextModel) {
+      return current
+    }
+
+    const nextProfiles = [...currentProfiles]
+    nextProfiles[profileIndex] = {
+      ...currentProfile,
+      model: nextModel,
+    }
+
+    return {
+      ...current,
+      providerProfiles: nextProfiles,
+    }
+  })
+
+  const resolvedProfile = getActiveProviderProfile()
+  if (!resolvedProfile || resolvedProfile.id !== activeProfile.id) {
+    return null
+  }
+
+  if (
+    process.env[PROFILE_ENV_APPLIED_FLAG] === '1' &&
+    trimOrUndefined(process.env[PROFILE_ENV_APPLIED_ID]) === resolvedProfile.id
+  ) {
+    applyProviderProfileToProcessEnv(resolvedProfile)
+  }
+
+  return resolvedProfile
+}
+
 export function setActiveProviderProfile(
   profileId: string,
 ): ProviderProfile | null {

src/utils/ripgrep.test.ts

@@ -1,11 +1,52 @@
 import { expect, test } from 'bun:test'
+import path from 'path'
 
-import { wrapRipgrepUnavailableError } from './ripgrep.ts'
+import { resolveRipgrepConfig, wrapRipgrepUnavailableError } from './ripgrep.js'
+
+const MOCK_BUILTIN_PATH = path.normalize(
+  process.platform === 'win32'
+    ? `vendor/ripgrep/${process.arch}-win32/rg.exe`
+    : `vendor/ripgrep/${process.arch}-${process.platform}/rg`,
+)
+
+test('ripgrepCommand falls back to system rg when builtin binary is missing', () => {
+  const config = resolveRipgrepConfig({
+    userWantsSystemRipgrep: false,
+    bundledMode: false,
+    builtinCommand: MOCK_BUILTIN_PATH,
+    builtinExists: false,
+    systemExecutablePath: '/usr/bin/rg',
+    processExecPath: '/fake/bun',
+  })
+
+  expect(config).toMatchObject({
+    mode: 'system',
+    command: 'rg',
+    args: [],
+  })
+})
+
+test('ripgrepCommand keeps builtin mode when bundled binary exists', () => {
+  const config = resolveRipgrepConfig({
+    userWantsSystemRipgrep: false,
+    bundledMode: false,
+    builtinCommand: MOCK_BUILTIN_PATH,
+    builtinExists: true,
+    systemExecutablePath: '/usr/bin/rg',
+    processExecPath: '/fake/bun',
+  })
+
+  expect(config).toMatchObject({
+    mode: 'builtin',
+    command: MOCK_BUILTIN_PATH,
+    args: [],
+  })
+})
 
 test('wrapRipgrepUnavailableError explains missing packaged fallback', () => {
   const error = wrapRipgrepUnavailableError(
     { code: 'ENOENT', message: 'spawn rg ENOENT' },
-    { mode: 'builtin', command: 'C:\\fake\\vendor\\ripgrep\\rg.exe' },
+    { mode: 'builtin', command: 'C:\\fake\\vendor\\ripgrep\\rg.exe', args: [] },
     'win32',
   )
 
@@ -18,7 +59,7 @@ test('wrapRipgrepUnavailableError explains missing packaged fallback', () => {
 test('wrapRipgrepUnavailableError explains missing system ripgrep', () => {
   const error = wrapRipgrepUnavailableError(
     { code: 'ENOENT', message: 'spawn rg ENOENT' },
-    { mode: 'system', command: 'rg' },
+    { mode: 'system', command: 'rg', args: [] },
     'linux',
   )
 

src/utils/ripgrep.ts

@@ -1,5 +1,6 @@
 import type { ChildProcess, ExecFileException } from 'child_process'
 import { execFile, spawn } from 'child_process'
+import { existsSync } from 'fs'
 import memoize from 'lodash-es/memoize.js'
 import { homedir } from 'os'
 import * as path from 'path'
@@ -30,40 +31,72 @@ type RipgrepConfig = {
 
 type RipgrepErrorLike = Pick<NodeJS.ErrnoException, 'code' | 'message'>
 
-const getRipgrepConfig = memoize((): RipgrepConfig => {
-  const userWantsSystemRipgrep = isEnvDefinedFalsy(
-    process.env.USE_BUILTIN_RIPGREP,
-  )
+function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error
+}
 
-  // Try system ripgrep if user wants it
-  if (userWantsSystemRipgrep) {
-    const { cmd: systemPath } = findExecutable('rg', [])
-    if (systemPath !== 'rg') {
-      // SECURITY: Use command name 'rg' instead of systemPath to prevent PATH hijacking
-      // If we used systemPath, a malicious ./rg.exe in current directory could be executed
-      // Using just 'rg' lets the OS resolve it safely with NoDefaultCurrentDirectoryInExePath protection
-      return { mode: 'system', command: 'rg', args: [] }
-    }
+type ResolveRipgrepConfigArgs = {
+  userWantsSystemRipgrep: boolean
+  bundledMode: boolean
+  builtinCommand: string
+  builtinExists: boolean
+  systemExecutablePath: string
+  processExecPath?: string
+}
+
+export function resolveRipgrepConfig({
+  userWantsSystemRipgrep,
+  bundledMode,
+  builtinCommand,
+  builtinExists,
+  systemExecutablePath,
+  processExecPath = process.execPath,
+}: ResolveRipgrepConfigArgs): RipgrepConfig {
+  if (userWantsSystemRipgrep && systemExecutablePath !== 'rg') {
+    // SECURITY: Use command name 'rg' instead of systemExecutablePath to prevent PATH hijacking
+    return { mode: 'system', command: 'rg', args: [] }
   }
 
-  // In bundled (native) mode, ripgrep is statically compiled into bun-internal
-  // and dispatches based on argv[0]. We spawn ourselves with argv0='rg'.
-  if (isInBundledMode()) {
+  if (bundledMode) {
     return {
       mode: 'embedded',
-      command: process.execPath,
+      command: processExecPath,
       args: ['--no-config'],
       argv0: 'rg',
     }
   }
 
+  if (builtinExists) {
+    return { mode: 'builtin', command: builtinCommand, args: [] }
+  }
+
+  if (systemExecutablePath !== 'rg') {
+    return { mode: 'system', command: 'rg', args: [] }
+  }
+
+  return { mode: 'builtin', command: builtinCommand, args: [] }
+}
+
+const getRipgrepConfig = memoize((): RipgrepConfig => {
+  const userWantsSystemRipgrep = isEnvDefinedFalsy(
+    process.env.USE_BUILTIN_RIPGREP,
+  )
+  const bundledMode = isInBundledMode()
   const rgRoot = path.resolve(__dirname, 'vendor', 'ripgrep')
-  const command =
+  const builtinCommand =
     process.platform === 'win32'
       ? path.resolve(rgRoot, `${process.arch}-win32`, 'rg.exe')
       : path.resolve(rgRoot, `${process.arch}-${process.platform}`, 'rg')
+  const builtinExists = existsSync(builtinCommand)
+  const { cmd: systemExecutablePath } = findExecutable('rg', [])
 
-  return { mode: 'builtin', command, args: [] }
+  return resolveRipgrepConfig({
+    userWantsSystemRipgrep,
+    bundledMode,
+    builtinCommand,
+    builtinExists,
+    systemExecutablePath,
+  })
 })
 
 export function ripgrepCommand(): {
@@ -324,7 +357,9 @@ async function ripGrepFileCount(
       if (settled) return
       settled = true
       reject(
-        err.code === 'ENOENT' ? wrapRipgrepUnavailableError(err) : err,
+        isErrnoException(err) && err.code === 'ENOENT'
+          ? wrapRipgrepUnavailableError(err)
+          : err,
       )
     })
   })
@@ -388,7 +423,9 @@ export async function ripGrepStream(
       if (settled) return
       settled = true
       reject(
-        err.code === 'ENOENT' ? wrapRipgrepUnavailableError(err) : err,
+        isErrnoException(err) && err.code === 'ENOENT'
+          ? wrapRipgrepUnavailableError(err)
+          : err,
       )
     })
   })
@@ -436,7 +473,9 @@ export async function ripGrep(
       const CRITICAL_ERROR_CODES = ['ENOENT', 'EACCES', 'EPERM']
       if (CRITICAL_ERROR_CODES.includes(error.code as string)) {
         reject(
-          error.code === 'ENOENT' ? wrapRipgrepUnavailableError(error) : error,
+          isErrnoException(error) && error.code === 'ENOENT'
+            ? wrapRipgrepUnavailableError(error)
+            : error,
         )
         return
       }

src/utils/schemaSanitizer.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'bun:test'
+
+import { sanitizeSchemaForOpenAICompat } from './schemaSanitizer'
+
+describe('sanitizeSchemaForOpenAICompat', () => {
+  test('preserves Grep-like properties.pattern while keeping it required', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        pattern: {
+          type: 'string',
+          description: 'The regular expression pattern to search for in file contents',
+        },
+        path: { type: 'string' },
+        glob: { type: 'string' },
+      },
+      required: ['pattern'],
+    }
+
+    const sanitized = sanitizeSchemaForOpenAICompat(schema)
+    const properties = sanitized.properties as Record<string, unknown> | undefined
+
+    expect(Object.keys(properties ?? {})).toEqual(['pattern', 'path', 'glob'])
+    expect(properties?.pattern).toEqual({
+      type: 'string',
+      description: 'The regular expression pattern to search for in file contents',
+    })
+    expect(sanitized.required).toEqual(['pattern'])
+  })
+
+  test('preserves Glob-like properties.pattern while keeping it required', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        pattern: {
+          type: 'string',
+          description: 'The glob pattern to match files against',
+        },
+        path: { type: 'string' },
+      },
+      required: ['pattern'],
+    }
+
+    const sanitized = sanitizeSchemaForOpenAICompat(schema)
+    const properties = sanitized.properties as Record<string, unknown> | undefined
+
+    expect(Object.keys(properties ?? {})).toEqual(['pattern', 'path'])
+    expect(properties?.pattern).toEqual({
+      type: 'string',
+      description: 'The glob pattern to match files against',
+    })
+    expect(sanitized.required).toEqual(['pattern'])
+  })
+
+  test('strips JSON Schema validator pattern from string schemas', () => {
+    const schema = {
+      type: 'string',
+      pattern: '^[a-z]+$',
+      minLength: 1,
+    }
+
+    const sanitized = sanitizeSchemaForOpenAICompat(schema)
+
+    expect(sanitized).toEqual({
+      type: 'string',
+    })
+  })
+})

src/utils/schemaSanitizer.ts

@@ -33,6 +33,15 @@ function stripSchemaKeywords(schema: unknown, keywords: Set<string>): unknown {
 
   const result: Record<string, unknown> = {}
   for (const [key, value] of Object.entries(schema)) {
+    if (key === 'properties' && isSchemaRecord(value)) {
+      const sanitizedProps: Record<string, unknown> = {}
+      for (const [propName, propSchema] of Object.entries(value)) {
+        sanitizedProps[propName] = stripSchemaKeywords(propSchema, keywords)
+      }
+      result[key] = sanitizedProps
+      continue
+    }
+
     if (keywords.has(key)) {
       continue
     }
@@ -215,10 +224,13 @@ export function sanitizeSchemaForOpenAICompat(
     }
   }
 
-  if (Array.isArray(record.required) && isSchemaRecord(record.properties)) {
+  const properties = isSchemaRecord(record.properties)
+    ? record.properties
+    : undefined
+
+  if (Array.isArray(record.required) && properties) {
     record.required = record.required.filter(
-      (value): value is string =>
-        typeof value === 'string' && value in record.properties,
+      (value): value is string => typeof value === 'string' && value in properties,
     )
   }
 

src/utils/staticRender.tsx

@@ -97,8 +97,12 @@ export function renderToAnsiString(node: React.ReactNode, columns?: number): Pro
       patchConsole: false
     });
 
-    // Wait for the component to exit naturally
-    await instance.waitUntilExit();
+    // Wait for the component to exit naturally, with a timeout guard so
+    // tests never hang indefinitely if a render error prevents exit().
+    await Promise.race([
+      instance.waitUntilExit(),
+      new Promise<void>(resolve => setTimeout(resolve, 3000)),
+    ]);
 
     // Extract only the first frame's content to avoid duplication
     // (Ink outputs multiple frames in non-TTY mode)