bingocode 1.1.200-beta.13 → 1.1.200-beta.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.200-beta.13",
+  "version": "1.1.200-beta.15",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/constants/prompts.ts

@@ -976,6 +976,14 @@ Each agent prompt must include:
 
 Report compressed: decisions made, blockers hit, next steps. Never narrate what
 agents are doing moment-by-moment. "Agent A found X, agent B confirmed Y. Decision:
-rollback needed." is enough.`
+rollback needed." is enough.
+
+## Sub-agent Capabilities
+
+Sub-agents have full access to: Bash (shell execution), Read (file reading),
+Write (file creation), Edit (precise string replacement), Grep (regex search),
+Glob (file pattern matching), WebFetch (URL content), WebSearch (web search),
+NotebookEdit (Jupyter editing), plus task management tools and any configured
+MCP servers.`
 }
 

package/src/hooks/useMergedTools.ts

@@ -22,12 +22,13 @@ export function useMergedTools(
   mcpTools: Tools,
   toolPermissionContext: ToolPermissionContext,
 ): Tools {
+  const brainMode = useAppState(s => s.brainMode ?? false)
   let replBridgeEnabled = false
   let replBridgeOutboundOnly = false
   return useMemo(() => {
     // assembleToolPool is the shared function that both REPL and runAgent use.
     // It handles: getTools() + MCP deny-rule filtering + dedup + MCP CLI exclusion.
-    const assembled = assembleToolPool(toolPermissionContext, mcpTools)
+    const assembled = assembleToolPool(toolPermissionContext, mcpTools, brainMode)
 
     return mergeAndFilterTools(
       initialTools,
@@ -38,6 +39,7 @@ export function useMergedTools(
     initialTools,
     mcpTools,
     toolPermissionContext,
+    brainMode,
     replBridgeEnabled,
     replBridgeOutboundOnly,
   ])

package/src/main.tsx

@@ -1865,7 +1865,8 @@ async function run(): Promise<CommanderCommand> {
     // (which returns isProactiveActive()) passes and Sleep is included.
     // The later REPL-path maybeActivateProactive() calls are idempotent.
     maybeActivateProactive(options);
-    let tools = getTools(toolPermissionContext);
+    const brainMode = getInitialSettings().brainMode === true || getCurrentSessionBrainMode() === true
+    let tools = getTools(toolPermissionContext, brainMode);
 
     // Apply coordinator mode tool filtering for headless path
     // (mirrors useMergedTools.ts filtering for REPL/interactive path)

package/src/screens/REPL.tsx

@@ -695,7 +695,8 @@ export function REPL({
   // /brief mid-session leaves the stale tool list (no SendUserMessage) and
   // the model emits plain text the brief filter hides.
   const isBriefOnly = useAppState(s => s.isBriefOnly);
-  const localTools = useMemo(() => getTools(toolPermissionContext), [toolPermissionContext, proactiveActive, isBriefOnly]);
+  const isBrainMode = useAppState(s => s.brainMode ?? false);
+  const localTools = useMemo(() => getTools(toolPermissionContext, isBrainMode), [toolPermissionContext, proactiveActive, isBriefOnly, isBrainMode]);
   useKickOffCheckAndDisableBypassPermissionsIfNeeded();
   useKickOffCheckAndDisableAutoModeIfNeeded();
   const [dynamicMcpConfig, setDynamicMcpConfig] = useState<Record<string, ScopedMcpServerConfig> | undefined>(initialDynamicMcpConfig);
@@ -2404,7 +2405,7 @@ export function REPL({
     // for mid-query tool list updates.
     const computeTools = () => {
       const state = store.getState();
-      const assembled = assembleToolPool(state.toolPermissionContext, state.mcp.tools);
+      const assembled = assembleToolPool(state.toolPermissionContext, state.mcp.tools, state.brainMode);
       const merged = mergeAndFilterTools(combinedInitialTools, assembled, state.toolPermissionContext.mode);
       if (!mainThreadAgentDefinition) return merged;
       return resolveAgentTools(mainThreadAgentDefinition, merged, false, true).resolvedTools;

package/src/server/services/providerService.ts

@@ -602,12 +602,6 @@ export class ProviderService {
     const writtenPaths: string[] = []
     const failedPaths: string[] = []
 
-    // Save pre-link bingo env so we can restore it on disconnect.
-    const bingoSettings = await this.readSettings()
-    const preLinkEnv = bingoSettings.env ?? null
-    bingoSettings.vscodePreLinkEnv = preLinkEnv
-    await this.writeSettings(bingoSettings)
-
     // Fix #8: Snapshot original VS Code claudeCode per path for unlink restore.
     const vscodePreLinkClaudeCode: Record<string, unknown> = {}
     // Fix #9: Backup original contents for rollback on partial failure.
@@ -724,6 +718,7 @@ export class ProviderService {
     }
 
     // Persist so re-sync on restart and unlink work correctly
+    const bingoSettings = await this.readSettings()
     bingoSettings.vscodeLinked = true
     bingoSettings.vscodeLinkedPaths = writtenPaths
     bingoSettings.vscodePreLinkClaudeCode = vscodePreLinkClaudeCode
@@ -741,32 +736,18 @@ export class ProviderService {
   }
 
   /**
-   * Restore pre-link bingo env so the CLI no longer routes through the proxy,
-   * and reset VS Code settings to their pre-link state (the original claudeCode
-   * that was saved in vscodePreLinkClaudeCode). Falls back to a minimal stub
-   * if no snapshot exists.
+   * Reset VS Code settings to pre-link state.  Does NOT touching bingo
+   * settings.env — the CLI keeps routing through the proxy independently.
    *
-   * Without this, the only way to stop VS Code from using bingo would be to
-   * delete ~/.claude/bingo/settings.json entirely — which would also kill CLI
-   * routing.  Saving/restoring the pre-link env keeps CLI and VS Code independent.
+   * Restores the original claudeCode snapshot (vscodePreLinkClaudeCode)
+   * when available, otherwise writes an override that points VS Code to
+   * api.anthropic.com so the extension shows its native login screen.
    */
   async unlinkVscode(): Promise<{ paths: string[]; linked: boolean }> {
     const bingoSettings = await this.readSettings()
     const linkedPaths = (bingoSettings.vscodeLinkedPaths as string[]) || []
 
-    // Restore bingo env to pre-link state
-    const preLinkEnv = bingoSettings.vscodePreLinkEnv
-    if (preLinkEnv !== undefined) {
-      if (preLinkEnv === null || Object.keys(preLinkEnv as Record<string, unknown>).length === 0) {
-        delete bingoSettings.env
-      } else {
-        bingoSettings.env = preLinkEnv
-      }
-      delete bingoSettings.vscodePreLinkEnv
-    }
-
-    // Fix #8: Restore original claudeCode snapshot per-path instead of a hardcoded stub.
-    // Fall back to { preferredLocation: "panel" } when no snapshot exists for a path.
+    // Restore original claudeCode snapshot per-path. Fall back to a clean
     const preLinkClaudeCode =
       (bingoSettings.vscodePreLinkClaudeCode as Record<string, unknown> | undefined) || {}
 
@@ -774,7 +755,12 @@ export class ProviderService {
       try {
         const raw = await fs.readFile(settingsPath, "utf-8")
         const settings = JSON.parse(raw)
-        settings.claudeCode = preLinkClaudeCode[settingsPath] ?? { preferredLocation: "panel" }
+        settings.claudeCode = preLinkClaudeCode[settingsPath] ?? {
+          preferredLocation: "panel",
+          environmentVariables: [
+            { name: "ANTHROPIC_BASE_URL", value: "https://api.anthropic.com" },
+          ],
+        }
         await fs.writeFile(settingsPath, JSON.stringify(settings, null, 4) + '\n')
       } catch {
         // File may have been moved or deleted since linking — harmless
@@ -784,6 +770,7 @@ export class ProviderService {
     bingoSettings.vscodeLinked = false
     delete bingoSettings.vscodeLinkedPaths
     delete bingoSettings.vscodePreLinkClaudeCode
+    delete bingoSettings.vscodePreLinkEnv
     await this.writeSettings(bingoSettings)
 
     return { paths: linkedPaths, linked: false }

package/src/tools.ts

@@ -1,390 +1,397 @@
-// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
-import { toolMatchesName, type Tool, type Tools } from './Tool.js'
-import { AgentTool } from './tools/AgentTool/AgentTool.js'
-import { SkillTool } from './tools/SkillTool/SkillTool.js'
-import { BashTool } from './tools/BashTool/BashTool.js'
-import { FileEditTool } from './tools/FileEditTool/FileEditTool.js'
-import { FileReadTool } from './tools/FileReadTool/FileReadTool.js'
-import { FileWriteTool } from './tools/FileWriteTool/FileWriteTool.js'
-import { GlobTool } from './tools/GlobTool/GlobTool.js'
-import { NotebookEditTool } from './tools/NotebookEditTool/NotebookEditTool.js'
-import { WebFetchTool } from './tools/WebFetchTool/WebFetchTool.js'
-import { TaskStopTool } from './tools/TaskStopTool/TaskStopTool.js'
-import { BriefTool } from './tools/BriefTool/BriefTool.js'
-// Dead code elimination: conditional import for ant-only tools
-/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-const REPLTool =
-  process.env.USER_TYPE === 'ant'
-    ? require('./tools/REPLTool/REPLTool.js').REPLTool
-    : null
-const SuggestBackgroundPRTool =
-  process.env.USER_TYPE === 'ant'
-    ? require('./tools/SuggestBackgroundPRTool/SuggestBackgroundPRTool.js')
-        .SuggestBackgroundPRTool
-    : null
-const SleepTool =
-  feature('PROACTIVE') || feature('KAIROS')
-    ? require('./tools/SleepTool/SleepTool.js').SleepTool
-    : null
-const cronTools = feature('AGENT_TRIGGERS')
-  ? [
-      require('./tools/ScheduleCronTool/CronCreateTool.js').CronCreateTool,
-      require('./tools/ScheduleCronTool/CronUpdateTool.js').CronUpdateTool,
-      require('./tools/ScheduleCronTool/CronDeleteTool.js').CronDeleteTool,
-      require('./tools/ScheduleCronTool/CronListTool.js').CronListTool,
-    ]
-  : []
-const RemoteTriggerTool = feature('AGENT_TRIGGERS_REMOTE')
-  ? require('./tools/RemoteTriggerTool/RemoteTriggerTool.js').RemoteTriggerTool
-  : null
-const MonitorTool = feature('MONITOR_TOOL')
-  ? require('./tools/MonitorTool/MonitorTool.js').MonitorTool
-  : null
-const SendUserFileTool = feature('KAIROS')
-  ? require('./tools/SendUserFileTool/SendUserFileTool.js').SendUserFileTool
-  : null
-const PushNotificationTool =
-  feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION')
-    ? require('./tools/PushNotificationTool/PushNotificationTool.js')
-        .PushNotificationTool
-    : null
-const SubscribePRTool = feature('KAIROS_GITHUB_WEBHOOKS')
-  ? require('./tools/SubscribePRTool/SubscribePRTool.js').SubscribePRTool
-  : null
-/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-import { TaskOutputTool } from './tools/TaskOutputTool/TaskOutputTool.js'
-import { WebSearchTool } from './tools/WebSearchTool/WebSearchTool.js'
-import { TodoWriteTool } from './tools/TodoWriteTool/TodoWriteTool.js'
-import { ExitPlanModeV2Tool } from './tools/ExitPlanModeTool/ExitPlanModeV2Tool.js'
-import { TestingPermissionTool } from './tools/testing/TestingPermissionTool.js'
-import { GrepTool } from './tools/GrepTool/GrepTool.js'
-import { TungstenTool } from './tools/TungstenTool/TungstenTool.js'
-// Lazy require to break circular dependency: tools.ts -> TeamCreateTool/TeamDeleteTool -> ... -> tools.ts
-/* eslint-disable @typescript-eslint/no-require-imports */
-const getTeamCreateTool = () =>
-  require('./tools/TeamCreateTool/TeamCreateTool.js')
-    .TeamCreateTool as typeof import('./tools/TeamCreateTool/TeamCreateTool.js').TeamCreateTool
-const getTeamDeleteTool = () =>
-  require('./tools/TeamDeleteTool/TeamDeleteTool.js')
-    .TeamDeleteTool as typeof import('./tools/TeamDeleteTool/TeamDeleteTool.js').TeamDeleteTool
-const getSendMessageTool = () =>
-  require('./tools/SendMessageTool/SendMessageTool.js')
-    .SendMessageTool as typeof import('./tools/SendMessageTool/SendMessageTool.js').SendMessageTool
-/* eslint-enable @typescript-eslint/no-require-imports */
-import { AskUserQuestionTool } from './tools/AskUserQuestionTool/AskUserQuestionTool.js'
-import { LSPTool } from './tools/LSPTool/LSPTool.js'
-import { ListMcpResourcesTool } from './tools/ListMcpResourcesTool/ListMcpResourcesTool.js'
-import { ReadMcpResourceTool } from './tools/ReadMcpResourceTool/ReadMcpResourceTool.js'
-import { ToolSearchTool } from './tools/ToolSearchTool/ToolSearchTool.js'
-import { EnterPlanModeTool } from './tools/EnterPlanModeTool/EnterPlanModeTool.js'
-import { EnterWorktreeTool } from './tools/EnterWorktreeTool/EnterWorktreeTool.js'
-import { ExitWorktreeTool } from './tools/ExitWorktreeTool/ExitWorktreeTool.js'
-import { ConfigTool } from './tools/ConfigTool/ConfigTool.js'
-import { TaskCreateTool } from './tools/TaskCreateTool/TaskCreateTool.js'
-import { TaskGetTool } from './tools/TaskGetTool/TaskGetTool.js'
-import { TaskUpdateTool } from './tools/TaskUpdateTool/TaskUpdateTool.js'
-import { TaskListTool } from './tools/TaskListTool/TaskListTool.js'
-import uniqBy from 'lodash-es/uniqBy.js'
-import { isToolSearchEnabledOptimistic } from './utils/toolSearch.js'
-import { isTodoV2Enabled } from './utils/tasks.js'
-// Dead code elimination: conditional import for CLAUDE_CODE_VERIFY_PLAN
-/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-const VerifyPlanExecutionTool =
-  process.env.CLAUDE_CODE_VERIFY_PLAN === 'true'
-    ? require('./tools/VerifyPlanExecutionTool/VerifyPlanExecutionTool.js')
-        .VerifyPlanExecutionTool
-    : null
-/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-import { SYNTHETIC_OUTPUT_TOOL_NAME } from './tools/SyntheticOutputTool/SyntheticOutputTool.js'
-export {
-  ALL_AGENT_DISALLOWED_TOOLS,
-  CUSTOM_AGENT_DISALLOWED_TOOLS,
-  ASYNC_AGENT_ALLOWED_TOOLS,
-  COORDINATOR_MODE_ALLOWED_TOOLS,
-} from './constants/tools.js'
-import { feature } from 'bun:bundle'
-// Dead code elimination: conditional import for OVERFLOW_TEST_TOOL
-/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-const OverflowTestTool = feature('OVERFLOW_TEST_TOOL')
-  ? require('./tools/OverflowTestTool/OverflowTestTool.js').OverflowTestTool
-  : null
-const CtxInspectTool = feature('CONTEXT_COLLAPSE')
-  ? require('./tools/CtxInspectTool/CtxInspectTool.js').CtxInspectTool
-  : null
-const TerminalCaptureTool = feature('TERMINAL_PANEL')
-  ? require('./tools/TerminalCaptureTool/TerminalCaptureTool.js')
-      .TerminalCaptureTool
-  : null
-const WebBrowserTool = feature('WEB_BROWSER_TOOL')
-  ? require('./tools/WebBrowserTool/WebBrowserTool.js').WebBrowserTool
-  : null
-const coordinatorModeModule = feature('COORDINATOR_MODE')
-  ? (require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js'))
-  : null
-const SnipTool = feature('HISTORY_SNIP')
-  ? require('./tools/SnipTool/SnipTool.js').SnipTool
-  : null
-const ListPeersTool = feature('UDS_INBOX')
-  ? require('./tools/ListPeersTool/ListPeersTool.js').ListPeersTool
-  : null
-const WorkflowTool = feature('WORKFLOW_SCRIPTS')
-  ? (() => {
-      require('./tools/WorkflowTool/bundled/index.js').initBundledWorkflows()
-      return require('./tools/WorkflowTool/WorkflowTool.js').WorkflowTool
-    })()
-  : null
-/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-import type { ToolPermissionContext } from './Tool.js'
-import { getDenyRuleForTool } from './utils/permissions/permissions.js'
-import { hasEmbeddedSearchTools } from './utils/embeddedTools.js'
-import { isEnvTruthy } from './utils/envUtils.js'
-import { isPowerShellToolEnabled } from './utils/shell/shellToolUtils.js'
-import { isAgentSwarmsEnabled } from './utils/agentSwarmsEnabled.js'
-import { isWorktreeModeEnabled } from './utils/worktreeModeEnabled.js'
-import {
-  REPL_TOOL_NAME,
-  REPL_ONLY_TOOLS,
-  isReplModeEnabled,
-} from './tools/REPLTool/constants.js'
-export { REPL_ONLY_TOOLS }
-/* eslint-disable @typescript-eslint/no-require-imports */
-const getPowerShellTool = () => {
-  if (!isPowerShellToolEnabled()) return null
-  return (
-    require('./tools/PowerShellTool/PowerShellTool.js') as typeof import('./tools/PowerShellTool/PowerShellTool.js')
-  ).PowerShellTool
-}
-/* eslint-enable @typescript-eslint/no-require-imports */
-
-/**
- * Predefined tool presets that can be used with --tools flag
- */
-export const TOOL_PRESETS = ['default'] as const
-
-export type ToolPreset = (typeof TOOL_PRESETS)[number]
-
-export function parseToolPreset(preset: string): ToolPreset | null {
-  const presetString = preset.toLowerCase()
-  if (!TOOL_PRESETS.includes(presetString as ToolPreset)) {
-    return null
-  }
-  return presetString as ToolPreset
-}
-
-/**
- * Get the list of tool names for a given preset
- * Filters out tools that are disabled via isEnabled() check
- * @param preset The preset name
- * @returns Array of tool names
- */
-export function getToolsForDefaultPreset(): string[] {
-  const tools = getAllBaseTools()
-  const isEnabled = tools.map(tool => tool.isEnabled())
-  return tools.filter((_, i) => isEnabled[i]).map(tool => tool.name)
-}
-
-/**
- * Get the complete exhaustive list of all tools that could be available
- * in the current environment (respecting process.env flags).
- * This is the source of truth for ALL tools.
- */
-/**
- * NOTE: This MUST stay in sync with https://console.statsig.com/4aF3Ewatb6xPVpCwxb5nA3/dynamic_configs/claude_code_global_system_caching, in order to cache the system prompt across users.
- */
-export function getAllBaseTools(): Tools {
-  return [
-    AgentTool,
-    TaskOutputTool,
-    BashTool,
-    // Ant-native builds have bfs/ugrep embedded in the bun binary (same ARGV0
-    // trick as ripgrep). When available, find/grep in Claude's shell are aliased
-    // to these fast tools, so the dedicated Glob/Grep tools are unnecessary.
-    ...(hasEmbeddedSearchTools() ? [] : [GlobTool, GrepTool]),
-    ExitPlanModeV2Tool,
-    FileReadTool,
-    FileEditTool,
-    FileWriteTool,
-    NotebookEditTool,
-    WebFetchTool,
-    TodoWriteTool,
-    WebSearchTool,
-    TaskStopTool,
-    AskUserQuestionTool,
-    SkillTool,
-    EnterPlanModeTool,
-    ...(process.env.USER_TYPE === 'ant' ? [ConfigTool] : []),
-    ...(process.env.USER_TYPE === 'ant' ? [TungstenTool] : []),
-    ...(SuggestBackgroundPRTool ? [SuggestBackgroundPRTool] : []),
-    ...(WebBrowserTool ? [WebBrowserTool] : []),
-    ...(isTodoV2Enabled()
-      ? [TaskCreateTool, TaskGetTool, TaskUpdateTool, TaskListTool]
-      : []),
-    ...(OverflowTestTool ? [OverflowTestTool] : []),
-    ...(CtxInspectTool ? [CtxInspectTool] : []),
-    ...(TerminalCaptureTool ? [TerminalCaptureTool] : []),
-    ...(isEnvTruthy(process.env.ENABLE_LSP_TOOL) ? [LSPTool] : []),
-    ...(isWorktreeModeEnabled() ? [EnterWorktreeTool, ExitWorktreeTool] : []),
-    getSendMessageTool(),
-    ...(ListPeersTool ? [ListPeersTool] : []),
-    ...(isAgentSwarmsEnabled()
-      ? [getTeamCreateTool(), getTeamDeleteTool()]
-      : []),
-    ...(VerifyPlanExecutionTool ? [VerifyPlanExecutionTool] : []),
-    ...(process.env.USER_TYPE === 'ant' && REPLTool ? [REPLTool] : []),
-    ...(WorkflowTool ? [WorkflowTool] : []),
-    ...(SleepTool ? [SleepTool] : []),
-    ...cronTools,
-    ...(RemoteTriggerTool ? [RemoteTriggerTool] : []),
-    ...(MonitorTool ? [MonitorTool] : []),
-    BriefTool,
-    ...(SendUserFileTool ? [SendUserFileTool] : []),
-    ...(PushNotificationTool ? [PushNotificationTool] : []),
-    ...(SubscribePRTool ? [SubscribePRTool] : []),
-    ...(getPowerShellTool() ? [getPowerShellTool()] : []),
-    ...(SnipTool ? [SnipTool] : []),
-    ...(process.env.NODE_ENV === 'test' ? [TestingPermissionTool] : []),
-    ListMcpResourcesTool,
-    ReadMcpResourceTool,
-    // Include ToolSearchTool when tool search might be enabled (optimistic check)
-    // The actual decision to defer tools happens at request time in claude.ts
-    ...(isToolSearchEnabledOptimistic() ? [ToolSearchTool] : []),
-  ]
-}
-
-/**
- * Filters out tools that are blanket-denied by the permission context.
- * A tool is filtered out if there's a deny rule matching its name with no
- * ruleContent (i.e., a blanket deny for that tool).
- *
- * Uses the same matcher as the runtime permission check (step 1a), so MCP
- * server-prefix rules like `mcp__server` strip all tools from that server
- * before the model sees them — not just at call time.
- */
-export function filterToolsByDenyRules<
-  T extends {
-    name: string
-    mcpInfo?: { serverName: string; toolName: string }
-  },
->(tools: readonly T[], permissionContext: ToolPermissionContext): T[] {
-  return tools.filter(tool => !getDenyRuleForTool(permissionContext, tool))
-}
-
-export const getTools = (permissionContext: ToolPermissionContext): Tools => {
-  // Simple mode: only Bash, Read, and Edit tools
-  if (isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)) {
-    // --bare + REPL mode: REPL wraps Bash/Read/Edit/etc inside the VM, so
-    // return REPL instead of the raw primitives. Matches the non-bare path
-    // below which also hides REPL_ONLY_TOOLS when REPL is enabled.
-    if (isReplModeEnabled() && REPLTool) {
-      const replSimple: Tool[] = [REPLTool]
-      if (
-        feature('COORDINATOR_MODE') &&
-        coordinatorModeModule?.isCoordinatorMode()
-      ) {
-        replSimple.push(TaskStopTool, getSendMessageTool())
-      }
-      return filterToolsByDenyRules(replSimple, permissionContext)
-    }
-    const simpleTools: Tool[] = [BashTool, FileReadTool, FileEditTool]
-    // When coordinator mode is also active, include AgentTool and TaskStopTool
-    // so the coordinator gets Task+TaskStop (via useMergedTools filtering) and
-    // workers get Bash/Read/Edit (via filterToolsForAgent filtering).
-    if (
-      feature('COORDINATOR_MODE') &&
-      coordinatorModeModule?.isCoordinatorMode()
-    ) {
-      simpleTools.push(AgentTool, TaskStopTool, getSendMessageTool())
-    }
-    return filterToolsByDenyRules(simpleTools, permissionContext)
-  }
-
-  // Get all base tools and filter out special tools that get added conditionally
-  const specialTools = new Set([
-    ListMcpResourcesTool.name,
-    ReadMcpResourceTool.name,
-    SYNTHETIC_OUTPUT_TOOL_NAME,
-  ])
-
-  const tools = getAllBaseTools().filter(tool => !specialTools.has(tool.name))
-
-  // Filter out tools that are denied by the deny rules
-  let allowedTools = filterToolsByDenyRules(tools, permissionContext)
-
-  // When REPL mode is enabled, hide primitive tools from direct use.
-  // They're still accessible inside REPL via the VM context.
-  if (isReplModeEnabled()) {
-    const replEnabled = allowedTools.some(tool =>
-      toolMatchesName(tool, REPL_TOOL_NAME),
-    )
-    if (replEnabled) {
-      allowedTools = allowedTools.filter(
-        tool => !REPL_ONLY_TOOLS.has(tool.name),
-      )
-    }
-  }
-
-  const isEnabled = allowedTools.map(_ => _.isEnabled())
-  return allowedTools.filter((_, i) => isEnabled[i])
-}
-
-/**
- * Assemble the full tool pool for a given permission context and MCP tools.
- *
- * This is the single source of truth for combining built-in tools with MCP tools.
- * Both REPL.tsx (via useMergedTools hook) and runAgent.ts (for coordinator workers)
- * use this function to ensure consistent tool pool assembly.
- *
- * The function:
- * 1. Gets built-in tools via getTools() (respects mode filtering)
- * 2. Filters MCP tools by deny rules
- * 3. Deduplicates by tool name (built-in tools take precedence)
- *
- * @param permissionContext - Permission context for filtering built-in tools
- * @param mcpTools - MCP tools from appState.mcp.tools
- * @returns Combined, deduplicated array of built-in and MCP tools
- */
-export function assembleToolPool(
-  permissionContext: ToolPermissionContext,
-  mcpTools: Tools,
-): Tools {
-  const builtInTools = getTools(permissionContext)
-
-  // Filter out MCP tools that are in the deny list
-  const allowedMcpTools = filterToolsByDenyRules(mcpTools, permissionContext)
-
-  // Sort each partition for prompt-cache stability, keeping built-ins as a
-  // contiguous prefix. The server's claude_code_system_cache_policy places a
-  // global cache breakpoint after the last prefix-matched built-in tool; a flat
-  // sort would interleave MCP tools into built-ins and invalidate all downstream
-  // cache keys whenever an MCP tool sorts between existing built-ins. uniqBy
-  // preserves insertion order, so built-ins win on name conflict.
-  // Avoid Array.toSorted (Node 20+) — we support Node 18. builtInTools is
-  // readonly so copy-then-sort; allowedMcpTools is a fresh .filter() result.
-  const byName = (a: Tool, b: Tool) => a.name.localeCompare(b.name)
-  return uniqBy(
-    [...builtInTools].sort(byName).concat(allowedMcpTools.sort(byName)),
-    'name',
-  )
-}
-
-/**
- * Get all tools including both built-in tools and MCP tools.
- *
- * This is the preferred function when you need the complete tools list for:
- * - Tool search threshold calculations (isToolSearchEnabled)
- * - Token counting that includes MCP tools
- * - Any context where MCP tools should be considered
- *
- * Use getTools() only when you specifically need just built-in tools.
- *
- * @param permissionContext - Permission context for filtering built-in tools
- * @param mcpTools - MCP tools from appState.mcp.tools
- * @returns Combined array of built-in and MCP tools
- */
-export function getMergedTools(
-  permissionContext: ToolPermissionContext,
-  mcpTools: Tools,
-): Tools {
-  const builtInTools = getTools(permissionContext)
-  return [...builtInTools, ...mcpTools]
-}
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { toolMatchesName, type Tool, type Tools } from './Tool.js'
+import { AgentTool } from './tools/AgentTool/AgentTool.js'
+import { SkillTool } from './tools/SkillTool/SkillTool.js'
+import { BashTool } from './tools/BashTool/BashTool.js'
+import { FileEditTool } from './tools/FileEditTool/FileEditTool.js'
+import { FileReadTool } from './tools/FileReadTool/FileReadTool.js'
+import { FileWriteTool } from './tools/FileWriteTool/FileWriteTool.js'
+import { GlobTool } from './tools/GlobTool/GlobTool.js'
+import { NotebookEditTool } from './tools/NotebookEditTool/NotebookEditTool.js'
+import { WebFetchTool } from './tools/WebFetchTool/WebFetchTool.js'
+import { TaskStopTool } from './tools/TaskStopTool/TaskStopTool.js'
+import { BriefTool } from './tools/BriefTool/BriefTool.js'
+// Dead code elimination: conditional import for ant-only tools
+/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+const REPLTool =
+  process.env.USER_TYPE === 'ant'
+    ? require('./tools/REPLTool/REPLTool.js').REPLTool
+    : null
+const SuggestBackgroundPRTool =
+  process.env.USER_TYPE === 'ant'
+    ? require('./tools/SuggestBackgroundPRTool/SuggestBackgroundPRTool.js')
+        .SuggestBackgroundPRTool
+    : null
+const SleepTool =
+  feature('PROACTIVE') || feature('KAIROS')
+    ? require('./tools/SleepTool/SleepTool.js').SleepTool
+    : null
+const cronTools = feature('AGENT_TRIGGERS')
+  ? [
+      require('./tools/ScheduleCronTool/CronCreateTool.js').CronCreateTool,
+      require('./tools/ScheduleCronTool/CronUpdateTool.js').CronUpdateTool,
+      require('./tools/ScheduleCronTool/CronDeleteTool.js').CronDeleteTool,
+      require('./tools/ScheduleCronTool/CronListTool.js').CronListTool,
+    ]
+  : []
+const RemoteTriggerTool = feature('AGENT_TRIGGERS_REMOTE')
+  ? require('./tools/RemoteTriggerTool/RemoteTriggerTool.js').RemoteTriggerTool
+  : null
+const MonitorTool = feature('MONITOR_TOOL')
+  ? require('./tools/MonitorTool/MonitorTool.js').MonitorTool
+  : null
+const SendUserFileTool = feature('KAIROS')
+  ? require('./tools/SendUserFileTool/SendUserFileTool.js').SendUserFileTool
+  : null
+const PushNotificationTool =
+  feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION')
+    ? require('./tools/PushNotificationTool/PushNotificationTool.js')
+        .PushNotificationTool
+    : null
+const SubscribePRTool = feature('KAIROS_GITHUB_WEBHOOKS')
+  ? require('./tools/SubscribePRTool/SubscribePRTool.js').SubscribePRTool
+  : null
+/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+import { TaskOutputTool } from './tools/TaskOutputTool/TaskOutputTool.js'
+import { WebSearchTool } from './tools/WebSearchTool/WebSearchTool.js'
+import { TodoWriteTool } from './tools/TodoWriteTool/TodoWriteTool.js'
+import { ExitPlanModeV2Tool } from './tools/ExitPlanModeTool/ExitPlanModeV2Tool.js'
+import { TestingPermissionTool } from './tools/testing/TestingPermissionTool.js'
+import { GrepTool } from './tools/GrepTool/GrepTool.js'
+import { TungstenTool } from './tools/TungstenTool/TungstenTool.js'
+// Lazy require to break circular dependency: tools.ts -> TeamCreateTool/TeamDeleteTool -> ... -> tools.ts
+/* eslint-disable @typescript-eslint/no-require-imports */
+const getTeamCreateTool = () =>
+  require('./tools/TeamCreateTool/TeamCreateTool.js')
+    .TeamCreateTool as typeof import('./tools/TeamCreateTool/TeamCreateTool.js').TeamCreateTool
+const getTeamDeleteTool = () =>
+  require('./tools/TeamDeleteTool/TeamDeleteTool.js')
+    .TeamDeleteTool as typeof import('./tools/TeamDeleteTool/TeamDeleteTool.js').TeamDeleteTool
+const getSendMessageTool = () =>
+  require('./tools/SendMessageTool/SendMessageTool.js')
+    .SendMessageTool as typeof import('./tools/SendMessageTool/SendMessageTool.js').SendMessageTool
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { AskUserQuestionTool } from './tools/AskUserQuestionTool/AskUserQuestionTool.js'
+import { LSPTool } from './tools/LSPTool/LSPTool.js'
+import { ListMcpResourcesTool } from './tools/ListMcpResourcesTool/ListMcpResourcesTool.js'
+import { ReadMcpResourceTool } from './tools/ReadMcpResourceTool/ReadMcpResourceTool.js'
+import { ToolSearchTool } from './tools/ToolSearchTool/ToolSearchTool.js'
+import { EnterPlanModeTool } from './tools/EnterPlanModeTool/EnterPlanModeTool.js'
+import { EnterWorktreeTool } from './tools/EnterWorktreeTool/EnterWorktreeTool.js'
+import { ExitWorktreeTool } from './tools/ExitWorktreeTool/ExitWorktreeTool.js'
+import { ConfigTool } from './tools/ConfigTool/ConfigTool.js'
+import { TaskCreateTool } from './tools/TaskCreateTool/TaskCreateTool.js'
+import { TaskGetTool } from './tools/TaskGetTool/TaskGetTool.js'
+import { TaskUpdateTool } from './tools/TaskUpdateTool/TaskUpdateTool.js'
+import { TaskListTool } from './tools/TaskListTool/TaskListTool.js'
+import uniqBy from 'lodash-es/uniqBy.js'
+import { isToolSearchEnabledOptimistic } from './utils/toolSearch.js'
+import { isTodoV2Enabled } from './utils/tasks.js'
+// Dead code elimination: conditional import for CLAUDE_CODE_VERIFY_PLAN
+/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+const VerifyPlanExecutionTool =
+  process.env.CLAUDE_CODE_VERIFY_PLAN === 'true'
+    ? require('./tools/VerifyPlanExecutionTool/VerifyPlanExecutionTool.js')
+        .VerifyPlanExecutionTool
+    : null
+/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+import { SYNTHETIC_OUTPUT_TOOL_NAME } from './tools/SyntheticOutputTool/SyntheticOutputTool.js'
+export {
+  ALL_AGENT_DISALLOWED_TOOLS,
+  CUSTOM_AGENT_DISALLOWED_TOOLS,
+  ASYNC_AGENT_ALLOWED_TOOLS,
+  COORDINATOR_MODE_ALLOWED_TOOLS,
+} from './constants/tools.js'
+import { feature } from 'bun:bundle'
+// Dead code elimination: conditional import for OVERFLOW_TEST_TOOL
+/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+const OverflowTestTool = feature('OVERFLOW_TEST_TOOL')
+  ? require('./tools/OverflowTestTool/OverflowTestTool.js').OverflowTestTool
+  : null
+const CtxInspectTool = feature('CONTEXT_COLLAPSE')
+  ? require('./tools/CtxInspectTool/CtxInspectTool.js').CtxInspectTool
+  : null
+const TerminalCaptureTool = feature('TERMINAL_PANEL')
+  ? require('./tools/TerminalCaptureTool/TerminalCaptureTool.js')
+      .TerminalCaptureTool
+  : null
+const WebBrowserTool = feature('WEB_BROWSER_TOOL')
+  ? require('./tools/WebBrowserTool/WebBrowserTool.js').WebBrowserTool
+  : null
+const coordinatorModeModule = feature('COORDINATOR_MODE')
+  ? (require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js'))
+  : null
+const SnipTool = feature('HISTORY_SNIP')
+  ? require('./tools/SnipTool/SnipTool.js').SnipTool
+  : null
+const ListPeersTool = feature('UDS_INBOX')
+  ? require('./tools/ListPeersTool/ListPeersTool.js').ListPeersTool
+  : null
+const WorkflowTool = feature('WORKFLOW_SCRIPTS')
+  ? (() => {
+      require('./tools/WorkflowTool/bundled/index.js').initBundledWorkflows()
+      return require('./tools/WorkflowTool/WorkflowTool.js').WorkflowTool
+    })()
+  : null
+/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+import type { ToolPermissionContext } from './Tool.js'
+import { getDenyRuleForTool } from './utils/permissions/permissions.js'
+import { hasEmbeddedSearchTools } from './utils/embeddedTools.js'
+import { isEnvTruthy } from './utils/envUtils.js'
+import { isPowerShellToolEnabled } from './utils/shell/shellToolUtils.js'
+import { isAgentSwarmsEnabled } from './utils/agentSwarmsEnabled.js'
+import { isWorktreeModeEnabled } from './utils/worktreeModeEnabled.js'
+import {
+  REPL_TOOL_NAME,
+  REPL_ONLY_TOOLS,
+  isReplModeEnabled,
+} from './tools/REPLTool/constants.js'
+export { REPL_ONLY_TOOLS }
+/* eslint-disable @typescript-eslint/no-require-imports */
+const getPowerShellTool = () => {
+  if (!isPowerShellToolEnabled()) return null
+  return (
+    require('./tools/PowerShellTool/PowerShellTool.js') as typeof import('./tools/PowerShellTool/PowerShellTool.js')
+  ).PowerShellTool
+}
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+/**
+ * Predefined tool presets that can be used with --tools flag
+ */
+export const TOOL_PRESETS = ['default'] as const
+
+export type ToolPreset = (typeof TOOL_PRESETS)[number]
+
+export function parseToolPreset(preset: string): ToolPreset | null {
+  const presetString = preset.toLowerCase()
+  if (!TOOL_PRESETS.includes(presetString as ToolPreset)) {
+    return null
+  }
+  return presetString as ToolPreset
+}
+
+/**
+ * Get the list of tool names for a given preset
+ * Filters out tools that are disabled via isEnabled() check
+ * @param preset The preset name
+ * @returns Array of tool names
+ */
+export function getToolsForDefaultPreset(): string[] {
+  const tools = getAllBaseTools()
+  const isEnabled = tools.map(tool => tool.isEnabled())
+  return tools.filter((_, i) => isEnabled[i]).map(tool => tool.name)
+}
+
+/**
+ * Get the complete exhaustive list of all tools that could be available
+ * in the current environment (respecting process.env flags).
+ * This is the source of truth for ALL tools.
+ */
+/**
+ * NOTE: This MUST stay in sync with https://console.statsig.com/4aF3Ewatb6xPVpCwxb5nA3/dynamic_configs/claude_code_global_system_caching, in order to cache the system prompt across users.
+ */
+export function getAllBaseTools(): Tools {
+  return [
+    AgentTool,
+    TaskOutputTool,
+    BashTool,
+    // Ant-native builds have bfs/ugrep embedded in the bun binary (same ARGV0
+    // trick as ripgrep). When available, find/grep in Claude's shell are aliased
+    // to these fast tools, so the dedicated Glob/Grep tools are unnecessary.
+    ...(hasEmbeddedSearchTools() ? [] : [GlobTool, GrepTool]),
+    ExitPlanModeV2Tool,
+    FileReadTool,
+    FileEditTool,
+    FileWriteTool,
+    NotebookEditTool,
+    WebFetchTool,
+    TodoWriteTool,
+    WebSearchTool,
+    TaskStopTool,
+    AskUserQuestionTool,
+    SkillTool,
+    EnterPlanModeTool,
+    ...(process.env.USER_TYPE === 'ant' ? [ConfigTool] : []),
+    ...(process.env.USER_TYPE === 'ant' ? [TungstenTool] : []),
+    ...(SuggestBackgroundPRTool ? [SuggestBackgroundPRTool] : []),
+    ...(WebBrowserTool ? [WebBrowserTool] : []),
+    ...(isTodoV2Enabled()
+      ? [TaskCreateTool, TaskGetTool, TaskUpdateTool, TaskListTool]
+      : []),
+    ...(OverflowTestTool ? [OverflowTestTool] : []),
+    ...(CtxInspectTool ? [CtxInspectTool] : []),
+    ...(TerminalCaptureTool ? [TerminalCaptureTool] : []),
+    ...(isEnvTruthy(process.env.ENABLE_LSP_TOOL) ? [LSPTool] : []),
+    ...(isWorktreeModeEnabled() ? [EnterWorktreeTool, ExitWorktreeTool] : []),
+    getSendMessageTool(),
+    ...(ListPeersTool ? [ListPeersTool] : []),
+    ...(isAgentSwarmsEnabled()
+      ? [getTeamCreateTool(), getTeamDeleteTool()]
+      : []),
+    ...(VerifyPlanExecutionTool ? [VerifyPlanExecutionTool] : []),
+    ...(process.env.USER_TYPE === 'ant' && REPLTool ? [REPLTool] : []),
+    ...(WorkflowTool ? [WorkflowTool] : []),
+    ...(SleepTool ? [SleepTool] : []),
+    ...cronTools,
+    ...(RemoteTriggerTool ? [RemoteTriggerTool] : []),
+    ...(MonitorTool ? [MonitorTool] : []),
+    BriefTool,
+    ...(SendUserFileTool ? [SendUserFileTool] : []),
+    ...(PushNotificationTool ? [PushNotificationTool] : []),
+    ...(SubscribePRTool ? [SubscribePRTool] : []),
+    ...(getPowerShellTool() ? [getPowerShellTool()] : []),
+    ...(SnipTool ? [SnipTool] : []),
+    ...(process.env.NODE_ENV === 'test' ? [TestingPermissionTool] : []),
+    ListMcpResourcesTool,
+    ReadMcpResourceTool,
+    // Include ToolSearchTool when tool search might be enabled (optimistic check)
+    // The actual decision to defer tools happens at request time in claude.ts
+    ...(isToolSearchEnabledOptimistic() ? [ToolSearchTool] : []),
+  ]
+}
+
+/**
+ * Filters out tools that are blanket-denied by the permission context.
+ * A tool is filtered out if there's a deny rule matching its name with no
+ * ruleContent (i.e., a blanket deny for that tool).
+ *
+ * Uses the same matcher as the runtime permission check (step 1a), so MCP
+ * server-prefix rules like `mcp__server` strip all tools from that server
+ * before the model sees them — not just at call time.
+ */
+export function filterToolsByDenyRules<
+  T extends {
+    name: string
+    mcpInfo?: { serverName: string; toolName: string }
+  },
+>(tools: readonly T[], permissionContext: ToolPermissionContext): T[] {
+  return tools.filter(tool => !getDenyRuleForTool(permissionContext, tool))
+}
+
+export const getTools = (permissionContext: ToolPermissionContext, brainMode?: boolean): Tools => {
+  // Brain mode: coordinator only needs Agent + AskUserQuestion
+  if (brainMode) {
+    return filterToolsByDenyRules([AgentTool, AskUserQuestionTool], permissionContext)
+  }
+
+  // Simple mode: only Bash, Read, and Edit tools
+  if (isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)) {
+    // --bare + REPL mode: REPL wraps Bash/Read/Edit/etc inside the VM, so
+    // return REPL instead of the raw primitives. Matches the non-bare path
+    // below which also hides REPL_ONLY_TOOLS when REPL is enabled.
+    if (isReplModeEnabled() && REPLTool) {
+      const replSimple: Tool[] = [REPLTool]
+      if (
+        feature('COORDINATOR_MODE') &&
+        coordinatorModeModule?.isCoordinatorMode()
+      ) {
+        replSimple.push(TaskStopTool, getSendMessageTool())
+      }
+      return filterToolsByDenyRules(replSimple, permissionContext)
+    }
+    const simpleTools: Tool[] = [BashTool, FileReadTool, FileEditTool]
+    // When coordinator mode is also active, include AgentTool and TaskStopTool
+    // so the coordinator gets Task+TaskStop (via useMergedTools filtering) and
+    // workers get Bash/Read/Edit (via filterToolsForAgent filtering).
+    if (
+      feature('COORDINATOR_MODE') &&
+      coordinatorModeModule?.isCoordinatorMode()
+    ) {
+      simpleTools.push(AgentTool, TaskStopTool, getSendMessageTool())
+    }
+    return filterToolsByDenyRules(simpleTools, permissionContext)
+  }
+
+  // Get all base tools and filter out special tools that get added conditionally
+  const specialTools = new Set([
+    ListMcpResourcesTool.name,
+    ReadMcpResourceTool.name,
+    SYNTHETIC_OUTPUT_TOOL_NAME,
+  ])
+
+  const tools = getAllBaseTools().filter(tool => !specialTools.has(tool.name))
+
+  // Filter out tools that are denied by the deny rules
+  let allowedTools = filterToolsByDenyRules(tools, permissionContext)
+
+  // When REPL mode is enabled, hide primitive tools from direct use.
+  // They're still accessible inside REPL via the VM context.
+  if (isReplModeEnabled()) {
+    const replEnabled = allowedTools.some(tool =>
+      toolMatchesName(tool, REPL_TOOL_NAME),
+    )
+    if (replEnabled) {
+      allowedTools = allowedTools.filter(
+        tool => !REPL_ONLY_TOOLS.has(tool.name),
+      )
+    }
+  }
+
+  const isEnabled = allowedTools.map(_ => _.isEnabled())
+  return allowedTools.filter((_, i) => isEnabled[i])
+}
+
+/**
+ * Assemble the full tool pool for a given permission context and MCP tools.
+ *
+ * This is the single source of truth for combining built-in tools with MCP tools.
+ * Both REPL.tsx (via useMergedTools hook) and runAgent.ts (for coordinator workers)
+ * use this function to ensure consistent tool pool assembly.
+ *
+ * The function:
+ * 1. Gets built-in tools via getTools() (respects mode filtering)
+ * 2. Filters MCP tools by deny rules
+ * 3. Deduplicates by tool name (built-in tools take precedence)
+ *
+ * @param permissionContext - Permission context for filtering built-in tools
+ * @param mcpTools - MCP tools from appState.mcp.tools
+ * @returns Combined, deduplicated array of built-in and MCP tools
+ */
+export function assembleToolPool(
+  permissionContext: ToolPermissionContext,
+  mcpTools: Tools,
+  brainMode?: boolean,
+): Tools {
+  const effectiveBrainMode = brainMode ?? false
+  const builtInTools = getTools(permissionContext, effectiveBrainMode)
+
+  // When brainMode is active, skip MCP tools entirely
+  const filteredMcpTools = effectiveBrainMode ? [] : filterToolsByDenyRules(mcpTools, permissionContext)
+
+  // Sort each partition for prompt-cache stability, keeping built-ins as a
+  // contiguous prefix. The server's claude_code_system_cache_policy places a
+  // global cache breakpoint after the last prefix-matched built-in tool; a flat
+  // sort would interleave MCP tools into built-ins and invalidate all downstream
+  // cache keys whenever an MCP tool sorts between existing built-ins. uniqBy
+  // preserves insertion order, so built-ins win on name conflict.
+  // Avoid Array.toSorted (Node 20+) — we support Node 18. builtInTools is
+  // readonly so copy-then-sort; filteredMcpTools is a fresh .filter() result.
+  const byName = (a: Tool, b: Tool) => a.name.localeCompare(b.name)
+  return uniqBy(
+    [...builtInTools].sort(byName).concat(filteredMcpTools.sort(byName)),
+    'name',
+  )
+}
+
+/**
+ * Get all tools including both built-in tools and MCP tools.
+ *
+ * This is the preferred function when you need the complete tools list for:
+ * - Tool search threshold calculations (isToolSearchEnabled)
+ * - Token counting that includes MCP tools
+ * - Any context where MCP tools should be considered
+ *
+ * Use getTools() only when you specifically need just built-in tools.
+ *
+ * @param permissionContext - Permission context for filtering built-in tools
+ * @param mcpTools - MCP tools from appState.mcp.tools
+ * @returns Combined array of built-in and MCP tools
+ */
+export function getMergedTools(
+  permissionContext: ToolPermissionContext,
+  mcpTools: Tools,
+): Tools {
+  const builtInTools = getTools(permissionContext)
+  return [...builtInTools, ...mcpTools]
+}