fix(code-index): exclude metadata points at query-time in Qdrant and gate orchestrator cleanup behind indexingStarted

- Merge must_not: [{ key: "type", match: { value: "metadata" } }] into QdrantVectorStore.search() filter ([QdrantVectorStore.search()](src/services/code-index/vector-store/qdrant-client.ts:383))
- Normalize constants import path in [qdrant-client.ts](src/services/code-index/vector-store/qdrant-client.ts:8)
- Only invoke clearCollection()/cache clear after initialize() succeeds in [CodeIndexOrchestrator.startIndexing()](src/services/code-index/orchestrator.ts:291)

test: update qdrant-client search expectations and add orchestrator error-path gating test

Author: daniel-lxs

src/services/code-index/__tests__/orchestrator.spec.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, beforeEach, vi } from "vitest"
+import { CodeIndexOrchestrator } from "../orchestrator"
+
+// Mock vscode workspace so startIndexing passes workspace check
+vi.mock("vscode", () => {
+	const path = require("path")
+	const testWorkspacePath = path.join(path.sep, "test", "workspace")
+	return {
+		window: {
+			activeTextEditor: null,
+		},
+		workspace: {
+			workspaceFolders: [
+				{
+					uri: { fsPath: testWorkspacePath },
+					name: "test",
+					index: 0,
+				},
+			],
+			createFileSystemWatcher: vi.fn().mockReturnValue({
+				onDidCreate: vi.fn().mockReturnValue({ dispose: vi.fn() }),
+				onDidChange: vi.fn().mockReturnValue({ dispose: vi.fn() }),
+				onDidDelete: vi.fn().mockReturnValue({ dispose: vi.fn() }),
+				dispose: vi.fn(),
+			}),
+		},
+		RelativePattern: vi.fn().mockImplementation((base: string, pattern: string) => ({ base, pattern })),
+	}
+})
+
+// Mock TelemetryService
+vi.mock("@roo-code/telemetry", () => ({
+	TelemetryService: {
+		instance: {
+			captureEvent: vi.fn(),
+		},
+	},
+}))
+
+// Mock i18n translator used in orchestrator messages
+vi.mock("../../i18n", () => ({
+	t: (key: string, params?: any) => {
+		if (key === "embeddings:orchestrator.failedDuringInitialScan" && params?.errorMessage) {
+			return `Failed during initial scan: ${params.errorMessage}`
+		}
+		return key
+	},
+}))
+
+describe("CodeIndexOrchestrator - error path cleanup gating", () => {
+	const workspacePath = "/test/workspace"
+
+	let configManager: any
+	let stateManager: any
+	let cacheManager: any
+	let vectorStore: any
+	let scanner: any
+	let fileWatcher: any
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+
+		configManager = {
+			isFeatureConfigured: true,
+		}
+
+		// Minimal state manager that tracks state transitions
+		let currentState = "Standby"
+		stateManager = {
+			get state() {
+				return currentState
+			},
+			setSystemState: vi.fn().mockImplementation((state: string, _msg: string) => {
+				currentState = state
+			}),
+			reportFileQueueProgress: vi.fn(),
+			reportBlockIndexingProgress: vi.fn(),
+		}
+
+		cacheManager = {
+			clearCacheFile: vi.fn().mockResolvedValue(undefined),
+		}
+
+		vectorStore = {
+			initialize: vi.fn(),
+			hasIndexedData: vi.fn(),
+			markIndexingIncomplete: vi.fn(),
+			markIndexingComplete: vi.fn(),
+			clearCollection: vi.fn().mockResolvedValue(undefined),
+		}
+
+		scanner = {
+			scanDirectory: vi.fn(),
+		}
+
+		fileWatcher = {
+			initialize: vi.fn().mockResolvedValue(undefined),
+			onDidStartBatchProcessing: vi.fn().mockReturnValue({ dispose: vi.fn() }),
+			onBatchProgressUpdate: vi.fn().mockReturnValue({ dispose: vi.fn() }),
+			onDidFinishBatchProcessing: vi.fn().mockReturnValue({ dispose: vi.fn() }),
+			dispose: vi.fn(),
+		}
+	})
+
+	it("should not call clearCollection() or clear cache when initialize() fails (indexing not started)", async () => {
+		// Arrange: fail at initialize()
+		vectorStore.initialize.mockRejectedValue(new Error("Qdrant unreachable"))
+
+		const orchestrator = new CodeIndexOrchestrator(
+			configManager,
+			stateManager,
+			workspacePath,
+			cacheManager,
+			vectorStore,
+			scanner,
+			fileWatcher,
+		)
+
+		// Act
+		await orchestrator.startIndexing()
+
+		// Assert
+		expect(vectorStore.clearCollection).not.toHaveBeenCalled()
+		expect(cacheManager.clearCacheFile).not.toHaveBeenCalled()
+
+		// Error state should be set
+		expect(stateManager.setSystemState).toHaveBeenCalled()
+		const lastCall = stateManager.setSystemState.mock.calls[stateManager.setSystemState.mock.calls.length - 1]
+		expect(lastCall[0]).toBe("Error")
+	})
+
+	it("should call clearCollection() and clear cache when an error occurs after initialize() succeeds (indexing started)", async () => {
+		// Arrange: initialize succeeds; fail soon after to enter error path with indexingStarted=true
+		vectorStore.initialize.mockResolvedValue(false) // existing collection
+		vectorStore.hasIndexedData.mockResolvedValue(false) // force full scan path
+		vectorStore.markIndexingIncomplete.mockRejectedValue(new Error("mark incomplete failure"))
+
+		const orchestrator = new CodeIndexOrchestrator(
+			configManager,
+			stateManager,
+			workspacePath,
+			cacheManager,
+			vectorStore,
+			scanner,
+			fileWatcher,
+		)
+
+		// Act
+		await orchestrator.startIndexing()
+
+		// Assert: cleanup gated behind indexingStarted should have happened
+		expect(vectorStore.clearCollection).toHaveBeenCalledTimes(1)
+		expect(cacheManager.clearCacheFile).toHaveBeenCalledTimes(1)
+
+		// Error state should be set
+		expect(stateManager.setSystemState).toHaveBeenCalled()
+		const lastCall = stateManager.setSystemState.mock.calls[stateManager.setSystemState.mock.calls.length - 1]
+		expect(lastCall[0]).toBe("Error")
+	})
+})

src/services/code-index/orchestrator.ts

@@ -288,15 +288,17 @@ export class CodeIndexOrchestrator {
 				stack: error instanceof Error ? error.stack : undefined,
 				location: "startIndexing",
 			})
-			try {
-				await this.vectorStore.clearCollection()
-			} catch (cleanupError) {
-				console.error("[CodeIndexOrchestrator] Failed to clean up after error:", cleanupError)
-				TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
-					error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
-					stack: cleanupError instanceof Error ? cleanupError.stack : undefined,
-					location: "startIndexing.cleanup",
-				})
+			if (indexingStarted) {
+				try {
+					await this.vectorStore.clearCollection()
+				} catch (cleanupError) {
+					console.error("[CodeIndexOrchestrator] Failed to clean up after error:", cleanupError)
+					TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
+						error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+						stack: cleanupError instanceof Error ? cleanupError.stack : undefined,
+						location: "startIndexing.cleanup",
+					})
+				}
 			}
 
 			// Only clear cache if indexing had started (Qdrant connection succeeded)