feat: 实现 Tool Search 基础设施层（CORE_TOOLS 白名单 + TF-IDF 索引 + ExecuteTool + 搜索增强）

- 新增 CORE_TOOLS 白名单常量（31 个核心工具），重构 isDeferredTool 为白名单制判定
- 新建 TF-IDF 工具索引模块（toolIndex.ts），复用 localSearch.ts 算法函数
- 新建 ExecuteTool 跨 API provider 统一工具执行入口
- 增强 ToolSearchTool：TF-IDF 搜索路径、discover: 模式、并行搜索合并、文本模式回退
- 新增 27 个单元测试，precheck 零错误通过（4108 tests pass）

Co-Authored-By: glm-5.1[1m] <zai-org@claude-code-best.win>

packages/builtin-tools/src/tools/ExecuteTool/__tests__/ExecuteTool.runner.ts

@@ -0,0 +1,166 @@
+import { describe, test, expect } from 'bun:test'
+import { mock } from 'bun:test'
+import { logMock } from '../../../../../../tests/mocks/log'
+import { debugMock } from '../../../../../../tests/mocks/debug'
+
+mock.module('src/utils/log.ts', logMock)
+mock.module('src/utils/debug.ts', debugMock)
+
+// Mock all heavy dependencies before importing ExecuteTool
+mock.module('src/services/analytics/growthbook.js', () => ({
+  getFeatureValue_CACHED_MAY_BE_STALE: () => false,
+  checkStatsigFeatureGate_CACHED_MAY_BE_STALE: () => false,
+  getFeatureValue_DEPRECATED: async () => undefined,
+  getFeatureValue_CACHED_WITH_REFRESH: async () => undefined,
+  hasGrowthBookEnvOverride: () => false,
+  getAllGrowthBookFeatures: () => ({}),
+  getGrowthBookConfigOverrides: () => ({}),
+  setGrowthBookConfigOverride: () => {},
+  clearGrowthBookConfigOverrides: () => {},
+  getApiBaseUrlHost: () => undefined,
+  onGrowthBookRefresh: () => {},
+  initializeGrowthBook: async () => {},
+  checkSecurityRestrictionGate: async () => false,
+  checkGate_CACHED_OR_BLOCKING: async () => false,
+  refreshGrowthBookAfterAuthChange: () => {},
+  resetGrowthBook: () => {},
+  refreshGrowthBookFeatures: async () => {},
+  setupPeriodicGrowthBookRefresh: () => {},
+  stopPeriodicGrowthBookRefresh: () => {},
+}))
+
+mock.module('src/utils/toolSearch.js', () => ({
+  isToolSearchEnabledOptimistic: () => true,
+  getAutoToolSearchCharThreshold: () => 100,
+  getToolSearchMode: () => 'tst' as const,
+  modelSupportsToolReference: () => true,
+  isToolSearchToolAvailable: async () => true,
+  isToolSearchEnabled: async () => true,
+  isToolReferenceBlock: () => false,
+  extractDiscoveredToolNames: () => new Set(),
+  isDeferredToolsDeltaEnabled: () => false,
+  getDeferredToolsDelta: () => null,
+}))
+
+mock.module('src/constants/tools.js', () => ({
+  CORE_TOOLS: new Set(['ExecuteTool', 'ToolSearch']),
+}))
+
+// Mock messages module
+mock.module('src/utils/messages.js', () => ({
+  createUserMessage: ({ content }: { content: string }) => ({
+    type: 'user' as const,
+    content,
+    uuid: 'test-uuid',
+  }),
+}))
+
+const { ExecuteTool } = await import('../ExecuteTool.js')
+const { EXECUTE_TOOL_NAME } = await import('../constants.js')
+
+function makeContext(tools: unknown[] = []) {
+  return {
+    options: {
+      tools,
+    },
+    cwd: '/tmp',
+    sessionId: 'test',
+  } as never
+}
+
+function makeMockTool(name: string, callResult: unknown = 'ok') {
+  return {
+    name,
+    call: async () => ({ data: callResult }),
+    checkPermissions: async () => ({ behavior: 'allow' as const }),
+    prompt: async () => `Description for ${name}`,
+    description: async () => `Description for ${name}`,
+    inputSchema: {},
+    isEnabled: () => true,
+    isConcurrencySafe: () => true,
+    isReadOnly: () => false,
+    isMcp: false,
+    alwaysLoad: undefined,
+    shouldDefer: undefined,
+    searchHint: '',
+    userFacingName: () => name,
+    renderToolUseMessage: () => `Running ${name}`,
+    mapToolResultToToolResultBlockParam: (content: unknown, id: string) => ({
+      tool_use_id: id,
+      type: 'tool_result',
+      content,
+    }),
+  }
+}
+
+describe('ExecuteTool', () => {
+  test('executes a target tool by name', async () => {
+    const mockTarget = makeMockTool('TestTool', { result: 'success' })
+    const ctx = makeContext([mockTarget])
+
+    const result = await ExecuteTool.call(
+      { tool_name: 'TestTool', params: {} },
+      ctx,
+      async () => ({ behavior: 'allow' }),
+      { type: 'assistant', content: [], uuid: 'msg1' } as never,
+      undefined,
+    )
+
+    expect(result.data).toEqual({
+      result: { result: 'success' },
+      tool_name: 'TestTool',
+    })
+  })
+
+  test('returns error when tool not found', async () => {
+    const ctx = makeContext([])
+
+    const result = await ExecuteTool.call(
+      { tool_name: 'NonexistentTool', params: {} },
+      ctx,
+      async () => ({ behavior: 'allow' }),
+      { type: 'assistant', content: [], uuid: 'msg1' } as never,
+      undefined,
+    )
+
+    expect(result.data).toEqual({
+      result: null,
+      tool_name: 'NonexistentTool',
+    })
+    expect(result.newMessages).toBeDefined()
+    expect(result.newMessages!.length).toBeGreaterThan(0)
+  })
+
+  test('returns permission denied when target denies', async () => {
+    const mockTarget = makeMockTool('SecretTool', 'secret')
+    mockTarget.checkPermissions = async () =>
+      ({
+        behavior: 'deny' as const,
+        message: 'Access denied',
+      }) as never
+    const ctx = makeContext([mockTarget])
+
+    const result = await ExecuteTool.call(
+      { tool_name: 'SecretTool', params: {} },
+      ctx,
+      async () => ({ behavior: 'allow' }),
+      { type: 'assistant', content: [], uuid: 'msg1' } as never,
+      undefined,
+    )
+
+    expect(result.data).toEqual({
+      result: null,
+      tool_name: 'SecretTool',
+    })
+    expect(result.newMessages).toBeDefined()
+  })
+
+  test('has correct name', () => {
+    expect(ExecuteTool.name).toBe(EXECUTE_TOOL_NAME)
+  })
+
+  test('searchHint contains keywords', () => {
+    expect(ExecuteTool.searchHint).toContain('execute')
+    expect(ExecuteTool.searchHint).toContain('tool')
+  })
+})