feat(MULTIVERSION-0001): add version management UI and auto-enqueue versions on re-index

- Add POST /api/v1/libs/:id/versions/discover endpoint that calls
  versionService.discoverTags() for local repos and returns empty tags
  gracefully for GitHub repos or git failures
- Enhance POST /api/v1/libs/:id/index to also enqueue jobs for all
  registered versions on default-branch re-index, returning versionJobs
  in the response
- Replace read-only Indexed Versions section with interactive Versions
  panel in the repo detail page: per-version state badges, Index/Remove
  buttons, inline Add version form, and Discover tags flow for local repos
- Add unit tests for both new/changed backend endpoints (8 new test cases)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/routes/api/v1/libs/[id]/index/+server.ts

@@ -1,17 +1,23 @@
 /**
  * POST /api/v1/libs/:id/index  — trigger an indexing job for a repository.
+ *
+ * Also enqueues jobs for all registered versions so that re-indexing a repo
+ * automatically covers its secondary versions.
  */
 import { json } from '@sveltejs/kit';
 import type { RequestHandler } from './$types';
 import { getClient } from '$lib/server/db/client';
 import { IndexingJobMapper } from '$lib/server/mappers/indexing-job.mapper.js';
 import { RepositoryService } from '$lib/server/services/repository.service';
+import { VersionService } from '$lib/server/services/version.service';
 import { getQueue } from '$lib/server/pipeline/startup';
 import { handleServiceError, NotFoundError } from '$lib/server/utils/validation';
 
 export const POST: RequestHandler = async ({ params, request }) => {
 	try {
-		const service = new RepositoryService(getClient());
+		const db = getClient();
+		const service = new RepositoryService(db);
+		const versionService = new VersionService(db);
 		const id = decodeURIComponent(params.id);
 
 		const repo = service.get(id);
@@ -30,7 +36,20 @@ export const POST: RequestHandler = async ({ params, request }) => {
 		const queue = getQueue();
 		const job = queue ? queue.enqueue(id, versionId) : service.createIndexingJob(id, versionId);
 
-		return json({ job: IndexingJobMapper.toDto(job) }, { status: 202 });
+		// Also enqueue jobs for all registered versions (dedup in queue makes this safe).
+		// Only when this is a default-branch re-index (no explicit versionId requested).
+		let versionJobs: ReturnType<typeof IndexingJobMapper.toDto>[] = [];
+		if (!versionId) {
+			const versions = versionService.list(id);
+			versionJobs = versions.map((version) => {
+				const vJob = queue
+					? queue.enqueue(id, version.id)
+					: service.createIndexingJob(id, version.id);
+				return IndexingJobMapper.toDto(vJob);
+			});
+		}
+
+		return json({ job: IndexingJobMapper.toDto(job), versionJobs }, { status: 202 });
 	} catch (err) {
 		return handleServiceError(err);
 	}

src/routes/api/v1/libs/[id]/index/server.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Unit tests for POST /api/v1/libs/:id/index
+ *
+ * Verifies:
+ * - Default-branch re-index also enqueues jobs for all registered versions
+ * - versionJobs array is returned in the response
+ * - Explicit versionId request does NOT trigger extra version jobs
+ * - Returns 404 when repo does not exist
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import Database from 'better-sqlite3';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { RepositoryService } from '$lib/server/services/repository.service';
+import { VersionService } from '$lib/server/services/version.service';
+
+let db: Database.Database;
+let mockQueue: { enqueue: ReturnType<typeof vi.fn> } | null = null;
+
+vi.mock('$lib/server/db/client', () => ({
+	getClient: () => db
+}));
+
+vi.mock('$lib/server/db/client.js', () => ({
+	getClient: () => db
+}));
+
+vi.mock('$lib/server/pipeline/startup', () => ({
+	getQueue: () => mockQueue
+}));
+
+vi.mock('$lib/server/pipeline/startup.js', () => ({
+	getQueue: () => mockQueue
+}));
+
+vi.mock('$lib/server/embeddings/registry', () => ({
+	createProviderFromProfile: () => null
+}));
+
+vi.mock('$lib/server/embeddings/registry.js', () => ({
+	createProviderFromProfile: () => null
+}));
+
+import { POST as postIndex } from './+server.js';
+
+const NOW_S = Math.floor(Date.now() / 1000);
+
+function createTestDb(): Database.Database {
+	const client = new Database(':memory:');
+	client.pragma('foreign_keys = ON');
+
+	const migrationsFolder = join(import.meta.dirname, '../../../../../../lib/server/db/migrations');
+	const ftsFile = join(import.meta.dirname, '../../../../../../lib/server/db/fts.sql');
+
+	const migration0 = readFileSync(join(migrationsFolder, '0000_large_master_chief.sql'), 'utf-8');
+	const migration1 = readFileSync(join(migrationsFolder, '0001_quick_nighthawk.sql'), 'utf-8');
+	const migration2 = readFileSync(join(migrationsFolder, '0002_silky_stellaris.sql'), 'utf-8');
+
+	for (const migration of [migration0, migration1, migration2]) {
+		for (const stmt of migration
+			.split('--> statement-breakpoint')
+			.map((s) => s.trim())
+			.filter(Boolean)) {
+			client.exec(stmt);
+		}
+	}
+
+	client.exec(readFileSync(ftsFile, 'utf-8'));
+	return client;
+}
+
+function makeEnqueueJob(repositoryId: string, versionId?: string) {
+	return {
+		id: `job-${Math.random().toString(36).slice(2)}`,
+		repositoryId,
+		versionId: versionId ?? null,
+		status: 'queued' as const,
+		processedFiles: 0,
+		totalFiles: 0,
+		error: null,
+		startedAt: null,
+		completedAt: null,
+		createdAt: new Date(NOW_S * 1000)
+	};
+}
+
+describe('POST /api/v1/libs/:id/index', () => {
+	beforeEach(() => {
+		db = createTestDb();
+		mockQueue = null;
+	});
+
+	it('returns 404 when repo does not exist', async () => {
+		const response = await postIndex({
+			params: { id: encodeURIComponent('/nonexistent/repo') },
+			request: new Request('http://test', { method: 'POST' })
+		} as never);
+
+		expect(response.status).toBe(404);
+	});
+
+	it('returns job and empty versionJobs when no versions are registered', async () => {
+		const repoService = new RepositoryService(db);
+		repoService.add({ source: 'github', sourceUrl: 'https://github.com/facebook/react' });
+
+		const response = await postIndex({
+			params: { id: encodeURIComponent('/facebook/react') },
+			request: new Request('http://test', { method: 'POST' })
+		} as never);
+
+		expect(response.status).toBe(202);
+		const body = await response.json();
+		expect(body.job).toBeDefined();
+		expect(body.job.repositoryId).toBe('/facebook/react');
+		expect(body.versionJobs).toEqual([]);
+	});
+
+	it('enqueues jobs for all registered versions on default-branch re-index', async () => {
+		const repoService = new RepositoryService(db);
+		const versionService = new VersionService(db);
+
+		repoService.add({ source: 'github', sourceUrl: 'https://github.com/facebook/react' });
+		versionService.add('/facebook/react', 'v18.3.0', 'React v18.3.0');
+		versionService.add('/facebook/react', 'v17.0.0', 'React v17.0.0');
+
+		const enqueue = vi.fn().mockImplementation(
+			(repositoryId: string, versionId?: string) => makeEnqueueJob(repositoryId, versionId)
+		);
+		mockQueue = { enqueue };
+
+		const response = await postIndex({
+			params: { id: encodeURIComponent('/facebook/react') },
+			request: new Request('http://test', { method: 'POST' })
+		} as never);
+
+		expect(response.status).toBe(202);
+		const body = await response.json();
+
+		// Main job enqueued (no versionId)
+		expect(body.job).toBeDefined();
+		expect(body.job.repositoryId).toBe('/facebook/react');
+
+		// Two version jobs enqueued
+		expect(body.versionJobs).toHaveLength(2);
+		expect(enqueue).toHaveBeenCalledTimes(3); // 1 main + 2 versions
+
+		// Version IDs should be the registered version IDs
+		const enqueuedVersionIds = enqueue.mock.calls.slice(1).map((call) => call[1]);
+		expect(enqueuedVersionIds).toContain('/facebook/react/v18.3.0');
+		expect(enqueuedVersionIds).toContain('/facebook/react/v17.0.0');
+	});
+
+	it('does NOT enqueue version jobs when an explicit versionId is provided', async () => {
+		const repoService = new RepositoryService(db);
+		const versionService = new VersionService(db);
+
+		repoService.add({ source: 'github', sourceUrl: 'https://github.com/facebook/react' });
+		versionService.add('/facebook/react', 'v18.3.0', 'React v18.3.0');
+
+		const enqueue = vi.fn().mockImplementation(
+			(repositoryId: string, versionId?: string) => makeEnqueueJob(repositoryId, versionId)
+		);
+		mockQueue = { enqueue };
+
+		const response = await postIndex({
+			params: { id: encodeURIComponent('/facebook/react') },
+			request: new Request('http://test', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ version: '/facebook/react/v18.3.0' })
+			})
+		} as never);
+
+		expect(response.status).toBe(202);
+		const body = await response.json();
+
+		// Only one call — the explicit version, no extra version enumeration
+		expect(enqueue).toHaveBeenCalledTimes(1);
+		expect(body.versionJobs).toEqual([]);
+	});
+});

src/routes/api/v1/libs/[id]/versions/discover/+server.ts

@@ -0,0 +1,63 @@
+/**
+ * POST /api/v1/libs/:id/versions/discover — discover git tags for a local repository.
+ *
+ * Returns { tags: Array<{ tag: string; commitHash: string }> }.
+ * For GitHub repositories or when tag discovery fails, returns { tags: [] } (not an error).
+ * Returns 404 if the repository does not exist.
+ */
+
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getClient } from '$lib/server/db/client';
+import { RepositoryService } from '$lib/server/services/repository.service';
+import { VersionService } from '$lib/server/services/version.service';
+import { handleServiceError, NotFoundError } from '$lib/server/utils/validation';
+
+function getServices() {
+	const db = getClient();
+	return {
+		repoService: new RepositoryService(db),
+		versionService: new VersionService(db)
+	};
+}
+
+// ---------------------------------------------------------------------------
+// POST /api/v1/libs/:id/versions/discover
+// ---------------------------------------------------------------------------
+
+export const POST: RequestHandler = ({ params }) => {
+	try {
+		const { repoService, versionService } = getServices();
+		const repositoryId = decodeURIComponent(params.id);
+
+		const repo = repoService.get(repositoryId);
+		if (!repo) {
+			throw new NotFoundError(`Repository ${repositoryId} not found`);
+		}
+
+		try {
+			const tags = versionService.discoverTags(repositoryId);
+			return json({ tags });
+		} catch {
+			// GitHub repos or git errors — return empty tags gracefully
+			return json({ tags: [] });
+		}
+	} catch (err) {
+		return handleServiceError(err);
+	}
+};
+
+// ---------------------------------------------------------------------------
+// OPTIONS preflight
+// ---------------------------------------------------------------------------
+
+export const OPTIONS: RequestHandler = () => {
+	return new Response(null, {
+		status: 204,
+		headers: {
+			'Access-Control-Allow-Origin': '*',
+			'Access-Control-Allow-Methods': 'POST, OPTIONS',
+			'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+		}
+	});
+};

src/routes/api/v1/libs/[id]/versions/discover/server.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Unit tests for POST /api/v1/libs/:id/versions/discover
+ *
+ * Verifies:
+ * - Local repo returns discovered tags
+ * - GitHub repo returns empty tags gracefully (no error)
+ * - Non-existent repo returns 404
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import Database from 'better-sqlite3';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+let db: Database.Database;
+
+vi.mock('$lib/server/db/client', () => ({
+	getClient: () => db
+}));
+
+vi.mock('$lib/server/db/client.js', () => ({
+	getClient: () => db
+}));
+
+vi.mock('$lib/server/pipeline/startup', () => ({
+	getQueue: () => null
+}));
+
+vi.mock('$lib/server/pipeline/startup.js', () => ({
+	getQueue: () => null
+}));
+
+// Mock git utilities so tests don't require a real git repo
+vi.mock('$lib/server/utils/git', () => ({
+	discoverVersionTags: vi.fn(),
+	resolveTagToCommit: vi.fn()
+}));
+
+vi.mock('$lib/server/utils/git.js', () => ({
+	discoverVersionTags: vi.fn(),
+	resolveTagToCommit: vi.fn()
+}));
+
+import { POST as postDiscover } from './+server.js';
+
+const NOW_S = Math.floor(Date.now() / 1000);
+
+function createTestDb(): Database.Database {
+	const client = new Database(':memory:');
+	client.pragma('foreign_keys = ON');
+
+	const migrationsFolder = join(import.meta.dirname, '../../../../../../../lib/server/db/migrations');
+	const ftsFile = join(import.meta.dirname, '../../../../../../../lib/server/db/fts.sql');
+
+	const migration0 = readFileSync(join(migrationsFolder, '0000_large_master_chief.sql'), 'utf-8');
+	const migration1 = readFileSync(join(migrationsFolder, '0001_quick_nighthawk.sql'), 'utf-8');
+	const migration2 = readFileSync(join(migrationsFolder, '0002_silky_stellaris.sql'), 'utf-8');
+
+	for (const migration of [migration0, migration1, migration2]) {
+		for (const stmt of migration
+			.split('--> statement-breakpoint')
+			.map((s) => s.trim())
+			.filter(Boolean)) {
+			client.exec(stmt);
+		}
+	}
+
+	client.exec(readFileSync(ftsFile, 'utf-8'));
+	return client;
+}
+
+function seedRepo(
+	client: Database.Database,
+	overrides: { id?: string; source?: 'github' | 'local'; sourceUrl?: string } = {}
+): string {
+	const id = overrides.id ?? '/facebook/react';
+	client
+		.prepare(
+			`INSERT INTO repositories
+			 (id, title, source, source_url, state, created_at, updated_at)
+			 VALUES (?, ?, ?, ?, 'indexed', ?, ?)`
+		)
+		.run(
+			id,
+			'React',
+			overrides.source ?? 'github',
+			overrides.sourceUrl ?? 'https://github.com/facebook/react',
+			NOW_S,
+			NOW_S
+		);
+	return id;
+}
+
+describe('POST /api/v1/libs/:id/versions/discover', () => {
+	beforeEach(async () => {
+		db = createTestDb();
+		const git = await import('$lib/server/utils/git');
+		vi.mocked(git.discoverVersionTags).mockReset();
+		vi.mocked(git.resolveTagToCommit).mockReset();
+	});
+
+	it('returns 404 when repo does not exist', async () => {
+		const response = await postDiscover({
+			params: { id: encodeURIComponent('/nonexistent/repo') }
+		} as never);
+
+		expect(response.status).toBe(404);
+		const body = await response.json();
+		expect(body.error).toBeDefined();
+	});
+
+	it('returns discovered tags for a local repository', async () => {
+		const { discoverVersionTags, resolveTagToCommit } = await import('$lib/server/utils/git');
+		vi.mocked(discoverVersionTags).mockReturnValue(['v2.0.0', 'v1.0.0']);
+		vi.mocked(resolveTagToCommit).mockImplementation(({ tag }) =>
+			tag === 'v2.0.0' ? 'abc12345' : 'def67890'
+		);
+
+		seedRepo(db, { source: 'local', sourceUrl: '/home/user/myrepo' });
+
+		const response = await postDiscover({
+			params: { id: encodeURIComponent('/facebook/react') }
+		} as never);
+
+		expect(response.status).toBe(200);
+		const body = await response.json();
+		expect(body.tags).toHaveLength(2);
+		expect(body.tags[0]).toEqual({ tag: 'v2.0.0', commitHash: 'abc12345' });
+		expect(body.tags[1]).toEqual({ tag: 'v1.0.0', commitHash: 'def67890' });
+	});
+
+	it('returns empty tags for a GitHub repository (no error)', async () => {
+		seedRepo(db, { source: 'github', sourceUrl: 'https://github.com/facebook/react' });
+
+		const response = await postDiscover({
+			params: { id: encodeURIComponent('/facebook/react') }
+		} as never);
+
+		expect(response.status).toBe(200);
+		const body = await response.json();
+		expect(body.tags).toEqual([]);
+	});
+
+	it('returns empty tags when git discovery throws', async () => {
+		const { discoverVersionTags } = await import('$lib/server/utils/git');
+		vi.mocked(discoverVersionTags).mockImplementation(() => {
+			throw new Error('git command failed');
+		});
+
+		seedRepo(db, { source: 'local', sourceUrl: '/home/user/myrepo' });
+
+		const response = await postDiscover({
+			params: { id: encodeURIComponent('/facebook/react') }
+		} as never);
+
+		expect(response.status).toBe(200);
+		const body = await response.json();
+		expect(body.tags).toEqual([]);
+	});
+});

src/routes/repos/[id]/+page.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
 	import { goto } from '$app/navigation';
 	import { resolve as resolveRoute } from '$app/paths';
+	import { onMount } from 'svelte';
 	import type { PageData } from './$types';
 	import type { Repository, IndexingJob } from '$lib/types';
 	import ConfirmDialog from '$lib/components/ConfirmDialog.svelte';
@@ -25,6 +26,35 @@
 	let errorMessage = $state<string | null>(null);
 	let successMessage = $state<string | null>(null);
 
+	// Version management state
+	interface VersionDto {
+		id: string;
+		repositoryId: string;
+		tag: string;
+		title: string | null;
+		commitHash: string | null;
+		state: 'pending' | 'indexing' | 'indexed' | 'error';
+		totalSnippets: number;
+		indexedAt: string | null;
+		createdAt: string;
+	}
+	let versions = $state<VersionDto[]>([]);
+	let versionsLoading = $state(false);
+
+	// Add version form
+	let addVersionTag = $state('');
+	let addVersionBusy = $state(false);
+
+	// Discover tags state
+	let discoverBusy = $state(false);
+	let discoveredTags = $state<Array<{ tag: string; commitHash: string }>>([]);
+	let selectedDiscoveredTags = $state<Set<string>>(new Set());
+	let showDiscoverPanel = $state(false);
+	let registerBusy = $state(false);
+
+	// Remove confirm
+	let removeTag = $state<string | null>(null);
+
 	const stateColors: Record<string, string> = {
 		pending: 'bg-gray-100 text-gray-600',
 		indexing: 'bg-blue-100 text-blue-700',
@@ -50,6 +80,25 @@
 		}
 	}
 
+	async function loadVersions() {
+		versionsLoading = true;
+		try {
+			const res = await fetch(`/api/v1/libs/${encodeURIComponent(repo.id)}/versions`);
+			if (res.ok) {
+				const data = await res.json();
+				versions = data.versions ?? [];
+			}
+		} catch {
+			// ignore
+		} finally {
+			versionsLoading = false;
+		}
+	}
+
+	onMount(() => {
+		loadVersions();
+	});
+
 	async function handleReindex() {
 		errorMessage = null;
 		successMessage = null;
@@ -65,8 +114,12 @@
 			if (d.job?.id) {
 				activeJobId = d.job.id;
 			}
-			successMessage = 'Re-indexing started.';
-			await refreshRepo();
+			const versionCount = d.versionJobs?.length ?? 0;
+			successMessage =
+				versionCount > 0
+					? `Re-indexing started. Also queued ${versionCount} version job${versionCount === 1 ? '' : 's'}.`
+					: 'Re-indexing started.';
+			await Promise.all([refreshRepo(), loadVersions()]);
 		} catch (e) {
 			errorMessage = (e as Error).message;
 		}
@@ -89,12 +142,133 @@
 		}
 	}
 
+	async function handleAddVersion() {
+		const tag = addVersionTag.trim();
+		if (!tag) return;
+		addVersionBusy = true;
+		errorMessage = null;
+		try {
+			const res = await fetch(`/api/v1/libs/${encodeURIComponent(repo.id)}/versions`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ tag, autoIndex: true })
+			});
+			if (!res.ok) {
+				const d = await res.json();
+				throw new Error(d.error ?? 'Failed to add version');
+			}
+			addVersionTag = '';
+			await loadVersions();
+		} catch (e) {
+			errorMessage = (e as Error).message;
+		} finally {
+			addVersionBusy = false;
+		}
+	}
+
+	async function handleIndexVersion(tag: string) {
+		errorMessage = null;
+		try {
+			const res = await fetch(
+				`/api/v1/libs/${encodeURIComponent(repo.id)}/versions/${encodeURIComponent(tag)}/index`,
+				{ method: 'POST' }
+			);
+			if (!res.ok) {
+				const d = await res.json();
+				throw new Error(d.error ?? 'Failed to queue version indexing');
+			}
+			await loadVersions();
+		} catch (e) {
+			errorMessage = (e as Error).message;
+		}
+	}
+
+	async function handleRemoveVersion() {
+		if (!removeTag) return;
+		const tag = removeTag;
+		removeTag = null;
+		errorMessage = null;
+		try {
+			const res = await fetch(
+				`/api/v1/libs/${encodeURIComponent(repo.id)}/versions/${encodeURIComponent(tag)}`,
+				{ method: 'DELETE' }
+			);
+			if (!res.ok && res.status !== 204) {
+				const d = await res.json();
+				throw new Error(d.error ?? 'Failed to remove version');
+			}
+			await loadVersions();
+		} catch (e) {
+			errorMessage = (e as Error).message;
+		}
+	}
+
+	async function handleDiscoverTags() {
+		discoverBusy = true;
+		errorMessage = null;
+		try {
+			const res = await fetch(
+				`/api/v1/libs/${encodeURIComponent(repo.id)}/versions/discover`,
+				{ method: 'POST' }
+			);
+			if (!res.ok) {
+				const d = await res.json();
+				throw new Error(d.error ?? 'Failed to discover tags');
+			}
+			const d = await res.json();
+			const registeredTags = new Set(versions.map((v) => v.tag));
+			discoveredTags = (d.tags ?? []).filter(
+				(t: { tag: string; commitHash: string }) => !registeredTags.has(t.tag)
+			);
+			selectedDiscoveredTags = new Set(discoveredTags.map((t) => t.tag));
+			showDiscoverPanel = true;
+		} catch (e) {
+			errorMessage = (e as Error).message;
+		} finally {
+			discoverBusy = false;
+		}
+	}
+
+	function toggleDiscoveredTag(tag: string) {
+		const next = new Set(selectedDiscoveredTags);
+		if (next.has(tag)) {
+			next.delete(tag);
+		} else {
+			next.add(tag);
+		}
+		selectedDiscoveredTags = next;
+	}
+
+	async function handleRegisterSelected() {
+		if (selectedDiscoveredTags.size === 0) return;
+		registerBusy = true;
+		errorMessage = null;
+		try {
+			await Promise.all(
+				[...selectedDiscoveredTags].map((tag) =>
+					fetch(`/api/v1/libs/${encodeURIComponent(repo.id)}/versions`, {
+						method: 'POST',
+						headers: { 'Content-Type': 'application/json' },
+						body: JSON.stringify({ tag, autoIndex: true })
+					})
+				)
+			);
+			showDiscoverPanel = false;
+			discoveredTags = [];
+			selectedDiscoveredTags = new Set();
+			await loadVersions();
+		} catch (e) {
+			errorMessage = (e as Error).message;
+		} finally {
+			registerBusy = false;
+		}
+	}
+
 	function formatDate(ts: Date | number | string | null | undefined): string {
 		if (!ts) return 'Never';
 		return new Date(ts as string).toLocaleString();
 	}
 
-	const indexedVersions = $derived(repo.indexedVersions ?? []);
 	const embeddingCount = $derived(repo.embeddingCount ?? 0);
 	const totalSnippets = $derived(repo.totalSnippets ?? 0);
 	const totalTokens = $derived(repo.totalTokens ?? 0);
@@ -191,6 +365,133 @@
 	{/if}
 </div>
 
+<!-- Versions -->
+<div class="mt-6 rounded-xl border border-gray-200 bg-white p-5">
+	<div class="mb-4 flex flex-wrap items-center justify-between gap-3">
+		<h2 class="text-sm font-semibold text-gray-700">Versions</h2>
+		<div class="flex flex-wrap items-center gap-2">
+			<!-- Add version inline form -->
+			<form
+				onsubmit={(e) => {
+					e.preventDefault();
+					handleAddVersion();
+				}}
+				class="flex items-center gap-1.5"
+			>
+				<input
+					type="text"
+					bind:value={addVersionTag}
+					placeholder="e.g. v2.0.0"
+					class="rounded-lg border border-gray-200 px-3 py-1.5 text-sm text-gray-900 placeholder-gray-400 focus:border-blue-400 focus:outline-none"
+				/>
+				<button
+					type="submit"
+					disabled={addVersionBusy || !addVersionTag.trim()}
+					class="rounded-lg bg-blue-600 px-3 py-1.5 text-sm font-medium text-white hover:bg-blue-700 disabled:cursor-not-allowed disabled:opacity-50"
+				>
+					Add
+				</button>
+			</form>
+			<!-- Discover tags button — local repos only -->
+			{#if repo.source === 'local'}
+				<button
+					onclick={handleDiscoverTags}
+					disabled={discoverBusy}
+					class="rounded-lg border border-gray-200 px-3 py-1.5 text-sm font-medium text-gray-700 hover:bg-gray-50 disabled:cursor-not-allowed disabled:opacity-50"
+				>
+					{discoverBusy ? 'Discovering...' : 'Discover tags'}
+				</button>
+			{/if}
+		</div>
+	</div>
+
+	<!-- Discover panel -->
+	{#if showDiscoverPanel}
+		<div class="mb-4 rounded-lg border border-blue-100 bg-blue-50 p-4">
+			<div class="mb-2 flex items-center justify-between">
+				<p class="text-sm font-medium text-blue-700">
+					{discoveredTags.length === 0
+						? 'No new tags found'
+						: `${discoveredTags.length} new tag${discoveredTags.length === 1 ? '' : 's'} available`}
+				</p>
+				<button
+					onclick={() => {
+						showDiscoverPanel = false;
+						discoveredTags = [];
+						selectedDiscoveredTags = new Set();
+					}}
+					class="text-xs text-blue-600 hover:underline"
+				>
+					Close
+				</button>
+			</div>
+			{#if discoveredTags.length > 0}
+				<div class="mb-3 flex flex-col gap-1.5">
+					{#each discoveredTags as discovered (discovered.tag)}
+						<label class="flex cursor-pointer items-center gap-2 text-sm">
+							<input
+								type="checkbox"
+								checked={selectedDiscoveredTags.has(discovered.tag)}
+								onchange={() => toggleDiscoveredTag(discovered.tag)}
+								class="rounded border-gray-300"
+							/>
+							<span class="font-mono text-gray-800">{discovered.tag}</span>
+							<span class="font-mono text-xs text-gray-400">{discovered.commitHash.slice(0, 8)}</span>
+						</label>
+					{/each}
+				</div>
+				<button
+					onclick={handleRegisterSelected}
+					disabled={registerBusy || selectedDiscoveredTags.size === 0}
+					class="rounded-lg bg-blue-600 px-3 py-1.5 text-sm font-medium text-white hover:bg-blue-700 disabled:cursor-not-allowed disabled:opacity-50"
+				>
+					{registerBusy
+						? 'Registering...'
+						: `Register ${selectedDiscoveredTags.size} selected`}
+				</button>
+			{/if}
+		</div>
+	{/if}
+
+	<!-- Versions list -->
+	{#if versionsLoading}
+		<p class="text-sm text-gray-400">Loading versions...</p>
+	{:else if versions.length === 0}
+		<p class="text-sm text-gray-400">No versions registered. Add a tag above to get started.</p>
+	{:else}
+		<div class="divide-y divide-gray-100">
+			{#each versions as version (version.id)}
+				<div class="flex items-center justify-between py-2.5">
+					<div class="flex items-center gap-3">
+						<span class="font-mono text-sm font-medium text-gray-900">{version.tag}</span>
+						<span
+							class="rounded-full px-2 py-0.5 text-xs font-medium {stateColors[version.state] ??
+								'bg-gray-100 text-gray-600'}"
+						>
+							{stateLabels[version.state] ?? version.state}
+						</span>
+					</div>
+					<div class="flex items-center gap-2">
+						<button
+							onclick={() => handleIndexVersion(version.tag)}
+							disabled={version.state === 'indexing'}
+							class="rounded-lg border border-blue-200 px-3 py-1 text-xs font-medium text-blue-600 hover:bg-blue-50 disabled:cursor-not-allowed disabled:opacity-50"
+						>
+							{version.state === 'indexing' ? 'Indexing...' : 'Index'}
+						</button>
+						<button
+							onclick={() => (removeTag = version.tag)}
+							class="rounded-lg border border-red-100 px-3 py-1 text-xs font-medium text-red-500 hover:bg-red-50"
+						>
+							Remove
+						</button>
+					</div>
+				</div>
+			{/each}
+		</div>
+	{/if}
+</div>
+
 <!-- Metadata -->
 <div class="mt-6 rounded-xl border border-gray-200 bg-white p-5">
 	<h2 class="mb-3 text-sm font-semibold text-gray-700">Repository Info</h2>
@@ -214,22 +515,6 @@
 	</dl>
 </div>
 
-<!-- Indexed Versions -->
-{#if indexedVersions.length > 0}
-	<div class="mt-6 rounded-xl border border-gray-200 bg-white p-5">
-		<h2 class="mb-3 text-sm font-semibold text-gray-700">Indexed Versions</h2>
-		<div class="flex flex-wrap gap-2">
-			{#each indexedVersions as versionTag (versionTag)}
-				<span
-					class="rounded-full border border-green-200 bg-green-50 px-3 py-1 font-mono text-sm text-green-800"
-				>
-					{versionTag}
-				</span>
-			{/each}
-		</div>
-	</div>
-{/if}
-
 <!-- Recent Jobs -->
 {#if recentJobs.length > 0}
 	<div class="mt-6 rounded-xl border border-gray-200 bg-white p-5">
@@ -277,3 +562,14 @@
 		onCancel={() => (showDeleteConfirm = false)}
 	/>
 {/if}
+
+{#if removeTag}
+	<ConfirmDialog
+		title="Remove Version"
+		message="Remove version '{removeTag}'? This will delete all indexed snippets for this version."
+		confirmLabel="Remove"
+		danger={true}
+		onConfirm={handleRemoveVersion}
+		onCancel={() => (removeTag = null)}
+	/>
+{/if}