fix(code-reviewer): require inline diff input and preserve read-only search in embedded-search builds

README.md

@@ -349,15 +349,18 @@ OpenClaude supports multiple providers, but behavior is not identical across all
 
 For best results, use models with strong tool/function calling support.
 
+
+
 ## Agents
 
 Route different agents to different models (cost optimization, splitting work
 by model strength), cap sub-agent tool steps with `maxSteps`, and tune GitHub
-Copilot sub-agent behavior. All settings-driven:
+Copilot sub-agent behavior. Configured via settings, agent frontmatter, and
+environment variables:
 
-- per-agent provider/model overrides via `agentModels` + `agentRouting` in `~/.openclaude.json`
+- per-agent provider/model overrides via `agentModels` + `agentRouting` in `~/.openclaude/settings.json`
 - model-only routes that reuse your current provider's credentials
-- built-in agents (`Explore`, `Plan`, `verification`) routable by type name
+- built-in agents (`Explore` and `Plan` [feature-gated], `verification` [feature-gated: requires `VERIFICATION_AGENT` + `tengu_hive_evidence`], `code-reviewer` [requires diff inline]) routable by type name
 
 See [Agent Routing and Step Limits](docs/agent-routing.md) for the full guide.
 

docs/agent-routing.md

@@ -29,7 +29,9 @@ OpenClaude can route different agents to different models through
 settings-based routing. This is useful for cost optimization or splitting work
 by model strength.
 
-Add to `~/.openclaude.json`:
+Add to `~/.openclaude/settings.json`:
+
+> **Note:** `api_key` values in `settings.json` are stored in plaintext. Keep this file private and do not commit it to version control.
 
 ```json
 {
@@ -88,9 +90,9 @@ no credential duplication:
 ```
 
 **Built-in agents are routable by their type name.** Useful keys:
-`verification` (the read-only auditor that runs before completion), `Explore`,
-and `Plan`. For example, `"agentRouting": { "verification": "mini" }` runs the
-verifier on `gpt-5-mini` while your main session stays on its model. Absent
+`verification` (the read-only auditor that runs before completion; **feature-gated**: requires `VERIFICATION_AGENT` and `tengu_hive_evidence` flag), `Explore`
+and `Plan` (if feature-gated on), and `code-reviewer` (requires diff inline). For example, `"agentRouting": { "verification": "mini" }` runs the
+verifier on `gpt-5-mini` while your main session stays on its model, but only when the verification gate is active. Absent
 any entry, the verifier inherits the main-loop model.
 
 ## GitHub Copilot sub-agent optimization

src/services/api/openaiShim/requestExecutor.integration.test.ts

@@ -1483,7 +1483,6 @@ test('OpenGateway MiMo replays real reasoning_content without adding empty fallb
             input: {
               description: 'Inspect code',
               prompt: 'Look at the relevant code',
-              subagent_type: 'general-purpose',
             },
           },
         ],
@@ -1566,7 +1565,6 @@ test('Xiaomi MiMo replays real reasoning_content without adding empty fallback',
             input: {
               description: 'Inspect code',
               prompt: 'Look at the relevant code',
-              subagent_type: 'general-purpose',
             },
           },
         ],
@@ -1643,7 +1641,6 @@ test('OpenGateway MiMo does not synthesize empty reasoning_content when missing'
             input: {
               description: 'Inspect code',
               prompt: 'Look at the relevant code',
-              subagent_type: 'general-purpose',
             },
           },
         ],

src/skills/bundled/batch.ts

@@ -71,7 +71,7 @@ For each agent, the prompt must be fully self-contained. Include:
 ${WORKER_INSTRUCTIONS}
 \`\`\`
 
-Use \`subagent_type: "general-purpose"\` unless a more specific agent type fits.
+Use a specific custom agent type if one fits the work unit, or \`subagent_type: "general-purpose"\` for default workers. Do NOT omit \`subagent_type\` — batch requires fresh, isolated subprocesses, and omitting the type routes to a fork (which inherits the coordinator's context) when the fork gate is on, which breaks the self-contained worktree invariant.
 
 ## Phase 3: Track Progress
 

src/tools/AgentTool/AgentTool.routing.test.ts

@@ -77,7 +77,6 @@ test('normal subagent prompt metadata uses routed effective model', async () =>
     {
       description: 'Inspect implementation',
       prompt: 'Find the bug',
-      subagent_type: 'general-purpose',
     },
     createToolUseContext('parent-model', [createAgentDefinition()]),
     mock(async () => ({ behavior: 'allow' })) as never,
@@ -124,7 +123,6 @@ test('agent invocation entering plan mode during MCP wait stays synchronous', as
     {
       description: 'Inspect implementation',
       prompt: 'Find the bug',
-      subagent_type: 'general-purpose',
     },
     createToolUseContext('parent-model', [agent], 'default', 'plan'),
     mock(async () => ({ behavior: 'allow' })) as never,
@@ -193,7 +191,6 @@ test('sync agents forward long-running tool progress to the parent tool call', a
     {
       description: 'Inspect implementation',
       prompt: 'Find the bug',
-      subagent_type: 'general-purpose',
     },
     createToolUseContext('parent-model', [createAgentDefinition()]),
     mock(async () => ({ behavior: 'allow' })) as never,
@@ -236,7 +233,6 @@ test('a throwing parent progress consumer does not change the subagent outcome',
     {
       description: 'Inspect implementation',
       prompt: 'Find the bug',
-      subagent_type: 'general-purpose',
     },
     createToolUseContext('parent-model', [createAgentDefinition()]),
     mock(async () => ({ behavior: 'allow' })) as never,

src/tools/AgentTool/AgentTool.teammateModel.test.ts

@@ -127,6 +127,7 @@ async function importAgentToolWithSpawnMock(): Promise<{
 function makeToolUseContext(options: {
   mainLoopModel?: string
   activeAgents?: AgentDefinition[]
+  allAgents?: AgentDefinition[]
 } = {}): ToolUseContext {
   const appState = {
     toolPermissionContext: { mode: 'default' },
@@ -146,7 +147,7 @@ function makeToolUseContext(options: {
       isNonInteractiveSession: false,
       agentDefinitions: {
         activeAgents: options.activeAgents ?? [],
-        allAgents: options.activeAgents ?? [],
+        allAgents: options.allAgents ?? options.activeAgents ?? [],
       },
     },
     abortController: new AbortController(),
@@ -191,6 +192,7 @@ function callTeammateAgentTool(
   contextOptions: {
     mainLoopModel?: string
     activeAgents?: AgentDefinition[]
+    allAgents?: AgentDefinition[]
   } = {},
 ): ReturnType<typeof AgentTool.call> {
   return AgentTool.call(
@@ -272,16 +274,16 @@ test('passes routed agentModels keys to teammate spawns by subagent type', async
       },
     },
     agentRouting: {
-      'general-purpose': 'deepseek-grunt',
+      'custom-helper': 'deepseek-grunt',
     },
   } as unknown as SettingsJson
   allowedModelsForTest = new Set(['deepseek-grunt'])
   const { AgentTool, spawnTeammate } = await importAgentToolWithSpawnMock()
 
   await callTeammateAgentTool(
     AgentTool,
-    { subagent_type: 'general-purpose' },
-    { activeAgents: [createAgentDefinition('general-purpose')] },
+    { subagent_type: 'custom-helper' },
+    { activeAgents: [createAgentDefinition('custom-helper')] },
   )
 
   expect(getSpawnConfig(spawnTeammate).model).toBe('deepseek-grunt')
@@ -300,16 +302,16 @@ test('applies a model-only route to a teammate spawn without a cross-provider ov
       mini: { model: 'gpt-5-mini' },
     },
     agentRouting: {
-      verification: 'mini',
+      'custom-researcher': 'mini',
     },
   } as unknown as SettingsJson
   allowedModelsForTest = new Set(['gpt-5-mini'])
   const { AgentTool, spawnTeammate } = await importAgentToolWithSpawnMock()
 
   await callTeammateAgentTool(
     AgentTool,
-    { subagent_type: 'verification' },
-    { activeAgents: [createAgentDefinition('verification')] },
+    { subagent_type: 'custom-researcher' },
+    { activeAgents: [createAgentDefinition('custom-researcher')] },
   )
 
   expect(getSpawnConfig(spawnTeammate).model).toBe('gpt-5-mini')
@@ -383,9 +385,9 @@ test('does not let non-configured explicit teammate models fall through to defau
     AgentTool,
     {
       model: 'custom-provider-model',
-      subagent_type: 'general-purpose',
+      subagent_type: 'custom-helper',
     },
-    { activeAgents: [createAgentDefinition('general-purpose')] },
+    { activeAgents: [createAgentDefinition('custom-helper')] },
   )
 
   expect(getSpawnConfig(spawnTeammate).model).toBe('custom-provider-model')
@@ -401,19 +403,104 @@ test('rejects disallowed routed provider models before spawning a teammate', asy
       },
     },
     agentRouting: {
-      'general-purpose': 'deepseek-grunt',
+      'custom-helper': 'deepseek-grunt',
     },
   } as unknown as SettingsJson
   const { AgentTool, spawnTeammate } = await importAgentToolWithSpawnMock()
 
   await expect(
     callTeammateAgentTool(
       AgentTool,
-      { subagent_type: 'general-purpose' },
-      { activeAgents: [createAgentDefinition('general-purpose')] },
+      { subagent_type: 'custom-helper' },
+      { activeAgents: [createAgentDefinition('custom-helper')] },
     ),
   ).rejects.toThrow(
     "Model 'deepseek-grunt' is not available. Your organization restricts model selection.",
   )
   expect(spawnTeammate).not.toHaveBeenCalled()
 })
+
+test('rejects built-in agents from being spawned as teammates', async () => {
+  const { AgentTool, spawnTeammate } = await importAgentToolWithSpawnMock()
+
+  const builtinAgent = {
+    agentType: 'code-reviewer',
+    source: 'built-in',
+    getSystemPrompt: () => 'review code',
+  } as unknown as AgentDefinition
+
+  await expect(
+    callTeammateAgentTool(
+      AgentTool,
+      { subagent_type: 'code-reviewer' },
+      { activeAgents: [builtinAgent] },
+    ),
+  ).rejects.toThrow(
+    "Built-in agent type 'code-reviewer' cannot be spawned as a teammate. Please omit name and team_name to use it as a standard subagent.",
+  )
+  expect(spawnTeammate).not.toHaveBeenCalled()
+})
+
+test('rejects built-in agents from being spawned as teammates even when built-ins are disabled', async () => {
+  const { AgentTool, spawnTeammate } = await importAgentToolWithSpawnMock()
+
+  const prevEnv = process.env.CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS
+  process.env.CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS = '1'
+  const { setIsInteractive, getIsNonInteractiveSession } = await import('../../bootstrap/state.js')
+  const { getAgentDefinitionsWithOverrides, clearAgentDefinitionsCache } = await import('./loadAgentsDir.js')
+
+  const prevInteractive = !getIsNonInteractiveSession()
+  setIsInteractive(false)
+  clearAgentDefinitionsCache()
+
+  try {
+    const definitions = await getAgentDefinitionsWithOverrides()
+
+    await expect(
+      callTeammateAgentTool(
+        AgentTool,
+        { subagent_type: 'code-reviewer' },
+        { activeAgents: definitions.activeAgents, allAgents: definitions.allAgents },
+      ),
+    ).rejects.toThrow(
+      "Built-in agent type 'code-reviewer' cannot be spawned as a teammate. Please omit name and team_name to use it as a standard subagent.",
+    )
+
+    await expect(
+      callTeammateAgentTool(
+        AgentTool,
+        { subagent_type: 'claude-code-guide' },
+        { activeAgents: definitions.activeAgents, allAgents: definitions.allAgents },
+      ),
+    ).rejects.toThrow(
+      "Built-in agent type 'claude-code-guide' cannot be spawned as a teammate. Please omit name and team_name to use it as a standard subagent.",
+    )
+    expect(spawnTeammate).not.toHaveBeenCalled()
+  } finally {
+    setIsInteractive(prevInteractive)
+    if (prevEnv !== undefined) {
+      process.env.CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS = prevEnv
+    } else {
+      delete process.env.CLAUDE_AGENT_SDK_DISABLE_BUILTIN_AGENTS
+    }
+    clearAgentDefinitionsCache()
+  }
+
+})
+
+test('allows a custom agent to be spawned as a teammate even if it shadows a built-in name', async () => {
+  const { AgentTool, spawnTeammate } = await importAgentToolWithSpawnMock()
+
+  const customShadowAgent = {
+    agentType: 'code-reviewer',
+    source: 'projectSettings', // It shadows the name but has a different source
+  } as unknown as AgentDefinition
+
+  await callTeammateAgentTool(
+    AgentTool,
+    { subagent_type: 'code-reviewer' },
+    { activeAgents: [customShadowAgent] },
+  )
+
+  expect(spawnTeammate).toHaveBeenCalled()
+})

src/tools/AgentTool/AgentTool.tsx

@@ -16,6 +16,7 @@ import { clearDumpState } from '../../services/api/dumpPrompts.js';
 import { resolveAgentRunModelRouting, resolveOutOfProcessTeammateProvider, resolveOutOfProcessTeammateModelOnly } from '../../services/api/agentRouting.js';
 import { completeAgentTask as completeAsyncAgent, createActivityDescriptionResolver, createProgressTracker, enqueueAgentNotification, failAgentTask as failAsyncAgent, getProgressUpdate, getTokenCountFromTracker, isLocalAgentTask, killAsyncAgent, registerAgentForeground, registerAsyncAgent, unregisterAgentForeground, updateAgentProgress as updateAsyncAgentProgress, updateProgressFromMessage } from '../../tasks/LocalAgentTask/LocalAgentTask.js';
 import { assembleToolPool } from '../../tools.js';
+import { isBuiltInAgentType } from './builtInAgents.js';
 import { asAgentId } from '../../types/ids.js';
 import { runWithAgentContext } from '../../utils/agentContext.js';
 import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js';
@@ -374,6 +375,17 @@ export const AgentTool = buildTool({
     if (teamName && name) {
       // Set agent definition color for grouped UI display before spawning
       const agentDef = subagent_type ? toolUseContext.options.agentDefinitions.activeAgents.find(a => a.agentType === subagent_type) : undefined;
+
+      if (subagent_type) {
+        if (agentDef) {
+          if (agentDef.source === 'built-in') {
+            throw new Error(`Built-in agent type '${subagent_type}' cannot be spawned as a teammate. Please omit name and team_name to use it as a standard subagent.`);
+          }
+        } else if (isBuiltInAgentType(subagent_type)) {
+          throw new Error(`Built-in agent type '${subagent_type}' cannot be spawned as a teammate. Please omit name and team_name to use it as a standard subagent.`);
+        }
+      }
+
       if (agentDef?.color) {
         setAgentColor(subagent_type!, agentDef.color);
       }
@@ -849,6 +861,7 @@ export const AgentTool = buildTool({
           // present so resume can still land in the target repository.
           void writeAgentMetadata(asAgentId(earlyAgentId), {
             agentType: selectedAgent.agentType,
+            source: selectedAgent.source,
             ...(cwd && { cwd }),
             ...(description && { description }),
           }).catch(_err => logForDebugging(`Failed to clear worktree metadata: ${_err}`));