fix: align codebase search readiness across mode filters

src/__tests__/extension.spec.ts

@@ -139,8 +139,8 @@ vi.mock("../services/mcp/McpServerManager", () => ({
 	},
 }))
 
-vi.mock("../services/code-index/manager", () => ({
-	CodeIndexManager: {
+vi.mock("../services/code-index/code-index-manager-registry", () => ({
+	CodeIndexManagerRegistry: {
 		getInstance: vi.fn().mockReturnValue(null),
 	},
 }))

src/activate/__tests__/registerCommands.spec.ts

@@ -67,8 +67,8 @@ vi.mock("../../core/config/importExport", () => ({
 	importSettingsWithFeedback: vi.fn(),
 }))
 
-vi.mock("../../services/code-index/manager", () => ({
-	CodeIndexManager: {
+vi.mock("../../services/code-index/code-index-manager-registry", () => ({
+	CodeIndexManagerRegistry: {
 		getInstance: vi.fn(),
 	},
 }))

src/activate/registerCommands.ts

@@ -10,7 +10,7 @@ import { ClineProvider } from "../core/webview/ClineProvider"
 import { ContextProxy } from "../core/config/ContextProxy"
 import { focusPanel } from "../utils/focusPanel"
 import { handleNewTask } from "./handleTask"
-import { CodeIndexManager } from "../services/code-index/manager"
+import { CodeIndexManagerRegistry } from "../services/code-index/code-index-manager-registry"
 import { importSettingsWithFeedback } from "../core/config/importExport"
 import { MdmService } from "../services/mdm/MdmService"
 import { registerRipgrepDiagnosticCommand } from "../services/ripgrep/diagnostic"
@@ -227,7 +227,7 @@ export const openClineInNewTab = async ({ context, outputChannel }: Omit<Registe
 	// don't need to use that event).
 	// https://github.com/microsoft/vscode-extension-samples/blob/main/webview-sample/src/extension.ts
 	const contextProxy = await ContextProxy.getInstance(context)
-	const codeIndexManager = CodeIndexManager.getInstance(context)
+	const codeIndexManager = CodeIndexManagerRegistry.getInstance(context)
 
 	// Get the existing MDM service instance to ensure consistent policy enforcement
 	let mdmService: MdmService | undefined

src/core/prompts/system.ts

@@ -8,7 +8,7 @@ import { formatLanguage } from "../../shared/language"
 import { isEmpty } from "../../utils/object"
 
 import { McpHub } from "../../services/mcp/McpHub"
-import { CodeIndexManager } from "../../services/code-index/manager"
+import { CodeIndexManagerRegistry } from "../../services/code-index/code-index-manager-registry"
 import { SkillsManager } from "../../services/skills/SkillsManager"
 
 import type { SystemPromptSettings } from "./types"
@@ -79,7 +79,7 @@ async function generatePrompt(
 	}
 	const shouldIncludeMcp = hasMcpGroup && hasMcpServers
 
-	const codeIndexManager = CodeIndexManager.getInstance(context, cwd)
+	const codeIndexManager = CodeIndexManagerRegistry.getInstance(context, cwd)
 
 	// Tool calling is native-only.
 	const effectiveProtocol = "native"

src/core/prompts/tools/__tests__/codebase-search-readiness.spec.ts

@@ -0,0 +1,89 @@
+import type OpenAI from "openai"
+import type { ModeConfig } from "@roo-code/types"
+import type { CodeIndexManager } from "../../../../services/code-index/manager"
+import { filterNativeToolsForMode, getAvailableToolsInGroup, isToolAllowedInMode } from "../filter-tools-for-mode"
+
+type Readiness = Pick<CodeIndexManager, "isFeatureEnabled" | "isFeatureConfigured" | "isInitialized">
+
+function makeManager(flags: Readiness): CodeIndexManager {
+	// These filters only read the three public readiness getters; no manager services are needed.
+	return flags as CodeIndexManager
+}
+
+const ready = { isFeatureEnabled: true, isFeatureConfigured: true, isInitialized: true }
+const nativeTools: OpenAI.Chat.ChatCompletionTool[] = [
+	"codebase_search",
+	"read_file",
+	"list_files",
+	"search_files",
+].map((name) => ({ type: "function", function: { name, parameters: { type: "object", properties: {} } } }))
+const noReadMode: ModeConfig = { slug: "no-read", name: "No read", roleDefinition: "No reading", groups: ["command"] }
+
+function checkAvailability(
+	manager: CodeIndexManager | undefined,
+	expected: boolean,
+	mode = "code",
+	settings: { disabledTools?: string[] } = {},
+) {
+	const names = filterNativeToolsForMode(nativeTools, mode, [noReadMode], {}, manager, settings).flatMap((tool) =>
+		"function" in tool ? [tool.function.name] : [],
+	)
+	const group = getAvailableToolsInGroup("read", mode, [noReadMode], {}, manager, settings)
+	expect(names.includes("codebase_search")).toBe(expected)
+	expect(isToolAllowedInMode("codebase_search", mode, [noReadMode], {}, manager, settings)).toBe(expected)
+	expect(group.includes("codebase_search")).toBe(expected)
+	for (const tool of ["read_file", "list_files", "search_files"] as const) {
+		expect(names.includes(tool)).toBe(mode === "code")
+		expect(isToolAllowedInMode(tool, mode, [noReadMode], {}, manager, settings)).toBe(mode === "code")
+		expect(group.includes(tool)).toBe(mode === "code")
+	}
+}
+
+describe("codebase_search readiness across mode filtering APIs", () => {
+	it("excludes search without a manager while retaining ordinary read tools", () => {
+		checkAvailability(undefined, false)
+	})
+
+	for (const isFeatureEnabled of [false, true]) {
+		for (const isFeatureConfigured of [false, true]) {
+			for (const isInitialized of [false, true]) {
+				it(`agrees for enabled=${isFeatureEnabled}, configured=${isFeatureConfigured}, initialized=${isInitialized}`, () => {
+					checkAvailability(
+						makeManager({ isFeatureEnabled, isFeatureConfigured, isInitialized }),
+						isFeatureEnabled && isFeatureConfigured && isInitialized,
+					)
+				})
+			}
+		}
+	}
+
+	it.each(["isFeatureEnabled", "isFeatureConfigured", "isInitialized"] as const)(
+		"rereads live %s changes",
+		(flag) => {
+			const flags = { ...ready }
+			const manager = makeManager(flags)
+			checkAvailability(manager, true)
+			flags[flag] = false
+			checkAvailability(manager, false)
+			flags[flag] = true
+			checkAvailability(manager, true)
+		},
+	)
+
+	it("keeps alternating managers isolated", () => {
+		const enabled = makeManager({ ...ready })
+		const disabled = makeManager({ ...ready, isFeatureEnabled: false })
+		checkAvailability(enabled, true)
+		checkAvailability(disabled, false)
+		checkAvailability(undefined, false)
+		checkAvailability(enabled, true)
+	})
+
+	it("does not bypass a mode without the read group", () => {
+		checkAvailability(makeManager({ ...ready }), false, "no-read")
+	})
+
+	it("does not bypass disabledTools with a ready manager", () => {
+		checkAvailability(makeManager({ ...ready }), false, "code", { disabledTools: ["codebase_search"] })
+	})
+})

src/core/prompts/tools/filter-tools-for-mode.ts

@@ -376,17 +376,22 @@
 ): boolean {
 	const modeSlug = mode ?? defaultModeSlug
 
+	// codebase_search belongs to the read group, not ALWAYS_AVAILABLE_TOOLS.
+	// Readiness can deny access, but must not bypass mode or disabled-tool restrictions.
+	if (
+		toolName === "codebase_search" &&
+		(!codeIndexManager ||
+			!codeIndexManager.isFeatureEnabled ||
+			!codeIndexManager.isFeatureConfigured ||
+			!codeIndexManager.isInitialized ||
+			settings?.disabledTools?.includes(toolName))
+	) {
+		return false
+	}
+
 	// Check if it's an always-available tool
 	if (ALWAYS_AVAILABLE_TOOLS.includes(toolName)) {
 		// But still check for conditional exclusions
-		if (toolName === "codebase_search") {
-			return !!(
-				codeIndexManager &&
-				codeIndexManager.isFeatureEnabled &&
-				codeIndexManager.isFeatureConfigured &&
-				codeIndexManager.isInitialized
-			)
-		}
 		if (toolName === "update_todo_list") {
 			return settings?.todoListEnabled !== false
 		}

src/core/task/__tests__/Task.spec.ts

@@ -131,6 +131,13 @@ vi.mock("p-wait-for", () => ({
 	default: vi.fn().mockImplementation(async () => Promise.resolve()),
 }))
 
+// Task tests do not exercise indexing; keep workspace resolution and its cache out of this suite.
+vi.mock("../../../services/code-index/code-index-manager-registry", () => ({
+	CodeIndexManagerRegistry: {
+		getInstance: vi.fn().mockReturnValue(undefined),
+	},
+}))
+
 vi.mock("vscode", () => {
 	const mockDisposable = { dispose: vi.fn() }
 	const mockEventEmitter = { event: vi.fn(), fire: vi.fn() }

src/core/task/__tests__/build-tools-readiness.integration.spec.ts

@@ -0,0 +1,74 @@
+import type OpenAI from "openai"
+import type { CodeIndexManager } from "../../../services/code-index/manager"
+import { CodeIndexManagerRegistry } from "../../../services/code-index/code-index-manager-registry"
+import { makeExtensionContext } from "../../../test-utils/vscode"
+import type { ClineProvider } from "../../webview/ClineProvider"
+import { buildNativeToolsArrayWithRestrictions } from "../build-tools"
+
+vi.mock("../../../services/code-index/code-index-manager-registry", () => ({
+	CodeIndexManagerRegistry: { getInstance: vi.fn() },
+}))
+
+function toolNames(tools: OpenAI.Chat.ChatCompletionTool[]) {
+	return tools.flatMap((tool) => ("function" in tool ? [tool.function.name] : []))
+}
+
+describe("task tool building with real readiness filtering", () => {
+	beforeEach(() => vi.clearAllMocks())
+
+	it.each([false, true])("uses task cwd/context and live manager readiness (restrictions=%s)", async (restricted) => {
+		const context = makeExtensionContext()
+		// The builder only consumes context and getMcpHub; avoid constructing the webview provider.
+		const provider = { context, getMcpHub: () => undefined } as ClineProvider
+		const flags = { isFeatureEnabled: true, isFeatureConfigured: true, isInitialized: true }
+		// Only the public readiness getters are consumed by the real filter.
+		const readyManager = flags as CodeIndexManager
+		const unreadyManager = { ...flags, isInitialized: false } as CodeIndexManager
+		const managers = new Map([
+			["/tasks/ready", readyManager],
+			["/tasks/unready", unreadyManager],
+		])
+		vi.mocked(CodeIndexManagerRegistry.getInstance).mockImplementation((receivedContext, cwd) => {
+			expect(receivedContext).toBe(context)
+			return managers.get(cwd ?? "")
+		})
+
+		async function check(cwd: string, expected: boolean, mode = "code", disabledTools: string[] = []) {
+			const result = await buildNativeToolsArrayWithRestrictions({
+				provider,
+				cwd,
+				mode,
+				customModes: [{ slug: "no-read", name: "No read", roleDefinition: "No reading", groups: ["command"] }],
+				experiments: {},
+				apiConfiguration: {},
+				disabledTools,
+				includeAllToolsWithRestrictions: restricted,
+			})
+			expect(CodeIndexManagerRegistry.getInstance).toHaveBeenLastCalledWith(context, cwd)
+			const definitions = toolNames(result.tools)
+			const callable = restricted ? result.allowedFunctionNames : definitions
+			expect(callable).toBeDefined()
+			expect(callable?.includes("codebase_search")).toBe(expected)
+			expect(callable?.includes("read_file")).toBe(mode === "code")
+			if (restricted) {
+				// Historical definitions remain present; only allowedFunctionNames controls calls.
+				expect(definitions).toContain("codebase_search")
+			} else {
+				expect(result.allowedFunctionNames).toBeUndefined()
+			}
+		}
+
+		await check("/tasks/ready", true)
+		await check("/tasks/unready", false)
+		await check("/tasks/missing", false)
+		await check("/tasks/ready", true)
+		for (const flag of ["isFeatureEnabled", "isFeatureConfigured", "isInitialized"] as const) {
+			flags[flag] = false
+			await check("/tasks/ready", false)
+			flags[flag] = true
+			await check("/tasks/ready", true)
+		}
+		await check("/tasks/ready", false, "no-read")
+		await check("/tasks/ready", false, "code", ["codebase_search"])
+	})
+})

src/core/task/build-tools.ts

@@ -96,8 +96,8 @@ export async function buildNativeToolsArrayWithRestrictions(options: BuildToolsO
 	const mcpHub = provider.getMcpHub()
 
 	// Get CodeIndexManager for feature checking.
-	const { CodeIndexManager } = await import("../../services/code-index/manager")
-	const codeIndexManager = CodeIndexManager.getInstance(provider.context, cwd)
+	const { CodeIndexManagerRegistry } = await import("../../services/code-index/code-index-manager-registry")
+	const codeIndexManager = CodeIndexManagerRegistry.getInstance(provider.context, cwd)
 
 	// Build settings object for tool filtering.
 	const filterSettings = {

src/core/tools/CodebaseSearchTool.ts

@@ -2,7 +2,7 @@ import * as vscode from "vscode"
 import path from "path"
 
 import { Task } from "../task/Task"
-import { CodeIndexManager } from "../../services/code-index/manager"
+import { CodeIndexManagerRegistry } from "../../services/code-index/code-index-manager-registry"
 import { getWorkspacePath } from "../../utils/path"
 import { formatResponse } from "../prompts/responses"
 import { VectorStoreSearchResult } from "../../services/code-index/interfaces"
@@ -57,7 +57,7 @@ export class CodebaseSearchTool extends BaseTool<"codebase_search"> {
 				throw new Error("Extension context is not available.")
 			}
 
-			const manager = CodeIndexManager.getInstance(context)
+			const manager = CodeIndexManagerRegistry.getInstance(context)
 
 			if (!manager) {
 				throw new Error("CodeIndexManager is not available.")

src/core/webview/ClineProvider.ts

@@ -91,6 +91,7 @@ import { McpServerManager } from "../../services/mcp/McpServerManager"
 import { MarketplaceManager } from "../../services/marketplace"
 import { ShadowCheckpointService } from "../../services/checkpoints/ShadowCheckpointService"
 import { CodeIndexManager } from "../../services/code-index/manager"
+import { CodeIndexManagerRegistry } from "../../services/code-index/code-index-manager-registry"
 import type { IndexProgressUpdate } from "../../services/code-index/interfaces/manager"
 import { MdmService } from "../../services/mdm/MdmService"
 import { SkillsManager } from "../../services/skills/SkillsManager"
@@ -3307,7 +3308,7 @@ export class ClineProvider
 	 * @returns CodeIndexManager instance for the current workspace or the default one
 	 */
 	public getCurrentWorkspaceCodeIndexManager(): CodeIndexManager | undefined {
-		return CodeIndexManager.getInstance(this.context)
+		return CodeIndexManagerRegistry.getInstance(this.context)
 	}
 
 	/**

src/core/webview/__tests__/ClineProvider.spec.ts

@@ -3225,7 +3225,7 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 	})
 
 	it("catches auto-enabled indexing failures and posts the resulting status", async () => {
-		const { CodeIndexManager } = await import("../../../services/code-index/manager")
+		const { CodeIndexManagerRegistry } = await import("../../../services/code-index/code-index-manager-registry")
 		let workspaceEnabled = false
 		const manager = createIndexManager({
 			setAutoEnableDefault: vi.fn().mockImplementation(async () => {
@@ -3235,8 +3235,8 @@ describe("webviewMessageHandler no-floating-promises coverage", () => {
 		})
 		Object.defineProperty(manager, "isWorkspaceEnabled", { get: () => workspaceEnabled })
 		const getAllInstances = vi
-			.spyOn(CodeIndexManager, "getAllInstances")
-			.mockReturnValue([manager] as unknown as ReturnType<typeof CodeIndexManager.getAllInstances>)
+			.spyOn(CodeIndexManagerRegistry, "getAllInstances")
+			.mockReturnValue([manager] as unknown as ReturnType<typeof CodeIndexManagerRegistry.getAllInstances>)
 		const provider = createProvider({
 			getCurrentWorkspaceCodeIndexManager: vi.fn().mockReturnValue(manager),
 		})

src/core/webview/webviewMessageHandler.ts

@@ -62,7 +62,7 @@ import { Package } from "../../shared/package"
 import { type RouterName, toRouterName } from "../../shared/api"
 import { MessageEnhancer } from "./messageEnhancer"
 
-import { CodeIndexManager } from "../../services/code-index/manager"
+import { CodeIndexManagerRegistry } from "../../services/code-index/code-index-manager-registry"
 import { checkExistKey } from "../../shared/checkExistApiConfig"
 import { getRouterRemovalMessage, getRouterUnavailableSignInMessage } from "../config/routerRemoval"
 import { experimentDefault } from "../../shared/experiments"
@@ -3311,7 +3311,7 @@ export const webviewMessageHandler = async (
 					return
 				}
 				// Capture prior state for every manager before persisting the global change
-				const allManagers = CodeIndexManager.getAllInstances()
+				const allManagers = CodeIndexManagerRegistry.getAllInstances()
 				const priorStates = new Map(allManagers.map((m) => [m, m.isWorkspaceEnabled]))
 				await manager.setAutoEnableDefault(message.bool ?? true)
 				// Apply stop/start to every affected manager

src/eslint-suppressions.json

@@ -1301,7 +1301,7 @@
 	},
 	"services/code-index/__tests__/manager.spec.ts": {
 		"@typescript-eslint/no-explicit-any": {
-			"count": 89
+			"count": 87
 		}
 	},
 	"services/code-index/__tests__/orchestrator.spec.ts": {

src/extension.ts

@@ -35,6 +35,7 @@ import { openAiCodexOAuthManager } from "./integrations/openai-codex/oauth"
 import { kimiCodeOAuthManager } from "./integrations/kimi-code/oauth"
 import { McpServerManager } from "./services/mcp/McpServerManager"
 import { CodeIndexManager } from "./services/code-index/manager"
+import { CodeIndexManagerRegistry } from "./services/code-index/code-index-manager-registry"
 import { MdmService } from "./services/mdm/MdmService"
 import { migrateSettings } from "./utils/migrateSettings"
 import { autoImportSettings } from "./utils/autoImportSettings"
@@ -200,7 +201,7 @@ export async function activate(context: vscode.ExtensionContext) {
 
 	if (vscode.workspace.workspaceFolders) {
 		for (const folder of vscode.workspace.workspaceFolders) {
-			const manager = CodeIndexManager.getInstance(context, folder.uri.fsPath)
+			const manager = CodeIndexManagerRegistry.getInstance(context, folder.uri.fsPath)
 
 			if (manager) {
 				codeIndexManagers.push(manager)