fix: align SkillTool schema error output

src/components/CustomSelect/use-multi-select-state.ts

@@ -1,4 +1,5 @@
 import { useCallback, useState } from 'react'
+import { isDeepStrictEqual } from 'util'
 import { useRegisterOverlay } from '../../context/overlayContext.js'
 import type { InputEvent } from '../../ink/events/input-event.js'
 // eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw space/arrow multiselect input
@@ -8,7 +9,6 @@ import {
   normalizeFullWidthSpace,
 } from '../../utils/stringUtils.js'
 import type { OptionWithDescription } from './select.js'
-import { optionsNavigateEqual } from './use-select-navigation.js'
 import { useSelectNavigation } from './use-select-navigation.js'
 
 export type UseMultiSelectStateProps<T> = {
@@ -174,7 +174,7 @@ export function useMultiSelectState<T>({
   // and the deleted ui/useMultiSelectState.ts — without this, MCPServerDesktopImportDialog
   // keeps colliding servers checked after getAllMcpConfigs() resolves.
   const [lastOptions, setLastOptions] = useState(options)
-  if (options !== lastOptions && !optionsNavigateEqual(options, lastOptions)) {
+  if (options !== lastOptions && !isDeepStrictEqual(options, lastOptions)) {
     setSelectedValues(defaultValue)
     setLastOptions(options)
   }

src/components/CustomSelect/use-select-navigation.ts

@@ -6,34 +6,10 @@ import {
   useRef,
   useState,
 } from 'react'
+import { isDeepStrictEqual } from 'util'
 import OptionMap from './option-map.js'
 import type { OptionWithDescription } from './select.js'
 
-/**
- * Compare two option arrays for structural equality on properties that
- * affect navigation behavior. ReactNode `label` and function `onChange`
- * are intentionally excluded — they are identity-unstable (new reference
- * each render) but don't change navigation semantics.
- */
-export function optionsNavigateEqual<T>(
-  a: OptionWithDescription<T>[],
-  b: OptionWithDescription<T>[],
-): boolean {
-  if (a.length !== b.length) return false
-  for (let i = 0; i < a.length; i++) {
-    const ao = a[i]!
-    const bo = b[i]!
-    if (
-      ao.value !== bo.value ||
-      ao.disabled !== bo.disabled ||
-      ao.type !== bo.type
-    ) {
-      return false
-    }
-  }
-  return true
-}
-
 type State<T> = {
   /**
    * Map where key is option's value and value is option's index.
@@ -548,7 +524,7 @@ export function useSelectNavigation<T>({
 
   const [lastOptions, setLastOptions] = useState(options)
 
-  if (options !== lastOptions && !optionsNavigateEqual(options, lastOptions)) {
+  if (options !== lastOptions && !isDeepStrictEqual(options, lastOptions)) {
     dispatch({
       type: 'reset',
       state: createDefaultState({

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 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"
+      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"
       <commentary>
-      Since the user is asking how to use Claude Code, use the claude-code-guide agent.
+      Since the user is greeting, use the greeting-responder agent to respond with a friendly joke. 
       </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,34 +8,6 @@ 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/services/api/codexShim.test.ts

@@ -201,117 +201,6 @@ 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.test.ts

@@ -261,73 +261,6 @@ test('preserves Gemini tool call extra_content in follow-up requests', async ()
   })
 })
 
-test('preserves Grep tool pattern field in OpenAI-compatible schemas', async () => {
-  let requestBody: Record<string, unknown> | undefined
-
-  globalThis.fetch = (async (_input, init) => {
-    requestBody = JSON.parse(String(init?.body))
-
-    return new Response(
-      JSON.stringify({
-        id: 'chatcmpl-grep-schema',
-        model: 'qwen/qwen3.6-plus',
-        choices: [
-          {
-            message: {
-              role: 'assistant',
-              content: 'done',
-            },
-            finish_reason: 'stop',
-          },
-        ],
-        usage: {
-          prompt_tokens: 12,
-          completion_tokens: 4,
-          total_tokens: 16,
-        },
-      }),
-      {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      },
-    )
-  }) as FetchType
-
-  const client = createOpenAIShimClient({}) as OpenAIShimClient
-
-  await client.beta.messages.create({
-    model: 'qwen/qwen3.6-plus',
-    system: 'test system',
-    messages: [{ role: 'user', content: 'Use Grep' }],
-    tools: [
-      {
-        name: 'Grep',
-        description: 'Search file contents',
-        input_schema: {
-          type: 'object',
-          properties: {
-            pattern: { type: 'string', description: 'Search pattern' },
-            path: { type: 'string' },
-          },
-          required: ['pattern'],
-          additionalProperties: false,
-        },
-      },
-    ],
-    max_tokens: 64,
-    stream: false,
-  })
-
-  const tools = requestBody?.tools as Array<Record<string, unknown>> | undefined
-  const grepTool = tools?.find(tool => (tool.function as Record<string, unknown>)?.name === 'Grep') as
-    | { function?: { parameters?: { properties?: Record<string, unknown>; required?: string[] } } }
-    | undefined
-
-  expect(Object.keys(grepTool?.function?.parameters?.properties ?? {})).toContain('pattern')
-  expect(grepTool?.function?.parameters?.required).toContain('pattern')
-})
-
 test('does not infer Gemini mode from OPENAI_BASE_URL path substrings', async () => {
   let capturedAuthorization: string | null = null
 

src/services/api/openaiShim.ts

@@ -195,12 +195,10 @@ function convertContentBlocks(
         // handled separately
         break
       case '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.
+        // Append thinking as text with a marker for models that support reasoning
+        if (block.thinking) {
+          parts.push({ type: 'text', text: `<thinking>${block.thinking}</thinking>` })
+        }
         break
       default:
         if (block.text) {

src/tools/AgentTool/prompt.ts

@@ -156,24 +156,34 @@ ${AGENT_TOOL_NAME}({
   const currentExamples = `Example usage:
 
 <example_agent_descriptions>
-"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
+"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
 </example_agent_descriptions>
 
 <example>
-user: "How do I configure Claude Code hooks?"
+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>
 <commentary>
-This is a Claude Code usage question, so use the claude-code-guide agent
+Since a significant piece of code was written and the task was completed, now use the test-runner agent to run the tests
 </commentary>
-assistant: Uses the ${AGENT_TOOL_NAME} tool to launch the claude-code-guide agent
+assistant: Uses the ${AGENT_TOOL_NAME} tool to launch the test-runner agent
 </example>
 
 <example>
-user: "Set up my Claude Code status line"
+user: "Hello"
 <commentary>
-This matches the statusline-setup agent, so use it to configure the setting
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
 </commentary>
-assistant: "I'm going to use the ${AGENT_TOOL_NAME} tool to launch the statusline-setup agent"
+assistant: "I'm going to use the ${AGENT_TOOL_NAME} tool to launch the greeting-responder agent"
 </example>
 `
 

src/utils/context.test.ts

@@ -94,22 +94,3 @@ 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,23 +72,16 @@ export function getContextWindowForModel(
     return 1_000_000
   }
 
-  // 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 =
+  // OpenAI-compatible provider — use known context windows for the model
+  if (
     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,93 +69,3 @@ 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,7 +13,6 @@ 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')}`
 }
@@ -77,3 +76,4 @@ test('loadConversationForResume rejects oversized reconstructed transcripts', as
     'Reconstructed transcript is too large to resume safely',
   )
 })
+

src/utils/conversationRecovery.ts

@@ -24,7 +24,6 @@ import {
   type FileHistorySnapshot,
 } from './fileHistory.js'
 import { logError } from './log.js'
-import { getAPIProvider } from './model/providers.js'
 import {
   createAssistantMessage,
   createUserMessage,
@@ -178,25 +177,6 @@ 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
@@ -247,19 +227,10 @@ 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(
-      thinkingStripped,
+      filteredThinking,
     ) as NormalizedMessage[]
 
     const internalState = detectTurnInterruption(filteredMessages)

src/utils/model/openaiContextWindows.ts

@@ -44,10 +44,6 @@ 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,
@@ -114,10 +110,6 @@ 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/ripgrep.test.ts

@@ -1,52 +1,11 @@
 import { expect, test } from 'bun:test'
-import path from 'path'
 
-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: [],
-  })
-})
+import { wrapRipgrepUnavailableError } from './ripgrep.ts'
 
 test('wrapRipgrepUnavailableError explains missing packaged fallback', () => {
   const error = wrapRipgrepUnavailableError(
     { code: 'ENOENT', message: 'spawn rg ENOENT' },
-    { mode: 'builtin', command: 'C:\\fake\\vendor\\ripgrep\\rg.exe', args: [] },
+    { mode: 'builtin', command: 'C:\\fake\\vendor\\ripgrep\\rg.exe' },
     'win32',
   )
 
@@ -59,7 +18,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', args: [] },
+    { mode: 'system', command: 'rg' },
     'linux',
   )
 

src/utils/ripgrep.ts

@@ -1,6 +1,5 @@
 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'
@@ -31,72 +30,40 @@ type RipgrepConfig = {
 
 type RipgrepErrorLike = Pick<NodeJS.ErrnoException, 'code' | 'message'>
 
-function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
-  return error instanceof Error
-}
+const getRipgrepConfig = memoize((): RipgrepConfig => {
+  const userWantsSystemRipgrep = isEnvDefinedFalsy(
+    process.env.USE_BUILTIN_RIPGREP,
+  )
 
-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
+  // 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: [] }
     }
+  }
 
-  if (bundledMode) {
+  // 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()) {
     return {
       mode: 'embedded',
-      command: processExecPath,
+      command: process.execPath,
       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 builtinCommand =
+  const command =
     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 resolveRipgrepConfig({
-    userWantsSystemRipgrep,
-    bundledMode,
-    builtinCommand,
-    builtinExists,
-    systemExecutablePath,
-  })
+  return { mode: 'builtin', command, args: [] }
 })
 
 export function ripgrepCommand(): {
@@ -357,9 +324,7 @@ async function ripGrepFileCount(
       if (settled) return
       settled = true
       reject(
-        isErrnoException(err) && err.code === 'ENOENT'
-          ? wrapRipgrepUnavailableError(err)
-          : err,
+        err.code === 'ENOENT' ? wrapRipgrepUnavailableError(err) : err,
       )
     })
   })
@@ -423,9 +388,7 @@ export async function ripGrepStream(
       if (settled) return
       settled = true
       reject(
-        isErrnoException(err) && err.code === 'ENOENT'
-          ? wrapRipgrepUnavailableError(err)
-          : err,
+        err.code === 'ENOENT' ? wrapRipgrepUnavailableError(err) : err,
       )
     })
   })
@@ -473,9 +436,7 @@ export async function ripGrep(
       const CRITICAL_ERROR_CODES = ['ENOENT', 'EACCES', 'EPERM']
       if (CRITICAL_ERROR_CODES.includes(error.code as string)) {
         reject(
-          isErrnoException(error) && error.code === 'ENOENT'
-            ? wrapRipgrepUnavailableError(error)
-            : error,
+          error.code === 'ENOENT' ? wrapRipgrepUnavailableError(error) : error,
         )
         return
       }

src/utils/schemaSanitizer.test.ts

@@ -1,68 +0,0 @@
-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,15 +33,6 @@ 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
     }
@@ -224,13 +215,10 @@ export function sanitizeSchemaForOpenAICompat(
     }
   }
 
-  const properties = isSchemaRecord(record.properties)
-    ? record.properties
-    : undefined
-
-  if (Array.isArray(record.required) && properties) {
+  if (Array.isArray(record.required) && isSchemaRecord(record.properties)) {
     record.required = record.required.filter(
-      (value): value is string => typeof value === 'string' && value in properties,
+      (value): value is string =>
+        typeof value === 'string' && value in record.properties,
     )
   }