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

AGENTS.md

@@ -74,7 +74,7 @@ bun run web:typecheck
 bun run web:build
 ```
 
-Website release notes live on GitHub Releases; do not add a manually maintained release-notes data source to the static site.
+Do not “fix” a web CI npm-freshness failure by editing `web/src/data/releases.ts` in an unrelated PR. That file is release/web-owned; leave version drift for the dedicated release/web path.
 
 Diagnostics and PR hygiene:
 
@@ -101,4 +101,4 @@ When modifying provider behavior:
 - Do not skip tests for behavior changes.
 - Do not silently change provider tags; maintainers control them during review.
 - Do not ignore CodeRabbit or maintainer feedback; address it before requesting more review.
-- Do not add a manually maintained release-notes data source to the static site; link to GitHub Releases instead.
+- Do not edit `web/src/data/releases.ts` in ordinary feature or bugfix PRs. That curated `/changelog` list is owned by the release/web process (release automation and dedicated web release PRs). If web CI fails because npm is ahead of the site version, leave `releases.ts` alone in your unrelated PR and let the release/web path update it.

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`, `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,8 +90,8 @@ 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
+`verification` (the read-only auditor that runs before completion), `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. Absent
 any entry, the verifier inherits the main-loop model.
 

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}`));