diff --git a/src/components/ai-edition/Modals.tsx b/src/components/ai-edition/Modals.tsx
index 9ac9d1079..3be5687fd 100644
--- a/src/components/ai-edition/Modals.tsx
+++ b/src/components/ai-edition/Modals.tsx
@@ -17,51 +17,28 @@ import {
 	type ReactNode,
 	type PointerEvent as ReactPointerEvent,
 	useEffect,
+	useMemo,
 	useRef,
 	useState,
 } from "react";
 import { toFileUrl } from "@/components/video-editor/projectPersistence";
 import type { CropRegion } from "@/components/video-editor/types";
-import { useScopedT } from "@/contexts/I18nContext";
+import { useI18n, useScopedT } from "@/contexts/I18nContext";
 import { toAxcutTranscriptDsl } from "@/lib/ai-edition/document/transcribe";
-import type { AxcutClip, AxcutTranscript } from "@/lib/ai-edition/schema";
+import {
+	type AxcutClip,
+	type AxcutTranscript,
+	type TranscriptLanguageCode,
+	transcriptLanguageSchema,
+} from "@/lib/ai-edition/schema";
 import { formatSec, formatSeconds } from "@/lib/ai-edition/timeline/format";
+import {
+	languageLabel,
+	sortedLanguageOptions,
+} from "@/lib/ai-edition/transcription/languageLabels";
 import styles from "./NewEditorShell.module.css";
 import type { VideoSource } from "./VirtualPreview";
 
-// ponytail: keep the UI's language list literal in one place. Mirrors
-// `transcriptLanguageSchema` in schema/index.ts; if the schema gains a
-// language, add it here too.
-const REGEN_LANGUAGES = [
-	"auto",
-	"en",
-	"fr",
-	"de",
-	"es",
-	"it",
-	"pt",
-	"nl",
-	"ja",
-	"ko",
-	"zh",
-] as const;
-
-type TranscriptLanguage = (typeof REGEN_LANGUAGES)[number];
-
-const LANGUAGE_LABELS: Record<TranscriptLanguage, string> = {
-	auto: "Auto",
-	en: "EN",
-	fr: "FR",
-	de: "DE",
-	es: "ES",
-	it: "IT",
-	pt: "PT",
-	nl: "NL",
-	ja: "JA",
-	ko: "KO",
-	zh: "ZH",
-};
-
 interface BaseModalProps {
 	open: boolean;
 	onClose: () => void;
@@ -1539,6 +1516,17 @@ export function InsertSourceModal({
 	);
 }
 
+/**
+ * `AxcutTranscript.language` is `z.string().min(1)`, not validated against
+ * the known code list, so a stored transcript can hold a value no
+ * `<option>` matches — falls back to "auto" rather than letting the select
+ * go visibly out of sync with the code a regenerate would actually submit.
+ */
+function supportedTranscriptLanguage(language: string | undefined): TranscriptLanguageCode {
+	const parsed = transcriptLanguageSchema.safeParse(language);
+	return parsed.success ? parsed.data : "auto";
+}
+
 export interface SourceTranscriptModalProps extends BaseModalProps {
 	assetLabel: string;
 	assetPath: string;
@@ -1548,7 +1536,7 @@ export interface SourceTranscriptModalProps extends BaseModalProps {
 	isFailed: boolean;
 	/** Why the last run produced nothing — "no audio track", or the engine's own message. */
 	failureMessage?: string;
-	onRegenerate: (language: TranscriptLanguage) => void;
+	onRegenerate: (language: TranscriptLanguageCode) => void;
 }
 
 export function SourceTranscriptModal({
@@ -1569,17 +1557,23 @@ export function SourceTranscriptModal({
 	const [isPlaying, setIsPlaying] = useState(false);
 	const [playTime, setPlayTime] = useState(0);
 	const [duration, setDuration] = useState<number | null>(null);
-	const [regenLang, setRegenLang] = useState<TranscriptLanguage>(
-		(transcript?.language as TranscriptLanguage) ?? "auto",
+	const { locale } = useI18n();
+	const [regenLang, setRegenLang] = useState<TranscriptLanguageCode>(
+		supportedTranscriptLanguage(transcript?.language),
 	);
 
 	// ponytail: sync the language picker to whatever the stored transcript was
 	// generated with. Avoids surprising the user with a different selection on
 	// every open after a regenerate.
 	useEffect(() => {
-		if (open) setRegenLang((transcript?.language as TranscriptLanguage) ?? "auto");
+		if (open) setRegenLang(supportedTranscriptLanguage(transcript?.language));
 	}, [open, transcript?.language]);
 
+	const regenLanguageOptions = useMemo(
+		() => sortedLanguageOptions(locale, t("mediaStage.auto")),
+		[locale, t],
+	);
+
 	useEffect(() => {
 		if (!open) {
 			setIsPlaying(false);
@@ -1875,7 +1869,9 @@ export function SourceTranscriptModal({
 									border: "1px solid color-mix(in srgb, var(--success) 22%, transparent)",
 								}}
 							>
-								{t("mediaStage.detectedLanguage", { language: detectedLanguage })}
+								{t("mediaStage.detectedLanguage", {
+									language: languageLabel(detectedLanguage, locale),
+								})}
 							</span>
 						) : null}
 					</div>
@@ -1900,7 +1896,7 @@ export function SourceTranscriptModal({
 								aria-label={t("mediaStage.regenerateAs")}
 								value={regenLang}
 								disabled={isTranscribing}
-								onChange={(e) => setRegenLang(e.target.value as TranscriptLanguage)}
+								onChange={(e) => setRegenLang(e.target.value as TranscriptLanguageCode)}
 								style={{
 									width: "100%",
 									padding: "10px 12px",
@@ -1911,9 +1907,9 @@ export function SourceTranscriptModal({
 									font: "500 13px var(--font-body)",
 								}}
 							>
-								{REGEN_LANGUAGES.map((code) => (
+								{regenLanguageOptions.map(({ code, label }) => (
 									<option key={code} value={code}>
-										{code === "auto" ? t("mediaStage.auto") : LANGUAGE_LABELS[code]}
+										{label}
 									</option>
 								))}
 							</select>
diff --git a/src/components/ai-edition/v4/MediaStage.tsx b/src/components/ai-edition/v4/MediaStage.tsx
index e69ff3452..f844bfca4 100644
--- a/src/components/ai-edition/v4/MediaStage.tsx
+++ b/src/components/ai-edition/v4/MediaStage.tsx
@@ -1,14 +1,18 @@
 import { ArrowDown, Film, Plus, RotateCw, Search, X } from "lucide-react";
 import { useMemo, useState } from "react";
 import { toast } from "sonner";
-import { useScopedT } from "@/contexts/I18nContext";
-import type { AxcutAsset } from "@/lib/ai-edition/schema";
+import { useI18n, useScopedT } from "@/contexts/I18nContext";
+import type { AxcutAsset, TranscriptLanguageCode } from "@/lib/ai-edition/schema";
 import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import {
 	useAssetTranscriptions,
 	useTranscriptionStore,
 } from "@/lib/ai-edition/store/transcriptionStore";
 import { formatSeconds } from "@/lib/ai-edition/timeline/format";
+import {
+	languageLabel,
+	sortedLanguageOptions,
+} from "@/lib/ai-edition/transcription/languageLabels";
 import type {
 	AssetTranscriptionStatus,
 	AssetTranscriptionView,
@@ -49,6 +53,7 @@ export function MediaStage({
 	onAddToTimeline: (assetId: string) => Promise<void>;
 }) {
 	const t = useScopedT("editor");
+	const { locale } = useI18n();
 	const projectId = useProjectStore((s) => s.projectId);
 	const document = useProjectStore((s) => s.document);
 	const addAsset = useProjectStore((s) => s.addAsset);
@@ -62,7 +67,11 @@ export function MediaStage({
 	const [busy, setBusy] = useState(false);
 	const [selectedId, setSelectedId] = useState<string | null>(null);
 	const [detailOpen, setDetailOpen] = useState(false);
-	const [lang, setLang] = useState("auto");
+	const [lang, setLang] = useState<TranscriptLanguageCode>("auto");
+	const regenLanguageOptions = useMemo(
+		() => sortedLanguageOptions(locale, t("mediaStage.auto")),
+		[locale, t],
+	);
 
 	const assets = document?.assets ?? [];
 	const filtered = useMemo(
@@ -335,7 +344,9 @@ export function MediaStage({
 											fontWeight: 600,
 										}}
 									>
-										{t("mediaStage.detectedLanguage", { language: transcript.language })}
+										{t("mediaStage.detectedLanguage", {
+											language: languageLabel(transcript.language, locale),
+										})}
 									</span>
 								) : null}
 							</div>
@@ -372,7 +383,7 @@ export function MediaStage({
 								<div style={{ display: "flex", gap: 8 }}>
 									<select
 										value={lang}
-										onChange={(e) => setLang(e.target.value)}
+										onChange={(e) => setLang(e.target.value as TranscriptLanguageCode)}
 										style={{
 											flex: 1,
 											minWidth: 0,
@@ -387,10 +398,11 @@ export function MediaStage({
 											outline: "none",
 										}}
 									>
-										<option value="auto">{t("mediaStage.auto")}</option>
-										<option value="en">English</option>
-										<option value="fr">Français</option>
-										<option value="es">Español</option>
+										{regenLanguageOptions.map(({ code, label }) => (
+											<option key={code} value={code}>
+												{label}
+											</option>
+										))}
 									</select>
 									<button
 										type="button"
diff --git a/src/lib/ai-edition/schema/index.ts b/src/lib/ai-edition/schema/index.ts
index 09743fa9e..dd6936fde 100644
--- a/src/lib/ai-edition/schema/index.ts
+++ b/src/lib/ai-edition/schema/index.ts
@@ -811,19 +811,124 @@ export const chatInputSchema = z.object({
 	message: z.string().trim().min(1),
 });
 
-export const transcriptLanguageSchema = z.enum([
+// Every code whisper.cpp's multilingual model can resolve, plus "auto" for
+// detection. Codes and order mirror whisper.cpp's own `g_lang` table
+// (`src/whisper.cpp`, verified against the tag `nix/whisper-stt.nix` pins —
+// v1.9.1) — `wparams.language` in
+// electron/native/whisper-stt/src/main.cpp forwards the code verbatim, so a
+// value outside this list fails to resolve a language id there. "auto" is
+// always index 0 — code that needs "every real language, no sentinel" relies
+// on that (see `WhisperLanguageCode` below) rather than filtering it out.
+// Consumed by both "Regenerate as" pickers: `MediaStage.tsx` (the one
+// actually mounted by `NewEditorShell`) and `Modals.tsx`'s
+// `SourceTranscriptModal` (currently unreachable — `LeftPanel` is only ever
+// mounted with `active="chat"` — but kept correct rather than deleted, since
+// nothing marks it dead code and a test or a future rewire could reach it).
+export const TRANSCRIPT_LANGUAGE_CODES = [
 	"auto",
 	"en",
-	"fr",
+	"zh",
 	"de",
 	"es",
-	"it",
+	"ru",
+	"ko",
+	"fr",
+	"ja",
 	"pt",
+	"tr",
+	"pl",
+	"ca",
 	"nl",
-	"ja",
-	"ko",
-	"zh",
-]);
+	"ar",
+	"sv",
+	"it",
+	"id",
+	"hi",
+	"fi",
+	"vi",
+	"he",
+	"uk",
+	"el",
+	"ms",
+	"cs",
+	"ro",
+	"da",
+	"hu",
+	"ta",
+	"no",
+	"th",
+	"ur",
+	"hr",
+	"bg",
+	"lt",
+	"la",
+	"mi",
+	"ml",
+	"cy",
+	"sk",
+	"te",
+	"fa",
+	"lv",
+	"bn",
+	"sr",
+	"az",
+	"sl",
+	"kn",
+	"et",
+	"mk",
+	"br",
+	"eu",
+	"is",
+	"hy",
+	"ne",
+	"mn",
+	"bs",
+	"kk",
+	"sq",
+	"sw",
+	"gl",
+	"mr",
+	"pa",
+	"si",
+	"km",
+	"sn",
+	"yo",
+	"so",
+	"af",
+	"oc",
+	"ka",
+	"be",
+	"tg",
+	"sd",
+	"gu",
+	"am",
+	"yi",
+	"lo",
+	"uz",
+	"fo",
+	"ht",
+	"ps",
+	"tk",
+	"nn",
+	"mt",
+	"sa",
+	"lb",
+	"my",
+	"bo",
+	"tl",
+	"mg",
+	"as",
+	"tt",
+	"haw",
+	"ln",
+	"ha",
+	"ba",
+	"jw",
+	"su",
+	"yue",
+] as const;
+
+export const transcriptLanguageSchema = z.enum(TRANSCRIPT_LANGUAGE_CODES);
 
 export type AxcutWord = z.infer<typeof wordSchema>;
 export type AxcutTranscriptSegment = z.infer<typeof transcriptSegmentSchema>;
@@ -845,6 +950,9 @@ export type AxcutDocumentInput = z.input<typeof documentSchema>;
 export type CreateProjectInput = z.infer<typeof createProjectInputSchema>;
 export type AddAssetInput = z.infer<typeof addAssetInputSchema>;
 export type ChatInput = z.infer<typeof chatInputSchema>;
+export type TranscriptLanguageCode = z.infer<typeof transcriptLanguageSchema>;
+/** A real whisper.cpp language code — `TranscriptLanguageCode` minus the "auto" detection sentinel. */
+export type WhisperLanguageCode = Exclude<TranscriptLanguageCode, "auto">;
 
 export function createEmptyDocument(
 	input: CreateProjectInput & { projectId: string; createdAt?: string },
diff --git a/src/lib/ai-edition/transcription/languageLabels.ts b/src/lib/ai-edition/transcription/languageLabels.ts
new file mode 100644
index 000000000..02f2f08e8
--- /dev/null
+++ b/src/lib/ai-edition/transcription/languageLabels.ts
@@ -0,0 +1,182 @@
+// Turns a whisper.cpp language code into text a user can read. Shared by
+// every "Regenerate as" picker and detected-language pill so they can't
+// disagree with each other the way a hand-duplicated label map would.
+import {
+	TRANSCRIPT_LANGUAGE_CODES,
+	type TranscriptLanguageCode,
+	type WhisperLanguageCode,
+} from "../schema";
+
+/**
+ * English fallback name per code, from whisper.cpp's own `g_lang` table.
+ * `languageLabel` prefers `Intl.DisplayNames` in the active locale and falls
+ * back to this when that can't resolve a name (e.g. an unusual code on an
+ * older ICU).
+ */
+const ENGLISH_NAMES: Record<WhisperLanguageCode, string> = {
+	en: "English",
+	zh: "Chinese",
+	de: "German",
+	es: "Spanish",
+	ru: "Russian",
+	ko: "Korean",
+	fr: "French",
+	ja: "Japanese",
+	pt: "Portuguese",
+	tr: "Turkish",
+	pl: "Polish",
+	ca: "Catalan",
+	nl: "Dutch",
+	ar: "Arabic",
+	sv: "Swedish",
+	it: "Italian",
+	id: "Indonesian",
+	hi: "Hindi",
+	fi: "Finnish",
+	vi: "Vietnamese",
+	he: "Hebrew",
+	uk: "Ukrainian",
+	el: "Greek",
+	ms: "Malay",
+	cs: "Czech",
+	ro: "Romanian",
+	da: "Danish",
+	hu: "Hungarian",
+	ta: "Tamil",
+	no: "Norwegian",
+	th: "Thai",
+	ur: "Urdu",
+	hr: "Croatian",
+	bg: "Bulgarian",
+	lt: "Lithuanian",
+	la: "Latin",
+	mi: "Maori",
+	ml: "Malayalam",
+	cy: "Welsh",
+	sk: "Slovak",
+	te: "Telugu",
+	fa: "Persian",
+	lv: "Latvian",
+	bn: "Bengali",
+	sr: "Serbian",
+	az: "Azerbaijani",
+	sl: "Slovenian",
+	kn: "Kannada",
+	et: "Estonian",
+	mk: "Macedonian",
+	br: "Breton",
+	eu: "Basque",
+	is: "Icelandic",
+	hy: "Armenian",
+	ne: "Nepali",
+	mn: "Mongolian",
+	bs: "Bosnian",
+	kk: "Kazakh",
+	sq: "Albanian",
+	sw: "Swahili",
+	gl: "Galician",
+	mr: "Marathi",
+	pa: "Punjabi",
+	si: "Sinhala",
+	km: "Khmer",
+	sn: "Shona",
+	yo: "Yoruba",
+	so: "Somali",
+	af: "Afrikaans",
+	oc: "Occitan",
+	ka: "Georgian",
+	be: "Belarusian",
+	tg: "Tajik",
+	sd: "Sindhi",
+	gu: "Gujarati",
+	am: "Amharic",
+	yi: "Yiddish",
+	lo: "Lao",
+	uz: "Uzbek",
+	fo: "Faroese",
+	ht: "Haitian Creole",
+	ps: "Pashto",
+	tk: "Turkmen",
+	nn: "Norwegian Nynorsk",
+	mt: "Maltese",
+	sa: "Sanskrit",
+	lb: "Luxembourgish",
+	my: "Myanmar",
+	bo: "Tibetan",
+	tl: "Tagalog",
+	mg: "Malagasy",
+	as: "Assamese",
+	tt: "Tatar",
+	haw: "Hawaiian",
+	ln: "Lingala",
+	ha: "Hausa",
+	ba: "Bashkir",
+	jw: "Javanese",
+	su: "Sundanese",
+	yue: "Cantonese",
+};
+
+// Caches both success AND failure (`null`) per locale, so a locale whose ICU
+// data can't build a language `Intl.DisplayNames` (e.g. a small-icu runtime)
+// pays the throwing constructor once per locale, not once per language code.
+const displayNamesCache = new Map<string, Intl.DisplayNames | null>();
+
+function displayNamesFor(locale: string): Intl.DisplayNames | null {
+	if (displayNamesCache.has(locale)) return displayNamesCache.get(locale) ?? null;
+	let names: Intl.DisplayNames | null;
+	try {
+		names = new Intl.DisplayNames([locale], { type: "language" });
+	} catch {
+		names = null;
+	}
+	displayNamesCache.set(locale, names);
+	return names;
+}
+
+/**
+ * Localized name for a whisper.cpp language code, e.g. "jw" -> "Javanese" in
+ * an English UI, "japonais" in a French one. Falls back to whisper's own
+ * English name (`ENGLISH_NAMES`) when the active locale's ICU data can't
+ * resolve one — `Intl.DisplayNames` echoes the input code back rather than
+ * throwing when it doesn't recognize it.
+ *
+ * `code` is typed loosely (not `WhisperLanguageCode`): `AxcutTranscript.language`
+ * is `z.string().min(1)`, not validated against the known code list, so a
+ * detected-language pill can hand this any non-empty string. Falls back to
+ * the raw code itself — never `undefined` — when neither ICU nor
+ * `ENGLISH_NAMES` recognizes it.
+ */
+export function languageLabel(code: string, locale: string): string {
+	try {
+		const resolved = displayNamesFor(locale)?.of(code);
+		if (resolved && resolved.toLowerCase() !== code.toLowerCase()) return resolved;
+	} catch {
+		// Malformed/unsupported subtag for this Intl implementation.
+	}
+	return ENGLISH_NAMES[code as WhisperLanguageCode] ?? code;
+}
+
+export interface LanguageOption {
+	code: TranscriptLanguageCode;
+	label: string;
+}
+
+/**
+ * Every language option for a "Regenerate as" picker: "auto" pinned first
+ * with the caller's own translated label for it, the rest sorted by
+ * localized name so a 100-language list is scannable instead of ordered by
+ * whisper's internal language id.
+ */
+export function sortedLanguageOptions(locale: string, autoLabel: string): LanguageOption[] {
+	let compare: (a: string, b: string) => number;
+	try {
+		compare = new Intl.Collator(locale).compare;
+	} catch {
+		compare = (a, b) => a.localeCompare(b);
+	}
+	// TRANSCRIPT_LANGUAGE_CODES always starts with "auto" (see its own comment).
+	const rest = (TRANSCRIPT_LANGUAGE_CODES.slice(1) as WhisperLanguageCode[])
+		.map((code) => ({ code, label: languageLabel(code, locale) }))
+		.sort((a, b) => compare(a.label, b.label));
+	return [{ code: "auto", label: autoLabel }, ...rest];
+}
diff --git a/technical-documentation/architecture/transcription-and-captions.md b/technical-documentation/architecture/transcription-and-captions.md
index 02bf9ae8b..df899cda3 100644
--- a/technical-documentation/architecture/transcription-and-captions.md
+++ b/technical-documentation/architecture/transcription-and-captions.md
@@ -636,16 +636,34 @@ it deletes data
 
 ## Known gaps
 
-- **No language selector in the UI.** The renderer always sends
-  `language: "auto"`. Forcing a language would skip detection on the
-  first window and slightly improve WER. Needs a UI control wired
-  through `setTranscript` and a mapping from the UI string to a
-  whisper.cpp language token.
+- **Language selector.** The "Regenerate as" picker offers `"auto"` plus
+  every language the `small` multilingual model resolves. There are two
+  copies of it in the tree — `MediaStage.tsx`'s Media stage panel
+  ([`src/components/ai-edition/v4/MediaStage.tsx`](../../src/components/ai-edition/v4/MediaStage.tsx)),
+  the one actually mounted by `NewEditorShell`, and `SourceTranscriptModal`
+  ([`src/components/ai-edition/Modals.tsx`](../../src/components/ai-edition/Modals.tsx)),
+  which is currently unreachable: `LeftPanel` (its only mount site) is only
+  ever rendered with `active="chat"` by `NewEditorShell.tsx`, so the
+  `MediaPane` branch that would render it never runs. Both are kept correct
+  rather than deleting the unreachable one, since nothing marks it dead code
+  and a future rewire could reach it. `TRANSCRIPT_LANGUAGE_CODES` in
+  [`src/lib/ai-edition/schema/index.ts`](../../src/lib/ai-edition/schema/index.ts)
+  mirrors whisper.cpp's own `g_lang` table verbatim — a code outside that
+  list fails to resolve a language id in `wparams.language`
+  (`electron/native/whisper-stt/src/main.cpp`) — and `languageLabel` /
+  `sortedLanguageOptions` in
+  [`src/lib/ai-edition/transcription/languageLabels.ts`](../../src/lib/ai-edition/transcription/languageLabels.ts)
+  are the single place both pickers build their options and labels from, so
+  the two copies cannot drift from each other the way two hand-duplicated
+  lists would. Option labels come from `Intl.DisplayNames` in the active UI
+  locale, falling back to whisper.cpp's own English name for a code that
+  locale's ICU data can't resolve. Forcing a language skips detection on the
+  first window and slightly improves WER.
 
   Note that `"auto"` is a *request* value only. The helper used to echo the
   request straight back into `detected_language`, so with no selector the field
   was permanently the literal string `"auto"`: the media stage's "detected
-  language" line ([`src/components/ai-edition/Modals.tsx:1763`](../../src/components/ai-edition/Modals.tsx:1763))
+  language" line ([`src/components/ai-edition/v4/MediaStage.tsx:347`](../../src/components/ai-edition/v4/MediaStage.tsx:347))
   displayed it verbatim, and `transcribe.ts` wrote it onto
   `AxcutTranscript.language`. It now reports `whisper_full_lang_id()` — the
   detected language under `"auto"`, the forced one otherwise.