diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 8190894..ec80422 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -595,6 +595,7 @@ function AppContent() {
 			provider?: "claude" | "opencode" | "cursor" | "github-copilot",
 			evaluatorFilter?: EvaluatorFilter,
 			concurrency?: number,
+			selectedEvaluators?: string[],
 		) => {
 			setEvaluationMode("evaluating");
 			setApiError(null);
@@ -609,6 +610,7 @@ function AppContent() {
 					evaluatorFilter,
 					undefined,
 					concurrency,
+					selectedEvaluators,
 				);
 				setCurrentJobId(response.jobId);
 				setSSEUrl(response.sseUrl);
@@ -622,6 +624,7 @@ function AppContent() {
 					totalEvaluators: getFilteredEvaluatorCount(
 						evaluatorFilter || "all",
 						evaluators,
+						selectedEvaluators?.length,
 					),
 					completedEvaluators: 0,
 					percentage: 0,
diff --git a/frontend/src/components/RepositoryUrlInput.tsx b/frontend/src/components/RepositoryUrlInput.tsx
index 5b8c830..00c732b 100644
--- a/frontend/src/components/RepositoryUrlInput.tsx
+++ b/frontend/src/components/RepositoryUrlInput.tsx
@@ -1,10 +1,11 @@
-import React, { useCallback, useEffect, useState } from "react";
+import React, { useCallback, useEffect, useRef, useState } from "react";
 import { useFeatureFlags } from "../contexts/FeatureFlagContext";
 import type { ProviderName } from "../hooks/useEvaluationApi";
 import { useEvaluatorsApi } from "../hooks/useEvaluatorsApi";
 import { useProviderDetection } from "../hooks/useProviderDetection";
 import { isValidGitUrl } from "../lib/url-validation";
 import type { EvaluatorFilter } from "../types/evaluation";
+import type { IEvaluator } from "../types/evaluator";
 
 interface IRepositoryUrlInputProps {
 	onSubmit: (
@@ -13,6 +14,7 @@ interface IRepositoryUrlInputProps {
 		provider: ProviderName,
 		evaluatorFilter: EvaluatorFilter,
 		concurrency: number,
+		selectedEvaluators?: string[],
 	) => Promise<void>;
 	isLoading: boolean;
 	error?: string | null;
@@ -44,23 +46,42 @@ export const RepositoryUrlInput: React.FC<IRepositoryUrlInputProps> = ({
 	const [url, setUrl] = useState("");
 	const [concurrency, setConcurrency] = useState<number>(3);
 	const [totalEvaluators, setTotalEvaluators] = useState<number>(17); // Default fallback
-	const [evaluatorFilter, setEvaluatorFilter] =
-		useState<EvaluatorFilter>("all");
+	const [evaluatorsList, setEvaluatorsList] = useState<IEvaluator[]>([]);
+	const [selectedEvaluatorIds, setSelectedEvaluatorIds] = useState<Set<string>>(
+		new Set(),
+	);
+	const [evaluatorDropdownOpen, setEvaluatorDropdownOpen] = useState(false);
+	const dropdownRef = useRef<HTMLDivElement>(null);
 	const [provider, setProvider] = useState<ProviderName>("claude");
 	const [validationError, setValidationError] = useState<string | null>(null);
 
-	// Fetch evaluators list on mount to get the total count
+	// Fetch evaluators list on mount to get the total count and details
 	useEffect(() => {
 		fetchEvaluatorsList()
 			.then((list) => {
-				const total = list.length;
-				setTotalEvaluators(total);
+				setTotalEvaluators(list.length);
+				setEvaluatorsList(list);
+				setSelectedEvaluatorIds(new Set(list.map((e) => e.id)));
 			})
 			.catch(() => {
 				// Keep the fallback default
 			});
 	}, [fetchEvaluatorsList]);
 
+	// Close dropdown on click outside
+	useEffect(() => {
+		const handleClickOutside = (event: MouseEvent) => {
+			if (
+				dropdownRef.current &&
+				!dropdownRef.current.contains(event.target as Node)
+			) {
+				setEvaluatorDropdownOpen(false);
+			}
+		};
+		document.addEventListener("mousedown", handleClickOutside);
+		return () => document.removeEventListener("mousedown", handleClickOutside);
+	}, []);
+
 	const validateUrl = useCallback((value: string): boolean => {
 		if (!value.trim()) {
 			setValidationError("Please enter a repository URL");
@@ -89,13 +110,19 @@ export const RepositoryUrlInput: React.FC<IRepositoryUrlInputProps> = ({
 			try {
 				// In cloud mode, use "random" sentinel to let backend pick an available provider
 				const effectiveProvider = cloudMode ? "random" : provider;
-				const effectiveFilter = cloudMode ? "all" : evaluatorFilter;
+				const isAllSelected =
+					selectedEvaluatorIds.size === totalEvaluators ||
+					selectedEvaluatorIds.size === 0;
+				const selectedArray = isAllSelected
+					? undefined
+					: Array.from(selectedEvaluatorIds);
 				await onSubmit(
 					url.trim(),
-					totalEvaluators,
+					selectedArray ? selectedArray.length : totalEvaluators,
 					effectiveProvider,
-					effectiveFilter,
+					"all",
 					concurrency,
+					cloudMode ? undefined : selectedArray,
 				);
 			} catch {
 				// Error is handled by parent component
@@ -105,7 +132,7 @@ export const RepositoryUrlInput: React.FC<IRepositoryUrlInputProps> = ({
 			url,
 			totalEvaluators,
 			provider,
-			evaluatorFilter,
+			selectedEvaluatorIds,
 			concurrency,
 			validateUrl,
 			onSubmit,
@@ -246,7 +273,7 @@ export const RepositoryUrlInput: React.FC<IRepositoryUrlInputProps> = ({
 	return (
 		<div className="w-full">
 			<form onSubmit={handleSubmit}>
-				<div className="glass-card p-4 gradient-border-hover transition-all duration-300">
+				<div className="glass-card p-4 gradient-border-hover transition-all duration-300 overflow-visible">
 					<div className="flex flex-col items-center py-2">
 						{/* Text Content */}
 						<div className="text-center mb-3">
@@ -294,37 +321,258 @@ export const RepositoryUrlInput: React.FC<IRepositoryUrlInputProps> = ({
 							</div>
 						</div>
 
-						{/* Options Row: Evaluator Filter and Provider - hidden in cloud mode */}
+						{/* Options Row: Evaluator Selector, Provider, Concurrency - hidden in cloud mode */}
 						{!cloudMode && (
 							<div className="w-full max-w-lg px-4 mb-3">
 								<div className="flex flex-wrap items-center justify-center gap-4">
-									{/* Evaluator Filter Selector */}
-									<div className="flex items-center gap-2">
-										<label
-											htmlFor="filter"
-											className="text-sm text-slate-400 whitespace-nowrap"
-										>
+									{/* Evaluator Multi-Select Dropdown */}
+									<div
+										className="flex items-center gap-2 relative"
+										ref={dropdownRef}
+									>
+										<label className="text-sm text-slate-400 whitespace-nowrap">
 											Evaluators:
 										</label>
-										<select
-											id="filter"
-											value={evaluatorFilter}
-											onChange={(e) =>
-												setEvaluatorFilter(e.target.value as EvaluatorFilter)
+										<button
+											type="button"
+											onClick={() =>
+												setEvaluatorDropdownOpen(!evaluatorDropdownOpen)
+											}
+											disabled={
+												disabled || isLoading || evaluatorsList.length === 0
 											}
-											disabled={disabled || isLoading}
 											className="
 												px-3 py-2 bg-slate-800/60 border border-slate-600/60 rounded-lg
 												text-slate-200 text-sm
 												focus:outline-none focus:border-indigo-500/70
 												disabled:opacity-50 disabled:cursor-not-allowed
 												transition-all duration-200 cursor-pointer
+												flex items-center gap-1.5
 											"
 										>
-											<option value="all">All (17)</option>
-											<option value="errors">Errors Only (13)</option>
-											<option value="suggestions">Suggestions (4)</option>
-										</select>
+											<span>
+												{selectedEvaluatorIds.size}/{totalEvaluators}
+											</span>
+											<svg
+												className={`w-3.5 h-3.5 transition-transform ${evaluatorDropdownOpen ? "rotate-180" : ""}`}
+												fill="none"
+												stroke="currentColor"
+												viewBox="0 0 24 24"
+											>
+												<path
+													strokeLinecap="round"
+													strokeLinejoin="round"
+													strokeWidth={2}
+													d="M19 9l-7 7-7-7"
+												/>
+											</svg>
+										</button>
+										{evaluatorDropdownOpen && evaluatorsList.length > 0 && (
+											<div className="absolute top-full left-0 mt-1 z-50 w-72 bg-slate-800 border border-slate-600/60 rounded-lg shadow-xl overflow-hidden">
+												{/* Select All / Deselect All */}
+												<div className="flex items-center justify-between px-3 py-2 border-b border-slate-700/60">
+													<button
+														type="button"
+														onClick={() =>
+															setSelectedEvaluatorIds(
+																new Set(evaluatorsList.map((e) => e.id)),
+															)
+														}
+														className="text-xs text-indigo-400 hover:text-indigo-300"
+													>
+														Select All
+													</button>
+													<button
+														type="button"
+														onClick={() => {
+															// Keep at least the first evaluator
+															const first = evaluatorsList[0];
+															if (first) {
+																setSelectedEvaluatorIds(new Set([first.id]));
+															}
+														}}
+														className="text-xs text-slate-400 hover:text-slate-300"
+													>
+														Deselect All
+													</button>
+												</div>
+												<div className="max-h-64 overflow-y-auto">
+													{/* Errors group */}
+													{(() => {
+														const errorEvals = evaluatorsList.filter(
+															(e) => e.issueType === "error",
+														);
+														const allErrorsSelected = errorEvals.every((e) =>
+															selectedEvaluatorIds.has(e.id),
+														);
+														const someErrorsSelected =
+															!allErrorsSelected &&
+															errorEvals.some((e) =>
+																selectedEvaluatorIds.has(e.id),
+															);
+														return (
+															<>
+																<div
+																	className="flex items-center gap-2 px-3 py-1.5 bg-slate-750 border-b border-slate-700/40 cursor-pointer hover:bg-slate-700/50"
+																	onClick={() => {
+																		setSelectedEvaluatorIds((prev) => {
+																			const next = new Set(prev);
+																			if (allErrorsSelected) {
+																				// Deselect all errors, but ensure at least 1 evaluator remains
+																				for (const e of errorEvals) {
+																					next.delete(e.id);
+																				}
+																				if (next.size === 0) {
+																					// Keep first suggestion or first error
+																					const fallback =
+																						evaluatorsList.find(
+																							(e) =>
+																								e.issueType === "suggestion",
+																						) || errorEvals[0];
+																					if (fallback) next.add(fallback.id);
+																				}
+																			} else {
+																				for (const e of errorEvals) {
+																					next.add(e.id);
+																				}
+																			}
+																			return next;
+																		});
+																	}}
+																>
+																	<input
+																		type="checkbox"
+																		checked={allErrorsSelected}
+																		ref={(el) => {
+																			if (el)
+																				el.indeterminate = someErrorsSelected;
+																		}}
+																		readOnly
+																		className="rounded border-slate-500 text-indigo-500 focus:ring-0 cursor-pointer"
+																	/>
+																	<span className="text-xs font-semibold text-slate-300 uppercase tracking-wide">
+																		Errors ({errorEvals.length})
+																	</span>
+																</div>
+																{errorEvals.map((ev) => (
+																	<label
+																		key={ev.id}
+																		className="flex items-center gap-2 px-3 py-1.5 hover:bg-slate-700/40 cursor-pointer"
+																	>
+																		<input
+																			type="checkbox"
+																			checked={selectedEvaluatorIds.has(ev.id)}
+																			onChange={() => {
+																				setSelectedEvaluatorIds((prev) => {
+																					const next = new Set(prev);
+																					if (next.has(ev.id)) {
+																						if (next.size > 1)
+																							next.delete(ev.id);
+																					} else {
+																						next.add(ev.id);
+																					}
+																					return next;
+																				});
+																			}}
+																			className="rounded border-slate-500 text-indigo-500 focus:ring-0 cursor-pointer"
+																		/>
+																		<span className="text-sm text-slate-300 truncate">
+																			{ev.name}
+																		</span>
+																	</label>
+																))}
+															</>
+														);
+													})()}
+													{/* Suggestions group */}
+													{(() => {
+														const suggestionEvals = evaluatorsList.filter(
+															(e) => e.issueType === "suggestion",
+														);
+														const allSuggestionsSelected =
+															suggestionEvals.every((e) =>
+																selectedEvaluatorIds.has(e.id),
+															);
+														const someSuggestionsSelected =
+															!allSuggestionsSelected &&
+															suggestionEvals.some((e) =>
+																selectedEvaluatorIds.has(e.id),
+															);
+														return (
+															<>
+																<div
+																	className="flex items-center gap-2 px-3 py-1.5 bg-slate-750 border-b border-t border-slate-700/40 cursor-pointer hover:bg-slate-700/50"
+																	onClick={() => {
+																		setSelectedEvaluatorIds((prev) => {
+																			const next = new Set(prev);
+																			if (allSuggestionsSelected) {
+																				for (const e of suggestionEvals) {
+																					next.delete(e.id);
+																				}
+																				if (next.size === 0) {
+																					const fallback =
+																						evaluatorsList.find(
+																							(e) => e.issueType === "error",
+																						) || suggestionEvals[0];
+																					if (fallback) next.add(fallback.id);
+																				}
+																			} else {
+																				for (const e of suggestionEvals) {
+																					next.add(e.id);
+																				}
+																			}
+																			return next;
+																		});
+																	}}
+																>
+																	<input
+																		type="checkbox"
+																		checked={allSuggestionsSelected}
+																		ref={(el) => {
+																			if (el)
+																				el.indeterminate =
+																					someSuggestionsSelected;
+																		}}
+																		readOnly
+																		className="rounded border-slate-500 text-indigo-500 focus:ring-0 cursor-pointer"
+																	/>
+																	<span className="text-xs font-semibold text-slate-300 uppercase tracking-wide">
+																		Suggestions ({suggestionEvals.length})
+																	</span>
+																</div>
+																{suggestionEvals.map((ev) => (
+																	<label
+																		key={ev.id}
+																		className="flex items-center gap-2 px-3 py-1.5 hover:bg-slate-700/40 cursor-pointer"
+																	>
+																		<input
+																			type="checkbox"
+																			checked={selectedEvaluatorIds.has(ev.id)}
+																			onChange={() => {
+																				setSelectedEvaluatorIds((prev) => {
+																					const next = new Set(prev);
+																					if (next.has(ev.id)) {
+																						if (next.size > 1)
+																							next.delete(ev.id);
+																					} else {
+																						next.add(ev.id);
+																					}
+																					return next;
+																				});
+																			}}
+																			className="rounded border-slate-500 text-indigo-500 focus:ring-0 cursor-pointer"
+																		/>
+																		<span className="text-sm text-slate-300 truncate">
+																			{ev.name}
+																		</span>
+																	</label>
+																))}
+															</>
+														);
+													})()}
+												</div>
+											</div>
+										)}
 									</div>
 
 									{/* Provider Selector */}
diff --git a/frontend/src/hooks/useEvaluationApi.ts b/frontend/src/hooks/useEvaluationApi.ts
index 1e1d6a3..ca05eba 100644
--- a/frontend/src/hooks/useEvaluationApi.ts
+++ b/frontend/src/hooks/useEvaluationApi.ts
@@ -19,6 +19,7 @@ interface IUseEvaluationApiReturn {
 		evaluatorFilter?: EvaluatorFilter,
 		timeout?: number,
 		concurrency?: number,
+		selectedEvaluators?: string[],
 	) => Promise<IEvaluateResponse>;
 	getJobStatus: (jobId: string) => Promise<IJobStatusResponse>;
 	cancelJob: (jobId: string) => Promise<void>;
@@ -39,6 +40,7 @@ export function useEvaluationApi(): IUseEvaluationApiReturn {
 			evaluatorFilter?: EvaluatorFilter,
 			timeout?: number,
 			concurrency?: number,
+			selectedEvaluators?: string[],
 		): Promise<IEvaluateResponse> => {
 			setIsLoading(true);
 			setError(null);
@@ -55,6 +57,7 @@ export function useEvaluationApi(): IUseEvaluationApiReturn {
 							...(evaluatorFilter ? { evaluatorFilter } : {}),
 							...(timeout ? { timeout } : {}),
 							...(concurrency ? { concurrency } : {}),
+							...(selectedEvaluators ? { selectedEvaluators } : {}),
 						},
 					}),
 				});
diff --git a/frontend/src/lib/formatters.ts b/frontend/src/lib/formatters.ts
index 9decc20..946436c 100644
--- a/frontend/src/lib/formatters.ts
+++ b/frontend/src/lib/formatters.ts
@@ -173,7 +173,13 @@ export function formatCost(usd: number): string {
 export function getFilteredEvaluatorCount(
 	filter: EvaluatorFilter,
 	maxCount: number = 17,
+	selectedCount?: number,
 ): number {
+	// When specific evaluators are selected, use that count directly
+	if (selectedCount !== undefined) {
+		return Math.min(selectedCount, maxCount);
+	}
+
 	// Total counts by filter type
 	const COUNTS = {
 		all: 17,
diff --git a/frontend/src/types/evaluator.ts b/frontend/src/types/evaluator.ts
index 013050d..20f73a9 100644
--- a/frontend/src/types/evaluator.ts
+++ b/frontend/src/types/evaluator.ts
@@ -1,6 +1,7 @@
 export interface IEvaluator {
 	id: string; // e.g., "01-content-quality"
 	name: string; // e.g., "Content Quality & Focus"
+	issueType: "error" | "suggestion";
 }
 
 export interface IEvaluatorTemplate extends IEvaluator {
diff --git a/src/api/utils/evaluator-utils.ts b/src/api/utils/evaluator-utils.ts
index 02dbb28..774a057 100644
--- a/src/api/utils/evaluator-utils.ts
+++ b/src/api/utils/evaluator-utils.ts
@@ -9,6 +9,7 @@ import {
 	getEvaluatorList,
 	hasEmbeddedPrompts,
 } from "../../embedded/prompt-server";
+import { getIssueTypeFromEvaluatorName } from "../../shared/evaluation/evaluator-types";
 
 /**
  * Evaluator metadata
@@ -16,6 +17,7 @@ import {
 export interface EvaluatorInfo {
 	id: string;
 	name: string;
+	issueType: "error" | "suggestion";
 }
 
 /**
@@ -54,7 +56,10 @@ export async function getEvaluators(
 	let evaluators: EvaluatorInfo[];
 
 	if (isEmbeddedPromptMode()) {
-		evaluators = getEvaluatorList();
+		evaluators = getEvaluatorList().map((e) => ({
+			...e,
+			issueType: getIssueTypeFromEvaluatorName(e.id),
+		}));
 	} else {
 		const files = await readdir(evaluatorsDir);
 		const mdFiles = files.filter(
@@ -67,7 +72,8 @@ export async function getEvaluators(
 				const filePath = resolve(evaluatorsDir, file);
 				const content = await readFile(filePath, "utf-8");
 				const name = extractEvaluatorName(content);
-				return { id, name };
+				const issueType = getIssueTypeFromEvaluatorName(id);
+				return { id, name, issueType };
 			}),
 		);
 	}
@@ -89,7 +95,10 @@ export async function getEvaluatorById(
 	if (isEmbeddedPromptMode()) {
 		const evaluator = getEvaluator(evaluatorId);
 		if (evaluator) {
-			return evaluator as EvaluatorWithContent;
+			return {
+				...evaluator,
+				issueType: getIssueTypeFromEvaluatorName(evaluatorId),
+			} as EvaluatorWithContent;
 		}
 		return null;
 	}
@@ -100,7 +109,8 @@ export async function getEvaluatorById(
 	try {
 		const content = await readFile(filePath, "utf-8");
 		const name = extractEvaluatorName(content);
-		return { id: evaluatorId, name, content };
+		const issueType = getIssueTypeFromEvaluatorName(evaluatorId);
+		return { id: evaluatorId, name, issueType, content };
 	} catch (error) {
 		// Check if it's a file not found error
 		const isNotFound =
diff --git a/src/shared/evaluation/engine.ts b/src/shared/evaluation/engine.ts
index 30512bd..1d173cd 100644
--- a/src/shared/evaluation/engine.ts
+++ b/src/shared/evaluation/engine.ts
@@ -1251,6 +1251,7 @@ export class EvaluationEngine {
 			onTimeout,
 			provider: aiProvider,
 			evaluatorFilter: options.evaluatorFilter,
+			selectedEvaluators: options.selectedEvaluators,
 			timeout: options.timeout,
 		});
 
@@ -1635,6 +1636,7 @@ export class EvaluationEngine {
 				onTimeout,
 				provider: aiProvider,
 				evaluatorFilter: options.evaluatorFilter,
+				selectedEvaluators: options.selectedEvaluators,
 				timeout: options.timeout,
 			});
 
diff --git a/src/shared/evaluation/evaluator-types.test.ts b/src/shared/evaluation/evaluator-types.test.ts
index 51b5bd5..8214e80 100644
--- a/src/shared/evaluation/evaluator-types.test.ts
+++ b/src/shared/evaluation/evaluator-types.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import {
+	filterEvaluatorsByIds,
 	filterEvaluatorsByType,
 	getEvaluatorCountByType,
 	getEvaluatorFilterMetadata,
@@ -266,4 +267,59 @@ describe("Evaluator Types", () => {
 			expect(suggestionsFilter?.description).toContain("improvement");
 		});
 	});
+
+	describe("filterEvaluatorsByIds", () => {
+		test("should select specific evaluators by ID", () => {
+			const result = filterEvaluatorsByIds(EVALUATOR_FILES, [
+				"content-quality",
+				"security",
+			]);
+			expect(result).toHaveLength(2);
+			expect(result).toContain("content-quality.md");
+			expect(result).toContain("security.md");
+		});
+
+		test("should preserve original order", () => {
+			const result = filterEvaluatorsByIds(EVALUATOR_FILES, [
+				"security",
+				"content-quality",
+			]);
+			expect(result).toEqual(["content-quality.md", "security.md"]);
+		});
+
+		test("should return empty for empty selection", () => {
+			const result = filterEvaluatorsByIds(EVALUATOR_FILES, []);
+			expect(result).toHaveLength(0);
+		});
+
+		test("should ignore unknown IDs", () => {
+			const result = filterEvaluatorsByIds(EVALUATOR_FILES, [
+				"content-quality",
+				"nonexistent-evaluator",
+			]);
+			expect(result).toHaveLength(1);
+			expect(result[0]).toBe("content-quality.md");
+		});
+
+		test("should return all when all IDs are provided", () => {
+			const allIds = EVALUATOR_FILES.map((f) => f.replace(".md", ""));
+			const result = filterEvaluatorsByIds(EVALUATOR_FILES, [...allIds]);
+			expect(result).toHaveLength(EVALUATOR_FILES.length);
+		});
+
+		test("should handle empty evaluator files array", () => {
+			const result = filterEvaluatorsByIds([], ["content-quality"]);
+			expect(result).toHaveLength(0);
+		});
+
+		test("should select mix of error and suggestion evaluators", () => {
+			const result = filterEvaluatorsByIds(EVALUATOR_FILES, [
+				"content-quality",
+				"context-gaps",
+			]);
+			expect(result).toHaveLength(2);
+			expect(result).toContain("content-quality.md");
+			expect(result).toContain("context-gaps.md");
+		});
+	});
 });
diff --git a/src/shared/evaluation/evaluator-types.ts b/src/shared/evaluation/evaluator-types.ts
index 432cb21..4b5df34 100644
--- a/src/shared/evaluation/evaluator-types.ts
+++ b/src/shared/evaluation/evaluator-types.ts
@@ -151,6 +151,19 @@ export function filterEvaluatorsByType(
 	});
 }
 
+/**
+ * Filter evaluator files by specific IDs.
+ * IDs are filenames without .md extension (e.g., "content-quality", "security").
+ * Returns filtered array preserving original order.
+ */
+export function filterEvaluatorsByIds(
+	evaluatorFiles: readonly string[],
+	selectedIds: string[],
+): string[] {
+	const idSet = new Set(selectedIds.map((id) => `${id}.md`));
+	return evaluatorFiles.filter((filename) => idSet.has(filename));
+}
+
 /**
  * Get count of evaluators by type
  * Note: This counts actual evaluator files, not all EVALUATOR_CONFIGS entries
diff --git a/src/shared/evaluation/runner.ts b/src/shared/evaluation/runner.ts
index 4fdbb78..d786098 100644
--- a/src/shared/evaluation/runner.ts
+++ b/src/shared/evaluation/runner.ts
@@ -30,6 +30,7 @@ import {
 	hasFileFiltering,
 } from "./config";
 import {
+	filterEvaluatorsByIds,
 	filterEvaluatorsByType,
 	getIssueTypeFromEvaluatorName,
 	shouldExecuteIfNoFile,
@@ -216,6 +217,8 @@ export async function runAllEvaluators(
 		provider?: IAIProvider;
 		/** Filter evaluators by type */
 		evaluatorFilter?: EvaluatorFilter;
+		/** Specific evaluator IDs to run (overrides evaluatorFilter when set) */
+		selectedEvaluators?: string[];
 		/** Timeout per evaluator in milliseconds */
 		timeout?: number;
 	} = {},
@@ -234,15 +237,16 @@ export async function runAllEvaluators(
 		noFileMode = false,
 		provider = getProvider(),
 		evaluatorFilter = "all",
+		selectedEvaluators,
 		timeout = DEFAULT_TIMEOUT_MS,
 	} = options;
 
 	// Apply filter first, then limit by count
 	const allEvaluatorFiles = EVALUATOR_FILES;
-	const filteredFiles = filterEvaluatorsByType(
-		allEvaluatorFiles,
-		evaluatorFilter,
-	);
+	const filteredFiles =
+		selectedEvaluators && selectedEvaluators.length > 0
+			? filterEvaluatorsByIds(allEvaluatorFiles, selectedEvaluators)
+			: filterEvaluatorsByType(allEvaluatorFiles, evaluatorFilter);
 	const selectedFiles = filteredFiles.slice(
 		0,
 		Math.min(evaluators, filteredFiles.length),
@@ -763,6 +767,8 @@ export async function runUnifiedEvaluation(
 		provider?: IAIProvider;
 		/** Filter evaluators by type */
 		evaluatorFilter?: EvaluatorFilter;
+		/** Specific evaluator IDs to run (overrides evaluatorFilter when set) */
+		selectedEvaluators?: string[];
 		/** Timeout per evaluator in milliseconds */
 		timeout?: number;
 	} = {},
@@ -782,6 +788,7 @@ export async function runUnifiedEvaluation(
 		noFileMode = false,
 		provider = getProvider(),
 		evaluatorFilter = "all",
+		selectedEvaluators,
 		timeout = DEFAULT_TIMEOUT_MS,
 	} = options;
 
@@ -802,10 +809,10 @@ export async function runUnifiedEvaluation(
 
 	// Apply filter first, then limit by count
 	const allEvaluatorFiles = EVALUATOR_FILES;
-	const filteredFiles = filterEvaluatorsByType(
-		allEvaluatorFiles,
-		evaluatorFilter,
-	);
+	const filteredFiles =
+		selectedEvaluators && selectedEvaluators.length > 0
+			? filterEvaluatorsByIds(allEvaluatorFiles, selectedEvaluators)
+			: filterEvaluatorsByType(allEvaluatorFiles, evaluatorFilter);
 	const selectedFiles = filteredFiles.slice(
 		0,
 		Math.min(evaluators, filteredFiles.length),
diff --git a/src/shared/types/evaluation.ts b/src/shared/types/evaluation.ts
index 22e80f9..d0df890 100644
--- a/src/shared/types/evaluation.ts
+++ b/src/shared/types/evaluation.ts
@@ -517,6 +517,12 @@ export interface IEvaluationOptions {
 	 * - "suggestions": Run only suggestion evaluators (improvement opportunities)
 	 */
 	evaluatorFilter?: EvaluatorFilter;
+	/**
+	 * Specific evaluator IDs to run (filenames without .md extension).
+	 * When set and non-empty, overrides evaluatorFilter.
+	 * Example: ["content-quality", "security", "context-gaps"]
+	 */
+	selectedEvaluators?: string[];
 	/**
 	 * Enable assessment features (feedback buttons, selection basket, assessment page)
 	 * - Default: false (features hidden)