From 3363f69c2890bc42334ff4111f7ddfc090b222f9 Mon Sep 17 00:00:00 2001
From: THEINAOG <216241348+IAnMove@users.noreply.github.com>
Date: Mon, 14 Sep 2026 17:21:03 +0200
Subject: [PATCH 1/3] Add reusable custom character voices from audio imports
 and microphone recordings

---
 README.md                                     |   4 +
 app/_launch_runtime.py                        |   1 +
 app/services/character_speech_definition.py   |  52 +++++-
 app/services/media_paths.py                   |  38 ++++-
 tests/test_custom_character_voice.py          | 160 ++++++++++++++++++
 .../characters/CharacterDefinitionEditor.tsx  |  19 ++-
 .../characters/CharacterKitSummary.tsx        |   2 +-
 .../characters/CharacterVoiceAudition.tsx     |  48 ++++++
 .../characters/CharacterVoiceFields.tsx       |  48 +++++-
 .../characters/CustomCharacterVoiceFields.tsx |  41 +++++
 .../characters/characterVoiceReference.ts     |  17 ++
 .../characters/useVoiceReferenceCapture.ts    |  43 +++++
 ui/src/features/scene3d/speech/microphone.ts  |   4 +-
 ui/src/features/series/SeriesVoiceFields.tsx  |   2 +-
 ui/src/i18n/locales/en/scene3dEditor.json     |  75 +++++++-
 ui/src/i18n/locales/es/scene3dEditor.json     |  75 +++++++-
 ui/src/lib/characterKit.ts                    |   5 +-
 ui/src/lib/characterVoice.ts                  |  54 +++++-
 ui/src/lib/characterVoiceCatalog.ts           |  15 ++
 ui/src/lib/sceneSpeech.ts                     |  19 ++-
 ui/tests/characterVoiceAudition.test.tsx      |  68 ++++++++
 ui/tests/customCharacterVoice.test.ts         |  96 +++++++++++
 ui/tests/customCharacterVoiceFields.test.tsx  | 131 ++++++++++++++
 23 files changed, 984 insertions(+), 33 deletions(-)
 create mode 100644 tests/test_custom_character_voice.py
 create mode 100644 ui/src/features/characters/CharacterVoiceAudition.tsx
 create mode 100644 ui/src/features/characters/CustomCharacterVoiceFields.tsx
 create mode 100644 ui/src/features/characters/characterVoiceReference.ts
 create mode 100644 ui/src/features/characters/useVoiceReferenceCapture.ts
 create mode 100644 ui/src/lib/characterVoiceCatalog.ts
 create mode 100644 ui/tests/characterVoiceAudition.test.tsx
 create mode 100644 ui/tests/customCharacterVoice.test.ts
 create mode 100644 ui/tests/customCharacterVoiceFields.test.tsx

diff --git a/README.md b/README.md
index 19e452c29..6a306620e 100644
--- a/README.md
+++ b/README.md
@@ -118,6 +118,10 @@ You can also enable production methods directly in **Series Lab → Shots**. For
 
 Location image prompts describe empty environments. Series Lab separates the physical setting and rendering style from character design and narrative occupants before generating. Use **Prepare environment prompt** in the location card to review the exact prompt first.
 
+Character Creator identifies each Qwen3 preset by its original language/profile and timbre. The nine presets can speak several languages, but none is natively Spanish. Use **Generate voice sample** with a Spanish or English sentence to hear the selected voice before saving or preparing mouths. Changing the voice cancels only that audition and stops the previous sample.
+
+Choose **Add your own voice: import or record** to use **Qwen3 Base** with a clean 3–30 second recording (up to 20 MB). Import an audio file or record with the microphone, name the voice, enter the exact recording transcript, and choose the language for new dialogue. Audition it, then **Save everything** on the character. Saved custom voices appear in the voice selector for other characters; new or regenerated native 2D/3D dialogue uses the stored recording and transcript. Existing takes remain available. Recording requires a browser with microphone support on HTTPS or localhost; importing also works over LAN HTTP. Audio samples are stored as persistent local uploads, and character metadata stores public references rather than machine-specific paths. No new model or recording is generated merely by selecting or saving a voice.
+
 Each **Canon → Characters** card also shows voice, 2D lip-sync and 3D lip-sync readiness. **Configure in Character Creator** opens a dedicated view for that exact character, carries over its reference image, and links the saved configuration by ID. The Series card keeps its library selector. **Save everything and return to Series Lab** saves voice, mouth images and placement together, then returns to the source character. A failed save retains the draft and keeps the editor open; a fully saved session can yield to the next character even after switching tabs. A voice can be saved without a 3D model. Save the character before opening its 2D mouth workshop or 3D face calibration. The mouth workshop has a rectangle whose width and height can be adjusted independently, a visible mouth-pack catalog with previews, explicit AI generation buttons, and a one-click prerecorded English voice sample for previewing mouth movement without generating speech. **Apply placement to all mouths** copies the current position, scale and rotation to all nine mouth shapes. **Try with their voice** previews the full isolated recording with the same phonetic analyzer as native shots, including pauses and resting-mouth closure; the separate quick text preview is approximate. Eyes and blinking are optional: keep the original drawing unless you want to add overlays. Review the cleaned base and mouth variants, then save the speech character. Dialogue shots open Character Creator directly; the advanced voice table links to the character card. AI video with native audio continues to use its generator's voice; the reusable TTS preset is used in the speech editor.
 
 ### Finish without regenerating
diff --git a/app/_launch_runtime.py b/app/_launch_runtime.py
index 4c0bb3ae9..bb0eaf324 100644
--- a/app/_launch_runtime.py
+++ b/app/_launch_runtime.py
@@ -1088,6 +1088,7 @@ def _resolve_request_media_path(
             uploads_root=os.path.join(os.getcwd(), "uploads"),
             workspace_root=_workspace_dir(workspace),
             kinds=kinds,
+            workspace_name=workspace or _get_active_workspace(),
         )
     except MediaPathNotAllowed:
         raise HTTPException(status_code=400, detail="Media path is not allowed") from None
diff --git a/app/services/character_speech_definition.py b/app/services/character_speech_definition.py
index dc58b0738..262dec2b4 100644
--- a/app/services/character_speech_definition.py
+++ b/app/services/character_speech_definition.py
@@ -2,7 +2,41 @@
 import json
 import math
 import re
-from urllib.parse import urlsplit, parse_qsl
+from urllib.parse import urlsplit, parse_qsl, unquote
+
+CHARACTER_VOICE_LANGUAGES = {"auto", "chinese", "english", "japanese", "korean", "german", "french", "russian", "portuguese", "spanish", "italian"}
+
+
+def _voice_reference_query(kind, raw):
+    if kind == "uploads":
+        if raw is not None:
+            raise ValueError("Upload references cannot contain query parameters.")
+        return
+    query = parse_qsl(raw or "", keep_blank_values=True)
+    if (len(query) != 1 or query[0][0] != "workspace"
+            or not re.fullmatch(r"[A-Za-z0-9_. -]{1,120}", query[0][1]) or query[0][1] in {".", ".."}):
+        raise ValueError("The reference recording needs its source workspace.")
+
+
+def normalize_character_voice_reference(value):
+    """Persistent same-origin audio only, with an explicit source workspace."""
+    if not isinstance(value, str) or not value or len(value) > 1200 or re.search(r"\s|[\\#]", value):
+        raise ValueError("Import a local reference recording first.")
+    match = re.fullmatch(r"/api/v1/(uploads|file)/([^?]+)(?:\?(.+))?", value)
+    if not match:
+        raise ValueError("Use a persistent local reference recording.")
+    if re.search(r"%(?![0-9a-fA-F]{2})", value):
+        raise ValueError("Invalid reference recording URL.")
+    try:
+        path = unquote(match[2], errors="strict")
+        unquote(match[3] or "", errors="strict")
+    except UnicodeDecodeError as error:
+        raise ValueError("Invalid reference recording URL.") from error
+    if (re.search(r"[\x00-\x1f\x7f\\%?#]", path) or any(not part or part.startswith(".") for part in path.split("/"))
+            or not re.search(r"\.(wav|mp3|m4a|aac|flac|ogg|opus)$", path, re.I)):
+        raise ValueError("Choose a local audio recording.")
+    _voice_reference_query(match[1], match[3])
+    return value
 
 
 def _asset_fields(value):
@@ -93,7 +127,23 @@ def normalize_speech3d(value):
     return result
 
 
+def _voice_text(value, limit):
+    return isinstance(value, str) and bool(value.strip()) and len(value) <= limit
+
+
+def _normalize_reference_voice(value):
+    if (set(value) != {"provider", "model", "voiceId", "name", "referenceAudio", "transcript", "language"}
+            or value.get("provider") != "local" or value.get("voiceId") != "reference"
+            or not _voice_text(value.get("name"), 120) or not _voice_text(value.get("transcript"), 4000)
+            or not isinstance(value.get("language"), str) or value["language"] not in CHARACTER_VOICE_LANGUAGES):
+        raise ValueError("Add a named local reference recording, its transcript and a supported language.")
+    return {**value, "name": value["name"].strip(), "transcript": value["transcript"].strip(),
+            "referenceAudio": normalize_character_voice_reference(value["referenceAudio"])}
+
+
 def normalize_character_voice(value):
+    if isinstance(value, dict) and value.get("model") == "qwen3_tts_base":
+        return _normalize_reference_voice(value)
     if not isinstance(value, dict) or set(value) - {"provider", "model", "voiceId", "instructions"}:
         raise ValueError("Store voice preferences only, never credentials.")
     if value.get("provider") != "local" or value.get("model") != "qwen3_tts_customvoice":
diff --git a/app/services/media_paths.py b/app/services/media_paths.py
index 277fb8a3a..4c93ef46d 100644
--- a/app/services/media_paths.py
+++ b/app/services/media_paths.py
@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import os
+import re
 from collections.abc import Iterable
+from urllib.parse import parse_qsl, unquote, urlsplit
 
 
 class MediaPathNotAllowed(ValueError):
@@ -31,12 +33,40 @@ def _is_contained(path: str, root: str) -> bool:
         return False
 
 
+def _canonical_media_path(value: str, uploads_root: str, workspace_root: str, workspace_name: str | None):
+    """Resolve the declared API root, without same-name fallback across roots."""
+    if any(ord(char) <= 32 or char in "\\#" for char in value) or re.search(r"%(?![0-9a-fA-F]{2})", value):
+        raise MediaPathNotAllowed("Invalid canonical media reference")
+    parsed = urlsplit(value)
+    upload_prefix, file_prefix = "/api/v1/uploads/", "/api/v1/file/"
+    if parsed.path.startswith(upload_prefix):
+        if parsed.query:
+            raise MediaPathNotAllowed("Upload references cannot contain query parameters")
+        root, relative = uploads_root, parsed.path[len(upload_prefix):]
+    elif parsed.path.startswith(file_prefix):
+        query = parse_qsl(parsed.query, keep_blank_values=True)
+        if len(query) != 1 or query[0] != ("workspace", workspace_name):
+            raise MediaPathNotAllowed("The reference workspace does not match its declared root")
+        root, relative = workspace_root, parsed.path[len(file_prefix):]
+    else:
+        raise MediaPathNotAllowed("Unsupported canonical media root")
+    try:
+        relative = unquote(relative, errors="strict")
+    except UnicodeDecodeError as error:
+        raise MediaPathNotAllowed("Invalid canonical media reference") from error
+    if (any(ord(char) < 32 or ord(char) == 127 or char == "\\" for char in relative)
+            or any(part in {"", ".", ".."} for part in relative.split("/"))):
+        raise MediaPathNotAllowed("Media path is not allowed")
+    return os.path.join(root, relative), root
+
+
 def resolve_permitted_media_path(
     value: str,
     *,
     uploads_root: str,
     workspace_root: str,
     kinds: Iterable[str] = ("audio", "video"),
+    workspace_name: str | None = None,
 ) -> str:
     """Resolve a media path contained in uploads or one workspace.
 
@@ -57,7 +87,12 @@ def resolve_permitted_media_path(
         raise MediaPathNotAllowed("Media roots are not available")
 
     raw = value.strip()
-    if os.path.isabs(raw) or os.path.splitdrive(raw)[0]:
+    if raw.startswith("/api/"):
+        canonical, declared_root = _canonical_media_path(raw, roots[0], roots[1], workspace_name)
+        # A canonical file may not follow a symlink into the other allowed root.
+        roots = (declared_root,)
+        raw_candidates = (canonical,)
+    elif os.path.isabs(raw) or os.path.splitdrive(raw)[0]:
         raw_candidates = (raw,)
     else:
         raw_candidates = (raw, *(os.path.join(root, raw) for root in roots))
@@ -165,4 +200,3 @@ def resolve_story_cover_audio(
         workspace_root=workspace_root,
         kinds=("audio",),
     )
-
diff --git a/tests/test_custom_character_voice.py b/tests/test_custom_character_voice.py
new file mode 100644
index 000000000..2f907c5f4
--- /dev/null
+++ b/tests/test_custom_character_voice.py
@@ -0,0 +1,160 @@
+import ast
+import asyncio
+import os
+from pathlib import Path
+from urllib.parse import quote
+
+import pytest
+from fastapi import HTTPException
+
+from app.services.character_kit_library import patch_character_kit, read_character_kit_library
+from app.services.character_speech_definition import normalize_character_voice
+from app.services.media_paths import MediaPathNotAllowed, resolve_permitted_media_path
+
+
+def voice():
+    return {"provider": "local", "model": "qwen3_tts_base", "voiceId": "reference", "name": "Narradora",
+            "referenceAudio": "/api/v1/uploads/audio/recording.wav", "transcript": "Esta es mi voz.", "language": "spanish"}
+
+
+def test_reference_voice_survives_library_reload_and_links_from_another_workspace(tmp_path):
+    custom = voice()
+    custom["referenceAudio"] = "/api/v1/file/assets/voice.wav?workspace=original"
+    kit = {"version": 1, "id": "narrator", "name": "Narrator", "style": "cutout", "poses": {},
+           "mouth": {}, "eyes": {}, "anchors": {}, "provenance": [], "voice": custom}
+    for workspace in ("original", "episode"):
+        patch_character_kit(str(tmp_path / workspace), "narrator", kit, base_revision=0)
+        assert read_character_kit_library(str(tmp_path / workspace))["kits"]["narrator"]["voice"] == custom
+    assert normalize_character_voice({**custom, "name": "  Narradora  ", "transcript": "  Esta es mi voz.  "}) == custom
+    preset = {"provider": "local", "model": "qwen3_tts_customvoice", "voiceId": "ryan", "instructions": "Warm"}
+    assert normalize_character_voice(preset) == preset
+
+
+@pytest.mark.parametrize("patch", [
+    {"name": ""}, {"name": " "}, {"name": "a" * 121}, {"name": 12}, {"transcript": ""}, {"transcript": "\n"},
+    {"transcript": "a" * 4001}, {"transcript": None}, {"referenceAudio": ""}, {"language": "martian"},
+    {"language": []}, {"voiceId": "ryan"}, {"provider": "remote"}, {"apiKey": "not-a-secret"}, {"instructions": "unsupported"},
+])
+def test_incomplete_or_unsupported_reference_voice_is_rejected(patch):
+    with pytest.raises(ValueError):
+        normalize_character_voice({**voice(), **patch})
+
+
+@pytest.mark.parametrize("key", list(voice()))
+def test_every_reference_voice_field_is_required(key):
+    incomplete = voice()
+    del incomplete[key]
+    with pytest.raises(ValueError):
+        normalize_character_voice(incomplete)
+
+
+@pytest.mark.parametrize("reference", [
+    "https://example.com/voice.wav", "//example.com/voice.wav", "blob:voice", "data:audio/wav;base64,AAAA",
+    "/home/private.wav", "/api/v1/uploads/../voice.wav", "/api/v1/uploads/%2e%2e/voice.wav",
+    "/api/v1/uploads/%252e%252e/voice.wav", "/api/v1/uploads/audio%5cvoice.wav", "/api/v1/uploads/.private/voice.wav",
+    "/api/v1/uploads/voice.wav?token=example", "/api/v1/uploads/voice.wav#fragment", "/api/v1/uploads/voice.wav?",
+    "/api/v1/uploads/voice.webm",
+    "/api/v1/uploads/voice%00.wav", "/api/v1/uploads/%ZZ.wav", "/api/v1/uploads/voice.json",
+    "/api/v1/uploads/voice wav.wav", "/api/v1/uploads//voice.wav", "/api/v1/file/voice.wav",
+    "/api/v1/file/voice.wav?workspace=", "/api/v1/file/voice.wav?workspace=..",
+    "/api/v1/file/voice.wav?workspace=one&workspace=two", "/api/v1/file/voice.wav?workspace=one&key=example",
+    "/api/v1/file/voice.wav?workspace=%ZZ", "/api/v1/file/voice.wav?workspace=%FF",
+])
+def test_remote_unsafe_or_ambiguous_reference_is_rejected(reference):
+    with pytest.raises(ValueError):
+        normalize_character_voice({**voice(), "referenceAudio": reference})
+
+
+@pytest.fixture
+def media_roots(tmp_path):
+    uploads, workspace = tmp_path / "uploads", tmp_path / "episode"
+    uploads.mkdir()
+    workspace.mkdir()
+    return uploads, workspace
+
+
+def resolve(reference, roots, workspace_name="original"):
+    return resolve_permitted_media_path(reference, uploads_root=str(roots[0]), workspace_root=str(roots[1]),
+                                        workspace_name=workspace_name, kinds=("audio",))
+
+
+def test_canonical_media_adoption_keeps_the_exact_root_even_with_colliding_names(media_roots):
+    uploads, workspace = media_roots
+    for root in media_roots:
+        (root / "same.wav").write_bytes(b"reference")
+    assert resolve("/api/v1/uploads/same.wav", media_roots) == str(uploads / "same.wav")
+    assert resolve("/api/v1/file/same.wav?workspace=original", media_roots) == str(workspace / "same.wav")
+    (workspace / "same.wav").unlink()
+    with pytest.raises(FileNotFoundError):
+        resolve("/api/v1/file/same.wav?workspace=original", media_roots)
+    (workspace / "nested").mkdir()
+    (workspace / "nested" / "mi voz.wav").write_bytes(b"reference")
+    assert resolve("/api/v1/file/nested%2Fmi%20voz.wav?workspace=original", media_roots) == str(workspace / "nested" / "mi voz.wav")
+
+
+@pytest.mark.parametrize("reference", [
+    "/api/v1/file/same.wav?workspace=wrong", "/api/v1/file/same.wav",
+    "/api/v1/file/same.wav?workspace=original&workspace=wrong", "/api/v1/file/same.wav?workspace=original&token=example",
+    "/api/v1/uploads/same.wav?token=example", "/api/v1/uploads/../episode/same.wav",
+    "/api/v1/uploads/%2e%2e/episode/same.wav", "/api/v1/file/%2e%2e/uploads/same.wav?workspace=original",
+    "/api/v1/uploads/audio%5csame.wav", "/api/v1/uploads/same%00.wav", "/api/v1/uploads/%ZZ.wav",
+    "/api/v1/uploads/same.wav#ignored", "/api/v1/uploads//same.wav",
+])
+def test_canonical_adoption_rejects_wrong_workspaces_and_traversal(media_roots, reference):
+    for root in media_roots:
+        (root / "same.wav").write_bytes(b"reference")
+    with pytest.raises(MediaPathNotAllowed):
+        resolve(reference, media_roots)
+
+
+def test_canonical_adoption_does_not_follow_a_symlink_into_another_allowed_root(media_roots):
+    uploads, workspace = media_roots
+    (uploads / "same.wav").write_bytes(b"reference")
+    try:
+        (workspace / "same.wav").symlink_to(uploads / "same.wav")
+    except (OSError, NotImplementedError):
+        pytest.skip("Symlinks unavailable")
+    with pytest.raises(MediaPathNotAllowed):
+        resolve("/api/v1/file/same.wav?workspace=original", media_roots)
+
+
+def test_legacy_adoption_remains_available_for_existing_audio_studio_callers(media_roots):
+    uploads, _ = media_roots
+    (uploads / "same.wav").write_bytes(b"reference")
+    assert resolve("same.wav", media_roots) == str(uploads / "same.wav")
+    assert resolve(str(uploads / "same.wav"), media_roots) == str(uploads / "same.wav")
+
+
+def test_audio_adopt_endpoint_uses_source_workspace_and_new_canonical_resolver(media_roots, monkeypatch):
+    """Execute the actual lightweight route functions without importing GPU runtimes."""
+    uploads, workspace = media_roots
+    monkeypatch.chdir(uploads.parent)
+    for root in media_roots:
+        (root / "same.wav").write_bytes(b"reference")
+    launch = Path(__file__).resolve().parents[1] / "app" / "_launch_runtime.py"
+    parsed = ast.parse(launch.read_text(encoding="utf-8"))
+    selected = [node for node in parsed.body if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+                and node.name in {"_resolve_request_media_path", "adopt_audio"}]
+    for node in selected:
+        node.decorator_list = []
+    seen_workspaces = []
+
+    def workspace_dir(name):
+        seen_workspaces.append(name)
+        return str(workspace)
+
+    namespace = {"os": os, "quote": quote, "Request": object, "HTTPException": HTTPException,
+                 "resolve_permitted_media_path": resolve_permitted_media_path, "MediaPathNotAllowed": MediaPathNotAllowed,
+                 "_workspace_dir": workspace_dir, "_get_active_workspace": lambda: "destination",
+                 "_probe_audio_duration": lambda _: 5}
+    exec(compile(ast.Module(body=selected, type_ignores=[]), str(launch), "exec"), namespace)
+
+    class Request:
+        async def json(self):
+            return {"audio_path": "/api/v1/file/same.wav?workspace=original", "workspace": "original"}
+
+    result = asyncio.run(namespace["adopt_audio"](Request()))
+    assert seen_workspaces == ["original"]
+    assert result["path"] == str(workspace / "same.wav")
+    assert result["duration_seconds"] == 5
+    assert result["url"].endswith("?workspace=original")
diff --git a/ui/src/features/characters/CharacterDefinitionEditor.tsx b/ui/src/features/characters/CharacterDefinitionEditor.tsx
index d9a9f7282..f83e4d93a 100644
--- a/ui/src/features/characters/CharacterDefinitionEditor.tsx
+++ b/ui/src/features/characters/CharacterDefinitionEditor.tsx
@@ -11,7 +11,7 @@ import { sourceRefFromOutput } from '../scene3d/slotSource'
 import { characterFromSlot, characterSlotPatch } from '../scene3d/speech/characterBinding'
 import { modelDigest } from '../scene3d/speech/profiles'
 import { CharacterVoiceFields } from './CharacterVoiceFields'
-import type { CharacterVoice } from '../../lib/characterVoice'
+import { isCharacterVoiceReady, type CharacterVoice } from '../../lib/characterVoice'
 import { randomUuid } from '../../lib/uuid'
 import { CharacterDefinitionSpeechTools } from './CharacterDefinitionSpeechTools'
 import type { CharacterDefinitionDraft } from './characterEditorHandoff'
@@ -80,13 +80,15 @@ function ScopedDefinition({ workspace, slot, disabled, initialKit, onSaved, onAp
   const [model, setModel] = useState<ApiOutput | undefined>(initialDraft?.model), [items, setItems] = useState<ApiOutput[]>([])
   const [busy, setBusy] = useState(false), [notice, setNotice] = useState('')
   const [workshopDirty, setWorkshopDirty] = useState(false), [workshopBusy, setWorkshopBusy] = useState(false)
+  const [voiceBusy, setVoiceBusy] = useState(false)
+  const speechBusy = workshopBusy || voiceBusy
   const workshopSave = useRef<SaveSpeechWorkshop | null>(null)
   const saving = useRef(false)
   const alive = useRef(true)
   const hasSlot = Boolean(slot)
   const kit = definitionKit(library, id, initialKit)
   const dirty = Boolean(kit && (name !== kit.name || JSON.stringify(voice) !== JSON.stringify(kit.voice) || model))
-  useEffect(() => { onBusyChange?.(busy || workshopBusy); return () => onBusyChange?.(false) }, [busy, workshopBusy, onBusyChange])
+  useEffect(() => { onBusyChange?.(busy || speechBusy); return () => onBusyChange?.(false) }, [busy, speechBusy, onBusyChange])
   useEffect(() => { onDirtyChange?.(dirty || workshopDirty); return () => onDirtyChange?.(false) }, [dirty, workshopDirty, onDirtyChange])
   useEffect(() => { onDraftChange?.({ name, voice, model }) }, [name, voice, model, onDraftChange])
   useEffect(() => {
@@ -103,7 +105,8 @@ function ScopedDefinition({ workspace, slot, disabled, initialKit, onSaved, onAp
     void task().catch(error => { if (alive.current) setNotice(error.message) }).finally(() => { if (alive.current) setBusy(false) })
   }
   const saveAll = async () => {
-    if (saving.current || workshopBusy || !canSaveDefinition(library, name, slot)) throw new Error(t('speech.busy'))
+    if (saving.current || speechBusy || !canSaveDefinition(library, name, slot)) throw new Error(t('speech.busy'))
+    if (!isCharacterVoiceReady(voice)) throw new Error(t('speech.customVoice.incomplete'))
     saving.current = true; setBusy(true); setNotice('')
     try {
       const update = (current?: CharacterKit) => definitionForSave(workspace, name, voice, current, slot, model)
@@ -125,7 +128,7 @@ function ScopedDefinition({ workspace, slot, disabled, initialKit, onSaved, onAp
     <h3 className="font-semibold text-text-primary">{t('speech.characterDefinition')}</h3>
     <p className="text-text-muted">{t('speech.definitionHint')}</p>
     <fieldset disabled={disabled || busy || !library} className={spacious ? 'space-y-6' : 'space-y-2'}>
-      <DefinitionIdentity library={library} initialKit={initialKit} id={id} disabled={lockIdentity || workshopDirty || workshopBusy}
+      <DefinitionIdentity library={library} initialKit={initialKit} id={id} disabled={lockIdentity || workshopDirty || speechBusy}
         onSelect={(nextId, next) => {
           setId(nextId); setNotice('')
           if (!slot) { setName(next?.name ?? ''); setVoice(next?.voice); setModel(undefined) }
@@ -138,14 +141,14 @@ function ScopedDefinition({ workspace, slot, disabled, initialKit, onSaved, onAp
       <label className="block">{t('speech.definitionName')}<input data-testid="character-name" maxLength={240}
         className="mt-1 min-h-10 w-full rounded border border-border bg-bg-primary px-2" value={name} onChange={e => setName(e.target.value)} /></label>
       <DefinitionModelInput slot={slot} kit={kit} items={items} model={model} workspace={workspace} onChoose={setModel} />
-      <CharacterVoiceFields value={voice} onChange={next => {
+      <CharacterVoiceFields key={id} workspace={workspace} value={voice} savedKits={Object.values(library?.kits ?? {})} onBusyChange={setVoiceBusy} onChange={next => {
         setVoice(next)
-        if (slot) onApply?.({ character: { id: slot.character?.id ?? slot.id, name: slot.character?.name ?? name, ...slot.character, voice: next } })
+        if (slot && isCharacterVoiceReady(next)) onApply?.({ character: { id: slot.character?.id ?? slot.id, name: slot.character?.name ?? name, ...slot.character, voice: next } })
       }} />
       <button data-testid="save-character" className="min-h-10 rounded border border-border px-3"
-        disabled={workshopBusy || !canSaveDefinition(library, name, slot)}
+        disabled={speechBusy || !isCharacterVoiceReady(voice) || !canSaveDefinition(library, name, slot)}
         onClick={() => { void saveAll().catch(() => undefined) }}>{busy ? t('speech.busy') : t('speech.saveCharacter')}</button>
-      <button className="min-h-10 px-2 underline" disabled={workshopDirty || workshopBusy} onClick={() => run(async () => {
+      <button className="min-h-10 px-2 underline" disabled={workshopDirty || speechBusy} onClick={() => run(async () => {
         const saved = await fetchCharacterKitLibrary(workspace)
         if (!alive.current) return
         setLibrary(saved); setNotice(t('speech.libraryReloaded'))
diff --git a/ui/src/features/characters/CharacterKitSummary.tsx b/ui/src/features/characters/CharacterKitSummary.tsx
index 6de9e1983..106a901be 100644
--- a/ui/src/features/characters/CharacterKitSummary.tsx
+++ b/ui/src/features/characters/CharacterKitSummary.tsx
@@ -20,7 +20,7 @@ export function CharacterKitSummary({ kit }: { kit?: CharacterKit }) {
         <p className="font-medium text-text-primary">{kit.name}</p>
         <p>
           {tts.source === 'kit'
-            ? t('sheet.ttsVoice', { voiceId: tts.voiceId ?? '' })
+            ? t('sheet.ttsVoice', { voiceId: tts.voiceName ?? tts.voiceId ?? '' })
             : t('sheet.ttsNone')}
         </p>
         {kit.lookNotes?.trim() ? <p className="text-text-muted">{kit.lookNotes}</p> : null}
diff --git a/ui/src/features/characters/CharacterVoiceAudition.tsx b/ui/src/features/characters/CharacterVoiceAudition.tsx
new file mode 100644
index 000000000..4379be5bc
--- /dev/null
+++ b/ui/src/features/characters/CharacterVoiceAudition.tsx
@@ -0,0 +1,48 @@
+import { useEffect, useRef, useState } from 'react'
+import { getFileUrl } from '../../api/client'
+import { useUiTranslation } from '../../i18n'
+import type { CharacterVoice } from '../../lib/characterVoice'
+import { generateSceneSpeechClip } from '../../lib/sceneSpeech'
+
+/** An explicit voice-only audition: no saved character or mouth rig required. */
+export function CharacterVoiceAudition({ workspace, voice }: { workspace: string; voice: CharacterVoice }) {
+  const { t, i18n } = useUiTranslation('scene3dEditor')
+  const [language, setLanguage] = useState<'es' | 'en'>(i18n.resolvedLanguage?.startsWith('es') ? 'es' : 'en')
+  const [filename, setFilename] = useState(''), [error, setError] = useState(''), [busy, setBusy] = useState(false)
+  const controller = useRef<AbortController | null>(null)
+  const audio = useRef<HTMLAudioElement | null>(null)
+  const stopAudio = () => { if (audio.current && !audio.current.paused) audio.current.pause() }
+  useEffect(() => () => {
+    controller.current?.abort()
+    if (audio.current && !audio.current.paused) audio.current.pause()
+  }, [])
+  const cancel = () => { controller.current?.abort(); setBusy(false) }
+  const generate = async () => {
+    stopAudio()
+    const owner = new AbortController(); controller.current = owner
+    setBusy(true); setError(''); setFilename('')
+    try {
+      const sampleVoice = voice.model === 'qwen3_tts_base' ? { ...voice, language: language === 'es' ? 'spanish' as const : 'english' as const } : voice
+      const result = await generateSceneSpeechClip({ workspace, model: voice.model, durationSeconds: 20,
+        prompt: t(`speech.voiceAudition.sample.${language}`), signal: owner.signal, voice: sampleVoice })
+      if (!owner.signal.aborted) setFilename(result.filename)
+    } catch (cause) { if (!owner.signal.aborted) setError((cause as Error).message) }
+    finally { if (!owner.signal.aborted) setBusy(false) }
+  }
+  return <div className="space-y-2 rounded-lg border border-border bg-bg-primary p-3">
+    <label className="block">{t('speech.voiceAudition.language')}
+      <select className="ml-2 min-h-10 rounded border border-border bg-bg-secondary px-2" value={language} disabled={busy}
+        onChange={event => { stopAudio(); setLanguage(event.target.value as 'es' | 'en'); setFilename(''); setError('') }}>
+        <option value="es">Español</option><option value="en">English</option>
+      </select>
+    </label>
+    <p>{t(`speech.voiceAudition.sample.${language}`)}</p>
+    <button type="button" disabled={busy} className="min-h-10 rounded bg-cyan-400 px-3 font-semibold text-black disabled:opacity-50"
+      onClick={() => void generate()}>{t(busy ? 'speech.voiceAudition.generating' : 'speech.voiceAudition.generate')}</button>
+    {busy && <button type="button" className="ml-3 min-h-10 underline" onClick={cancel}>{t('speech.voiceAudition.cancel')}</button>}
+    {filename && <audio ref={node => { if (node) audio.current = node }} aria-label={t('speech.voiceAudition.audio')}
+      controls preload="metadata" src={getFileUrl(filename, workspace)} className="w-full" />}
+    <p className="text-text-muted">{t('speech.voiceAudition.hint')}</p>
+    {error && <p role="alert" className="text-red-300">{error}</p>}
+  </div>
+}
diff --git a/ui/src/features/characters/CharacterVoiceFields.tsx b/ui/src/features/characters/CharacterVoiceFields.tsx
index 1945535c7..8dc1f3c80 100644
--- a/ui/src/features/characters/CharacterVoiceFields.tsx
+++ b/ui/src/features/characters/CharacterVoiceFields.tsx
@@ -1,21 +1,53 @@
+import { useCallback, useState } from 'react'
 import { useUiTranslation } from '../../i18n'
-import { CHARACTER_VOICES, type CharacterVoice } from '../../lib/characterVoice'
+import { CHARACTER_VOICES, isCharacterVoiceReady, type CharacterVoice } from '../../lib/characterVoice'
+import type { CharacterKit } from '../../lib/characterKit'
+import { CHARACTER_VOICE_PROFILES } from '../../lib/characterVoiceCatalog'
+import { CharacterVoiceAudition } from './CharacterVoiceAudition'
+import { CustomCharacterVoiceFields } from './CustomCharacterVoiceFields'
 
-export function CharacterVoiceFields({ value, onChange, disabled }: {
-  value?: CharacterVoice; onChange: (voice: CharacterVoice | undefined) => void; disabled?: boolean
+export function CharacterVoiceFields({ workspace, value, onChange, disabled, savedKits = [], onBusyChange }: {
+  workspace: string; value?: CharacterVoice; onChange: (voice: CharacterVoice | undefined) => void; disabled?: boolean
+  savedKits?: CharacterKit[]; onBusyChange?: (busy: boolean) => void
 }) {
   const { t } = useUiTranslation('scene3dEditor')
+  const [capturing, setCapturing] = useState(false)
+  const captureBusy = useCallback((busy: boolean) => { setCapturing(busy); onBusyChange?.(busy) }, [onBusyChange])
+  const voiceId = CHARACTER_VOICES.find(id => id === value?.voiceId)
+  const profile = voiceId ? CHARACTER_VOICE_PROFILES[voiceId] : undefined
+  const custom = value?.model === 'qwen3_tts_base' ? value : undefined
+  const saved = savedKits.filter(kit => kit.voice?.model === 'qwen3_tts_base')
+  const select = (id: string) => {
+    if (id.startsWith('saved:')) { const kit = saved.find(kit => kit.id === id.slice(6)); if (kit?.voice) onChange(kit.voice); return }
+    if (id === 'new-reference') {
+      onChange({ provider: 'local', model: 'qwen3_tts_base', voiceId: 'reference', name: '', referenceAudio: '', transcript: '', language: 'auto' }); return
+    }
+    onChange(id ? { provider: 'local', model: 'qwen3_tts_customvoice', voiceId: id,
+      instructions: value?.model === 'qwen3_tts_customvoice' ? value.instructions : undefined } : undefined)
+  }
   return <fieldset disabled={disabled} className="space-y-2 text-xs">
     <label className="block">{t('speech.libraryVoice')}
-      <select data-testid="character-voice" className="mt-1 min-h-10 w-full rounded border border-border bg-bg-primary px-2" value={value?.voiceId ?? ''}
-        onChange={e => onChange(e.target.value ? { provider: 'local', model: 'qwen3_tts_customvoice', voiceId: e.target.value, instructions: value?.instructions } : undefined)}>
+      <select data-testid="character-voice" disabled={capturing} className="mt-1 min-h-10 w-full rounded border border-border bg-bg-primary px-2" value={value?.voiceId ?? ''}
+        onChange={e => select(e.target.value)}>
         <option value="">{t('speech.noPreferredVoice')}</option>
-        {CHARACTER_VOICES.map(id => <option key={id} value={id}>Qwen3 · {id}</option>)}
+        {custom && <option value="reference">{custom.name || t('speech.customVoice.selected')}</option>}
+        <option value="new-reference">{t('speech.customVoice.add')}</option>
+        {saved.length > 0 && <optgroup label={t('speech.customVoice.saved')}>
+          {saved.map(kit => <option key={kit.id} value={`saved:${kit.id}`}>{kit.voice?.model === 'qwen3_tts_base' ? kit.voice.name : kit.name} · {kit.name}</option>)}
+        </optgroup>}
+        {CHARACTER_VOICES.map(id => <option key={id} value={id}>{CHARACTER_VOICE_PROFILES[id].name} · {t(`speech.voiceOrigins.${CHARACTER_VOICE_PROFILES[id].origin}`)}</option>)}
       </select>
     </label>
-    {value && <label className="block">{t('speech.voiceDirection')}<textarea maxLength={1000} rows={2}
+    {profile && voiceId && <div className="space-y-1">
+      <p className="font-medium">{t(`speech.voiceProfiles.${voiceId}`)}</p>
+      <p className="text-text-secondary">{t('speech.voiceOrigin', { language: t(`speech.voiceOrigins.${profile.origin}`) })}</p>
+    </div>}
+    {custom && <CustomCharacterVoiceFields value={custom} onChange={onChange} onBusyChange={captureBusy} />}
+    {value?.model === 'qwen3_tts_customvoice' && <label className="block">{t('speech.voiceDirection')}<textarea maxLength={1000} rows={2}
       className="mt-1 w-full rounded border border-border bg-bg-primary p-2" value={value.instructions ?? ''}
       onChange={e => onChange({ ...value, instructions: e.target.value })} /></label>}
-    <p className="text-text-muted">{t('speech.voiceHint')}</p>
+    {!custom && <p className="text-text-muted">{t('speech.voiceHint')}</p>}
+    {value && !capturing && isCharacterVoiceReady(value) && <CharacterVoiceAudition key={JSON.stringify([workspace, value])} workspace={workspace} voice={value} />}
+    {custom && !isCharacterVoiceReady(custom) && <p role="status" className="text-amber-200">{t('speech.customVoice.incomplete')}</p>}
   </fieldset>
 }
diff --git a/ui/src/features/characters/CustomCharacterVoiceFields.tsx b/ui/src/features/characters/CustomCharacterVoiceFields.tsx
new file mode 100644
index 000000000..35ffedcac
--- /dev/null
+++ b/ui/src/features/characters/CustomCharacterVoiceFields.tsx
@@ -0,0 +1,41 @@
+import { useUiTranslation } from '../../i18n'
+import { CHARACTER_VOICE_LANGUAGES, type CustomCharacterVoice } from '../../lib/characterVoice'
+import { VoicePreview } from '../scene3d/speech/VoicePreview'
+import { useVoiceReferenceCapture } from './useVoiceReferenceCapture'
+
+const input = 'mt-1 min-h-10 w-full rounded border border-border bg-bg-primary p-2'
+const button = 'min-h-10 rounded border border-border px-3 disabled:opacity-50'
+
+export function CustomCharacterVoiceFields({ value, onChange, onBusyChange }: {
+  value: CustomCharacterVoice; onChange: (voice: CustomCharacterVoice) => void; onBusyChange?: (busy: boolean) => void
+}) {
+  const { t } = useUiTranslation('scene3dEditor')
+  const capture = useVoiceReferenceCapture(referenceAudio => onChange({ ...value, referenceAudio, transcript: '' }), onBusyChange)
+  const busy = capture.state !== 'idle'
+  return <div className="space-y-3 rounded-lg border border-border p-3" data-testid="custom-character-voice">
+    <p>{t('speech.customVoice.hint')}</p>
+    <fieldset disabled={busy} className="space-y-3">
+      <label className="block">{t('speech.customVoice.name')}<input className={input} maxLength={120} value={value.name}
+        onChange={event => onChange({ ...value, name: event.target.value })} /></label>
+      <label className="block">{t('speech.customVoice.import')}<input className={input} type="file" accept="audio/*,.wav,.mp3,.m4a,.flac,.ogg,.webm"
+        onChange={event => { const file = event.target.files?.[0]; event.target.value = ''; if (file) capture.importAudio(file) }} /></label>
+      <button type="button" className={button} onClick={capture.record}>{t('speech.customVoice.record')}</button>
+      <p className="text-text-muted">{t('speech.customVoice.recordHint')}</p>
+      <label className="block">{t('speech.customVoice.transcript')}<textarea className={input} rows={3} maxLength={4000}
+        placeholder={t('speech.customVoice.transcriptPlaceholder')} value={value.transcript}
+        onChange={event => onChange({ ...value, transcript: event.target.value })} /></label>
+      <label className="block">{t('speech.customVoice.language')}<select className={input} value={value.language}
+        onChange={event => onChange({ ...value, language: event.target.value as CustomCharacterVoice['language'] })}>
+        {CHARACTER_VOICE_LANGUAGES.map(language => <option key={language} value={language}>{t(`speech.customVoice.languages.${language}`)}</option>)}
+      </select></label>
+    </fieldset>
+    {capture.state !== 'idle' && <div className="flex flex-wrap items-center gap-3">
+      <span role="status">{t(`speech.customVoice.states.${capture.state}`)}</span>
+      {capture.state === 'recording' && <button type="button" className={button} onClick={capture.stop}>{t('speech.stopRecording')}</button>}
+      <button type="button" className={button} onClick={capture.cancel}>{t('speech.cancelRecording')}</button>
+    </div>}
+    {value.referenceAudio && <VoicePreview url={value.referenceAudio} disabled={busy} label={t('speech.customVoice.referencePreview')} />}
+    <p className="text-text-muted">{t('speech.customVoice.saveHint')}</p>
+    {capture.error && <p role="alert" className="text-red-300">{capture.error}</p>}
+  </div>
+}
diff --git a/ui/src/features/characters/characterVoiceReference.ts b/ui/src/features/characters/characterVoiceReference.ts
new file mode 100644
index 000000000..066e32dc7
--- /dev/null
+++ b/ui/src/features/characters/characterVoiceReference.ts
@@ -0,0 +1,17 @@
+import { uploadLocalAsset } from '../asset-picker/upload'
+import { voiceWav } from '../scene3d/speech/audio'
+
+/** Normalize both browser recordings and imported audio before storing a reusable voice. */
+export async function uploadVoiceReference(blob: Blob, signal: AbortSignal): Promise<string> {
+  if (!blob.size || blob.size > 20 * 1024 * 1024) throw new Error('voiceFileSize')
+  signal.throwIfAborted()
+  let buffer: AudioBuffer
+  try { buffer = await new OfflineAudioContext(1, 1, 24000).decodeAudioData(await blob.arrayBuffer()) }
+  catch { throw new Error('voiceFileDecode') }
+  signal.throwIfAborted()
+  if (!Number.isFinite(buffer.duration) || buffer.duration < 3 || buffer.duration > 30) throw new Error('voiceFileDuration')
+  const wav = await voiceWav(buffer)
+  signal.throwIfAborted()
+  const uploaded = await uploadLocalAsset(new File([wav], 'voice-reference.wav', { type: 'audio/wav' }), signal)
+  return uploaded.url
+}
diff --git a/ui/src/features/characters/useVoiceReferenceCapture.ts b/ui/src/features/characters/useVoiceReferenceCapture.ts
new file mode 100644
index 000000000..7f61d4e7f
--- /dev/null
+++ b/ui/src/features/characters/useVoiceReferenceCapture.ts
@@ -0,0 +1,43 @@
+import { useEffect, useRef, useState } from 'react'
+import { useUiTranslation } from '../../i18n'
+import { recordMicrophone } from '../scene3d/speech/microphone'
+import { uploadVoiceReference } from './characterVoiceReference'
+
+export function useVoiceReferenceCapture(onAudio: (url: string) => void, onBusyChange?: (busy: boolean) => void) {
+  const { t } = useUiTranslation('scene3dEditor')
+  const [state, setState] = useState<'idle' | 'permission' | 'recording' | 'uploading'>('idle')
+  const [error, setError] = useState('')
+  const owner = useRef<AbortController | null>(null), stop = useRef<() => void>(() => {})
+  useEffect(() => () => owner.current?.abort(), [])
+  useEffect(() => { onBusyChange?.(state !== 'idle'); return () => onBusyChange?.(false) }, [state, onBusyChange])
+  const cancel = () => { owner.current?.abort(); setState('idle') }
+  const fail = (cause: unknown, signal: AbortSignal) => {
+    if (signal.aborted) return
+    const error = cause as Error
+    const known = (['voiceFileSize', 'voiceFileDecode', 'voiceFileDuration'] as const).find(key => key === error.message)
+    setError(known ? t(`speech.customVoice.${known}`) : error.name === 'NotAllowedError'
+      ? t('speech.microphoneDenied') : error.message || t('speech.recordingFailed'))
+    setState('idle')
+  }
+  const upload = async (blob: Blob, signal: AbortSignal) => {
+    setState('uploading')
+    try { const url = await uploadVoiceReference(blob, signal); if (!signal.aborted) { onAudio(url); setState('idle') } }
+    catch (cause) { fail(cause, signal) }
+  }
+  const importAudio = (file: File) => {
+    owner.current?.abort(); const request = new AbortController(); owner.current = request; setError('')
+    void upload(file, request.signal)
+  }
+  const record = () => {
+    if (!window.isSecureContext || !navigator.mediaDevices?.getUserMedia || typeof MediaRecorder === 'undefined') {
+      setError(t('speech.customVoice.microphoneUnavailable')); return
+    }
+    owner.current?.abort(); const request = new AbortController(); owner.current = request
+    setError(''); setState('permission')
+    void recordMicrophone(request.signal, {
+      onRecording: () => setState('recording'), onComplete: blob => { void upload(blob, request.signal) },
+      onError: cause => fail(cause, request.signal),
+    }, 30).then(finish => { if (!request.signal.aborted) stop.current = finish }).catch(cause => fail(cause, request.signal))
+  }
+  return { state, error, cancel, importAudio, record, stop: () => stop.current() }
+}
diff --git a/ui/src/features/scene3d/speech/microphone.ts b/ui/src/features/scene3d/speech/microphone.ts
index a5438a84b..900fa2b64 100644
--- a/ui/src/features/scene3d/speech/microphone.ts
+++ b/ui/src/features/scene3d/speech/microphone.ts
@@ -4,7 +4,7 @@ export type MicrophoneCallbacks = {
   onError: (error: unknown) => void
 }
 /** Owns only this recording's stream. Aborting also handles late permission grants. */
-export async function recordMicrophone(signal: AbortSignal, callbacks: MicrophoneCallbacks): Promise<() => void> {
+export async function recordMicrophone(signal: AbortSignal, callbacks: MicrophoneCallbacks, maxSeconds = 90): Promise<() => void> {
   const stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false })
   const stopTracks = () => stream.getTracks().forEach(track => track.stop())
   if (signal.aborted) { stopTracks(); return () => {} }
@@ -30,7 +30,7 @@ export async function recordMicrophone(signal: AbortSignal, callbacks: Microphon
   }
   try {
     recorder.start(250)
-    timer = setTimeout(stop, 90000)
+    timer = setTimeout(stop, Math.min(90, Math.max(1, maxSeconds)) * 1000)
     callbacks.onRecording()
   } catch (error) { cleanup(); throw error }
   return stop
diff --git a/ui/src/features/series/SeriesVoiceFields.tsx b/ui/src/features/series/SeriesVoiceFields.tsx
index 8c9bc7e04..3a1a673a6 100644
--- a/ui/src/features/series/SeriesVoiceFields.tsx
+++ b/ui/src/features/series/SeriesVoiceFields.tsx
@@ -47,7 +47,7 @@ export function SeriesVoiceFields({
               <input className={inputClass} value={String(kitOwnsTts ? tts.provider || '' : character.voiceProfile?.provider || '')} disabled={kitOwnsTts} onChange={event => onPatchVoice(index, { provider: event.target.value })} />
             </SeriesField>
             <SeriesField label={t('canon.voiceId')} hint={t('canon.voiceIdHint')}>
-              <input className={inputClass} value={String(kitOwnsTts ? tts.voiceId || '' : character.voiceProfile?.voiceId || '')} disabled={kitOwnsTts} onChange={event => onPatchVoice(index, { voiceId: event.target.value })} />
+              <input className={inputClass} value={String(kitOwnsTts ? tts.voiceName || tts.voiceId || '' : character.voiceProfile?.voiceId || '')} disabled={kitOwnsTts} onChange={event => onPatchVoice(index, { voiceId: event.target.value })} />
             </SeriesField>
             <SeriesField label={t('canon.language')}>
               <input className={inputClass} value={String(character.voiceProfile?.language || '')} onChange={event => onPatchVoice(index, { language: event.target.value })} />
diff --git a/ui/src/i18n/locales/en/scene3dEditor.json b/ui/src/i18n/locales/en/scene3dEditor.json
index 9720d6f45..2b3c0dc4e 100644
--- a/ui/src/i18n/locales/en/scene3dEditor.json
+++ b/ui/src/i18n/locales/en/scene3dEditor.json
@@ -17,7 +17,7 @@
     "libraryVoice": "Preferred voice (optional)",
     "noPreferredVoice": "No preferred voice · use existing audio",
     "voiceDirection": "Voice direction (optional)",
-    "voiceHint": "Local Qwen3 CustomVoice. Language is detected from the text. Requires the model installed; no credentials or automatic audio generation.",
+    "voiceHint": "Qwen3 CustomVoice supports several languages, but none of these nine original voices is native Spanish. Pronunciation and accent vary across languages: listen to a sample before choosing. Voice direction can influence delivery; it does not guarantee a different accent.",
     "generateVoice": "Generate this line's voice",
     "attachGeneratedVoice": "Apply already generated audio",
     "existingAudioWins": "This line already has audio: reuse it without generating another voice.",
@@ -205,7 +205,78 @@
     "optionalModel": "3D model (optional; not required for voice or 2D characters)",
     "configure2d": "Configure 2D mouth and lip sync",
     "need2dImage": "For 2D lip sync, add an image and save the character. You can do this in Characters or from its reference in Series Lab.",
-    "configureLibraryCharacter": "Configure voice and lip sync for {{name}}"
+    "configureLibraryCharacter": "Configure voice and lip sync for {{name}}",
+    "voiceOrigin": "Original language/profile: {{language}}",
+    "voiceOrigins": {
+      "chinese": "Chinese",
+      "beijing": "Chinese · Beijing",
+      "sichuan": "Chinese · Sichuan",
+      "english": "English",
+      "americanEnglish": "American English",
+      "japanese": "Japanese",
+      "korean": "Korean"
+    },
+    "voiceProfiles": {
+      "vivian": "Young female voice, bright with a slight edge.",
+      "serena": "Young female voice, warm and gentle.",
+      "uncle_fu": "Mature male voice, low and mellow.",
+      "dylan": "Young male voice, clear and natural.",
+      "eric": "Lively male voice, bright and slightly husky.",
+      "ryan": "Dynamic male voice with pronounced rhythm.",
+      "aiden": "Bright male voice with a clear midrange.",
+      "ono_anna": "Playful female voice, light and agile.",
+      "sohee": "Warm, expressive female voice."
+    },
+    "voiceAudition": {
+      "language": "Sample sentence language",
+      "sample": {
+        "es": "Hola, esta es mi voz. Así sueno al contar una historia en español.",
+        "en": "Hello, this is my voice. This is how I sound when telling a story in English."
+      },
+      "generate": "Generate voice sample",
+      "generating": "Generating sample…",
+      "cancel": "Cancel sample",
+      "audio": "Selected voice sample",
+      "hint": "Uses this voice and its current direction. Choosing a voice does not generate audio. This button creates a short recording in HocusPocus; no character save or mouth setup is needed."
+    },
+    "customVoice": {
+      "add": "Add your own voice: import or record",
+      "selected": "Custom voice",
+      "saved": "Custom voices saved with characters",
+      "name": "Voice name",
+      "hint": "Use a clean sample of one speaker, without music or other voices. Import or record 3–30 seconds, then enter exactly what it says. The model will use that voice to read new dialogue.",
+      "import": "Import audio sample",
+      "record": "Record with microphone",
+      "recordHint": "Recording stops after 30 seconds. You can read a 5–15 second sentence and copy it into the transcript.",
+      "referencePreview": "Original voice sample",
+      "transcript": "Exact sample transcript",
+      "transcriptPlaceholder": "Enter the same words heard in the audio. This is not the dialogue to generate.",
+      "language": "Language for new dialogue",
+      "saveHint": "Save the whole character to keep this voice. You can select it for other characters; new or regenerated shots will use that configuration.",
+      "incomplete": "To preview or save this voice, add its name, an audio sample, and its exact transcript.",
+      "voiceFileSize": "Choose a nonempty audio file up to 20 MB.",
+      "voiceFileDecode": "The browser could not decode this audio. Try WAV or MP3.",
+      "voiceFileDuration": "The sample must last 3–30 seconds. Trim the audio and keep the exact transcript of that segment.",
+      "microphoneUnavailable": "Browsers only allow the microphone on HTTPS or localhost. Open HocusPocus at one of those addresses, or import an audio file here.",
+      "states": {
+        "permission": "Allow microphone access in your browser…",
+        "recording": "Recording · 30 seconds maximum",
+        "uploading": "Saving audio sample…"
+      },
+      "languages": {
+        "auto": "Automatic from text",
+        "spanish": "Spanish",
+        "english": "English",
+        "chinese": "Chinese",
+        "japanese": "Japanese",
+        "korean": "Korean",
+        "german": "German",
+        "french": "French",
+        "russian": "Russian",
+        "portuguese": "Portuguese",
+        "italian": "Italian"
+      }
+    }
   },
   "title": "3D scene studio",
   "subtitle": "Choose a shot, place your objects and press Play.",
diff --git a/ui/src/i18n/locales/es/scene3dEditor.json b/ui/src/i18n/locales/es/scene3dEditor.json
index 80ce3ad82..275c8f943 100644
--- a/ui/src/i18n/locales/es/scene3dEditor.json
+++ b/ui/src/i18n/locales/es/scene3dEditor.json
@@ -17,7 +17,7 @@
     "libraryVoice": "Voz preferida (opcional)",
     "noPreferredVoice": "Sin voz preferida · usar audio existente",
     "voiceDirection": "Dirección de voz (opcional)",
-    "voiceHint": "Qwen3 CustomVoice local. Idioma detectado por el texto. Requiere el modelo instalado; no se guardan claves ni se genera audio automáticamente.",
+    "voiceHint": "Qwen3 CustomVoice habla varios idiomas, pero ninguna de estas nueve voces originales es nativa española. La pronunciación y el acento varían según el idioma: escucha una muestra antes de elegir. La dirección de voz puede influir en la interpretación; no garantiza cambiar el acento.",
     "generateVoice": "Generar voz de esta frase",
     "attachGeneratedVoice": "Aplicar audio ya generado",
     "existingAudioWins": "Esta frase ya tiene audio: se reutiliza y no se genera otra voz.",
@@ -205,7 +205,78 @@
     "optionalModel": "Modelo 3D (opcional; no hace falta para voz o personajes 2D)",
     "configure2d": "Configurar boca y lipsync 2D",
     "need2dImage": "Para lipsync 2D, añade una imagen al personaje y guarda su ficha. Puedes hacerlo en Personajes o desde su referencia en Series Lab.",
-    "configureLibraryCharacter": "Configurar voz y lipsync de {{name}}"
+    "configureLibraryCharacter": "Configurar voz y lipsync de {{name}}",
+    "voiceOrigin": "Idioma/perfil de origen: {{language}}",
+    "voiceOrigins": {
+      "chinese": "Chino",
+      "beijing": "Chino · Pekín",
+      "sichuan": "Chino · Sichuan",
+      "english": "Inglés",
+      "americanEnglish": "Inglés estadounidense",
+      "japanese": "Japonés",
+      "korean": "Coreano"
+    },
+    "voiceProfiles": {
+      "vivian": "Voz femenina joven, brillante y con un punto incisivo.",
+      "serena": "Voz femenina joven, cálida y suave.",
+      "uncle_fu": "Voz masculina madura, grave y aterciopelada.",
+      "dylan": "Voz masculina joven, clara y natural.",
+      "eric": "Voz masculina vivaz, brillante y algo ronca.",
+      "ryan": "Voz masculina dinámica, con ritmo marcado.",
+      "aiden": "Voz masculina luminosa, de registro medio claro.",
+      "ono_anna": "Voz femenina juguetona, ligera y ágil.",
+      "sohee": "Voz femenina cálida y expresiva."
+    },
+    "voiceAudition": {
+      "language": "Idioma de la frase de prueba",
+      "sample": {
+        "es": "Hola, esta es mi voz. Así sueno al contar una historia en español.",
+        "en": "Hello, this is my voice. This is how I sound when telling a story in English."
+      },
+      "generate": "Generar muestra de voz",
+      "generating": "Generando muestra…",
+      "cancel": "Cancelar muestra",
+      "audio": "Muestra de la voz seleccionada",
+      "hint": "Usa esta voz y su dirección actual. Elegir una voz no genera audio. Este botón crea una grabación breve en HocusPocus; no hace falta guardar el personaje ni configurar las bocas."
+    },
+    "customVoice": {
+      "add": "Añadir voz propia: importar o grabar",
+      "selected": "Voz propia",
+      "saved": "Voces propias guardadas en personajes",
+      "name": "Nombre de esta voz",
+      "hint": "Usa una muestra limpia de una sola persona, sin música ni otras voces. Importa o graba entre 3 y 30 segundos; después escribe exactamente lo que dice. El modelo usará su voz para leer diálogos nuevos.",
+      "import": "Importar muestra de audio",
+      "record": "Grabar con el micrófono",
+      "recordHint": "La grabación se detiene a los 30 segundos. Puedes leer una frase de 5–15 segundos y copiarla en la transcripción.",
+      "referencePreview": "Muestra original de la voz",
+      "transcript": "Texto exacto de la muestra",
+      "transcriptPlaceholder": "Escribe aquí las mismas palabras que se escuchan en el audio. No es el diálogo que se generará.",
+      "language": "Idioma para los nuevos diálogos",
+      "saveHint": "Guarda todo el personaje para conservar esta voz. Podrás elegirla en otros personajes; los planos nuevos o regenerados usarán esa configuración.",
+      "incomplete": "Para probar o guardar esta voz, añade su nombre, una muestra de audio y su transcripción exacta.",
+      "voiceFileSize": "Elige un audio de hasta 20 MB que no esté vacío.",
+      "voiceFileDecode": "El navegador no ha podido leer este audio. Prueba con WAV o MP3.",
+      "voiceFileDuration": "La muestra debe durar entre 3 y 30 segundos. Recorta el audio y conserva el texto exacto del fragmento.",
+      "microphoneUnavailable": "El navegador solo permite el micrófono desde HTTPS o localhost. Abre HocusPocus con una de esas direcciones, o importa un audio aquí.",
+      "states": {
+        "permission": "Permite el acceso al micrófono en el navegador…",
+        "recording": "Grabando · máximo 30 segundos",
+        "uploading": "Guardando muestra de audio…"
+      },
+      "languages": {
+        "auto": "Automático según el texto",
+        "spanish": "Español",
+        "english": "Inglés",
+        "chinese": "Chino",
+        "japanese": "Japonés",
+        "korean": "Coreano",
+        "german": "Alemán",
+        "french": "Francés",
+        "russian": "Ruso",
+        "portuguese": "Portugués",
+        "italian": "Italiano"
+      }
+    }
   },
   "title": "Estudio de escenas 3D",
   "subtitle": "Elige un plano, coloca tus objetos y pulsa Reproducir.",
diff --git a/ui/src/lib/characterKit.ts b/ui/src/lib/characterKit.ts
index a9349a345..ae21dc749 100644
--- a/ui/src/lib/characterKit.ts
+++ b/ui/src/lib/characterKit.ts
@@ -104,13 +104,14 @@ export function characterKitStillSource(kit: CharacterKit): string | undefined {
 export function resolvedCharacterTts(
   kit?: CharacterKit,
   fallback?: { provider?: string; voiceId?: string },
-): { source: 'kit' | 'profile' | 'none'; voiceId?: string; provider?: string; instructions?: string } {
+): { source: 'kit' | 'profile' | 'none'; voiceId?: string; voiceName?: string; provider?: string; instructions?: string } {
   if (kit?.voice) {
     return {
       source: 'kit',
       voiceId: kit.voice.voiceId,
+      ...(kit.voice.model === 'qwen3_tts_base' ? { voiceName: kit.voice.name } : {}),
       provider: kit.voice.provider,
-      instructions: kit.voice.instructions,
+      instructions: kit.voice.model === 'qwen3_tts_customvoice' ? kit.voice.instructions : undefined,
     }
   }
   if (fallback?.voiceId) {
diff --git a/ui/src/lib/characterVoice.ts b/ui/src/lib/characterVoice.ts
index b54677204..350b4cd69 100644
--- a/ui/src/lib/characterVoice.ts
+++ b/ui/src/lib/characterVoice.ts
@@ -1,16 +1,65 @@
 /** Public preferences only. Credentials always stay in the server configuration. */
-export type CharacterVoice = {
+export type PresetCharacterVoice = {
   provider: 'local'
   model: 'qwen3_tts_customvoice'
   voiceId: string
   instructions?: string
 }
+export const CHARACTER_VOICE_LANGUAGES = ['auto', 'chinese', 'english', 'japanese', 'korean', 'german', 'french', 'russian', 'portuguese', 'spanish', 'italian'] as const
+export type CustomCharacterVoice = {
+  provider: 'local'
+  model: 'qwen3_tts_base'
+  voiceId: 'reference'
+  name: string
+  referenceAudio: string
+  transcript: string
+  language: typeof CHARACTER_VOICE_LANGUAGES[number]
+}
+export type CharacterVoice = PresetCharacterVoice | CustomCharacterVoice
 export type CharacterKitRef = { id: string; workspace: string }
 export const CHARACTER_VOICES = ['vivian', 'serena', 'uncle_fu', 'dylan', 'eric', 'ryan', 'aiden', 'ono_anna', 'sohee'] as const
+
+function validateReferenceQuery(kind: string, raw?: string) {
+  if (kind === 'uploads') {
+    if (raw !== undefined) throw new Error('Upload references cannot contain query parameters.')
+    return
+  }
+  const query = new URLSearchParams(raw), workspace = query.get('workspace')
+  if ([...query.keys()].length !== 1 || !workspace || !/^[A-Za-z0-9_. -]{1,120}$/.test(workspace)
+    || ['.', '..'].includes(workspace)) throw new Error('The reference recording needs its source workspace.')
+}
+
+/** Keep the public asset root and source workspace, never host paths or credentials. */
+export function parseCharacterVoiceReference(raw: unknown): string {
+  if (typeof raw !== 'string' || !raw || raw.length > 1200 || /[\s\\#]/.test(raw)) throw new Error('Import a local reference recording first.')
+  const match = /^\/api\/v1\/(uploads|file)\/([^?]+)(?:\?(.+))?$/.exec(raw)
+  if (!match) throw new Error('Use a persistent local reference recording.')
+  let path: string
+  try { path = decodeURIComponent(match[2]); decodeURIComponent(match[3] ?? '') } catch { throw new Error('Invalid reference recording URL.') }
+  if ([...path].some(char => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127) || /[\\%?#]/.test(path)
+    || path.split('/').some(part => !part || part.startsWith('.'))
+    || !/\.(wav|mp3|m4a|aac|flac|ogg|opus)$/i.test(path)) throw new Error('Choose a local audio recording.')
+  validateReferenceQuery(match[1], match[3])
+  return raw
+}
+
+const boundedText = (raw: unknown, max: number): raw is string => typeof raw === 'string' && Boolean(raw.trim()) && raw.length <= max
+function parseCustomCharacterVoice(data: Record<string, unknown>): CustomCharacterVoice {
+  if (Object.keys(data).some(key => !['provider', 'model', 'voiceId', 'name', 'referenceAudio', 'transcript', 'language'].includes(key))
+    || data.provider !== 'local' || data.voiceId !== 'reference' || !boundedText(data.name, 120) || !boundedText(data.transcript, 4000)
+    || !CHARACTER_VOICE_LANGUAGES.includes(data.language as typeof CHARACTER_VOICE_LANGUAGES[number])) {
+    throw new Error('Add a named local reference recording, its transcript and a supported language.')
+  }
+  return { provider: 'local', model: 'qwen3_tts_base', voiceId: 'reference', name: data.name.trim(),
+    referenceAudio: parseCharacterVoiceReference(data.referenceAudio), transcript: data.transcript.trim(),
+    language: data.language as CustomCharacterVoice['language'] }
+}
+
 export function parseCharacterVoice(raw: unknown): CharacterVoice | undefined {
   if (raw === undefined) return undefined
   if (!raw || typeof raw !== 'object') throw new Error('Invalid character voice.')
   const data = raw as Record<string, unknown>
+  if (data.model === 'qwen3_tts_base') return parseCustomCharacterVoice(data)
   if (Object.keys(data).some(key => !['provider', 'model', 'voiceId', 'instructions'].includes(key))
     || data.provider !== 'local' || data.model !== 'qwen3_tts_customvoice'
     || !CHARACTER_VOICES.includes(data.voiceId as typeof CHARACTER_VOICES[number])
@@ -20,6 +69,9 @@ export function parseCharacterVoice(raw: unknown): CharacterVoice | undefined {
   return { provider: 'local', model: 'qwen3_tts_customvoice', voiceId: data.voiceId as string,
     ...(data.instructions ? { instructions: data.instructions as string } : {}) }
 }
+export function isCharacterVoiceReady(raw: unknown): boolean {
+  try { parseCharacterVoice(raw); return true } catch { return false }
+}
 export function parseCharacterKitRef(raw: unknown): CharacterKitRef | undefined {
   if (raw === undefined) return undefined
   const ref = raw as CharacterKitRef
diff --git a/ui/src/lib/characterVoiceCatalog.ts b/ui/src/lib/characterVoiceCatalog.ts
new file mode 100644
index 000000000..1c623a37d
--- /dev/null
+++ b/ui/src/lib/characterVoiceCatalog.ts
@@ -0,0 +1,15 @@
+import type { CHARACTER_VOICES } from './characterVoice'
+
+// Qwen's original speaker profiles, not measured accents in translated speech.
+// https://github.com/QwenLM/Qwen3-TTS#custom-voice-generate
+export const CHARACTER_VOICE_PROFILES = {
+  vivian: { name: 'Vivian', origin: 'chinese' },
+  serena: { name: 'Serena', origin: 'chinese' },
+  uncle_fu: { name: 'Uncle Fu', origin: 'chinese' },
+  dylan: { name: 'Dylan', origin: 'beijing' },
+  eric: { name: 'Eric', origin: 'sichuan' },
+  ryan: { name: 'Ryan', origin: 'english' },
+  aiden: { name: 'Aiden', origin: 'americanEnglish' },
+  ono_anna: { name: 'Ono Anna', origin: 'japanese' },
+  sohee: { name: 'Sohee', origin: 'korean' },
+} as const satisfies Record<typeof CHARACTER_VOICES[number], { name: string; origin: string }>
diff --git a/ui/src/lib/sceneSpeech.ts b/ui/src/lib/sceneSpeech.ts
index 36b16455b..313a9e864 100644
--- a/ui/src/lib/sceneSpeech.ts
+++ b/ui/src/lib/sceneSpeech.ts
@@ -1,4 +1,4 @@
-import { cancelJob, fetchJobStatus, submitGeneration } from '../api/client'
+import { adoptAudio, cancelJob, fetchJobStatus, submitGeneration } from '../api/client'
 
 const AUDIO_FILE = /\.(wav|mp3|m4a|aac|flac|ogg)$/i
 const TERMINAL = new Set(['completed', 'failed', 'cancelled'])
@@ -14,6 +14,7 @@ export type SceneSpeechDependencies = {
   submitGeneration: typeof submitGeneration
   fetchJobStatus: typeof fetchJobStatus
   cancelJob?: typeof cancelJob
+  adoptAudio?: typeof adoptAudio
   now?: () => number
   wait?: (ms: number) => Promise<void>
 }
@@ -32,7 +33,7 @@ type SceneSpeechOptions = {
 /** Generate one speech clip with the currently selected HocusPocus audio model. */
 export async function generateSceneSpeechClip(
   options: SceneSpeechOptions,
-  deps: SceneSpeechDependencies = { submitGeneration, fetchJobStatus, cancelJob },
+  deps: SceneSpeechDependencies = { submitGeneration, fetchJobStatus, cancelJob, adoptAudio },
 ): Promise<SceneSpeechClip> {
   const submitted = await submitSpeech(options, deps)
   return awaitSpeechOutput(options, deps, submitted)
@@ -46,6 +47,16 @@ async function submitSpeech(options: SceneSpeechOptions, deps: SceneSpeechDepend
   options.signal?.throwIfAborted()
   const voice = options.voice ? (await import('./characterVoice')).parseCharacterVoice(options.voice) : undefined
   if (voice && voice.model !== model) throw new Error('The selected voice belongs to a different speech model.')
+  let referencePath: string | undefined
+  if (voice?.model === 'qwen3_tts_base') {
+    const sourceWorkspace = new URLSearchParams(voice.referenceAudio.split('?')[1]).get('workspace') ?? options.workspace
+    const reference = await (deps.adoptAudio ?? adoptAudio)({ audio_path: voice.referenceAudio,
+      ...(sourceWorkspace ? { workspace: sourceWorkspace } : {}) })
+    referencePath = reference.path
+    if (!referencePath) throw new Error('The reference recording is no longer available.')
+    // Only the owned generation is cancellable; adopting a stored file never creates a job.
+    options.signal?.throwIfAborted()
+  }
   const submitted = await deps.submitGeneration({
     model_type: model,
     generation_mode: 'audio',
@@ -56,7 +67,9 @@ async function submitSpeech(options: SceneSpeechOptions, deps: SceneSpeechDepend
     duration_seconds: Math.max(1, options.durationSeconds),
     _audio_sub_mode: 'speech',
     ...(options.workspace ? { workspace: options.workspace } : {}),
-    ...(voice ? { model_mode: voice.voiceId, alt_prompt: voice.instructions ?? '' } : {}),
+    ...(voice?.model === 'qwen3_tts_base'
+      ? { model_mode: voice.language, audio_prompt_type: 'A', audio_guide: referencePath, alt_prompt: voice.transcript }
+      : voice ? { model_mode: voice.voiceId, alt_prompt: voice.instructions ?? '' } : {}),
   })
   return { prompt, model, jobId: submitted.job_id }
 }
diff --git a/ui/tests/characterVoiceAudition.test.tsx b/ui/tests/characterVoiceAudition.test.tsx
new file mode 100644
index 000000000..248df6012
--- /dev/null
+++ b/ui/tests/characterVoiceAudition.test.tsx
@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import React from 'react'
+import { JSDOM } from 'jsdom'
+import type { CharacterVoice } from '../src/lib/characterVoice'
+
+const dom = new JSDOM('<!doctype html><html><body /></html>', { url: 'http://localhost/' })
+Object.assign(globalThis, { window: dom.window, document: dom.window.document, localStorage: dom.window.localStorage,
+  HTMLElement: dom.window.HTMLElement, Event: dom.window.Event, CustomEvent: dom.window.CustomEvent })
+const voice: CharacterVoice = { provider: 'local', model: 'qwen3_tts_customvoice', voiceId: 'ryan', instructions: 'Warm storyteller' }
+const json = (value: unknown) => new Response(JSON.stringify(value), { headers: { 'Content-Type': 'application/json' } })
+
+test('voice origin and an explicit Spanish audition are available before saving a character or setting up mouths', async t => {
+  const { render, fireEvent, waitFor, cleanup } = await import('@testing-library/react')
+  const { CharacterVoiceFields } = await import('../src/features/characters/CharacterVoiceFields')
+  const original = globalThis.fetch, requests: Record<string, unknown>[] = [], changes: unknown[] = []
+  globalThis.fetch = async (input, init) => {
+    if (String(input).endsWith('/generate')) { requests.push(JSON.parse(String(init?.body))); return json({ job_id: 'audition', status: 'queued' }) }
+    return json({ job_id: 'audition', status: 'completed', output_files: ['spanish-sample.wav'] })
+  }
+  t.after(() => { cleanup(); globalThis.fetch = original })
+  const view = render(<CharacterVoiceFields workspace="my-studio" value={voice} onChange={value => changes.push(value)} />)
+  assert.ok(view.getByRole('option', { name: 'Ryan · English' }))
+  assert.ok(view.getByRole('option', { name: 'Eric · Chinese · Sichuan' }))
+  assert.equal(requests.length, 0)
+  fireEvent.change(view.getByLabelText('Sample sentence language'), { target: { value: 'es' } })
+  assert.equal(requests.length, 0)
+  fireEvent.click(view.getByRole('button', { name: 'Generate voice sample' }))
+  await waitFor(() => assert.ok(view.getByLabelText('Selected voice sample').getAttribute('src')?.includes('spanish-sample.wav')))
+  assert.equal(requests.length, 1)
+  assert.equal(requests[0].workspace, 'my-studio')
+  assert.equal(requests[0].model_mode, 'ryan')
+  assert.equal(requests[0].alt_prompt, voice.instructions)
+  assert.match(String(requests[0].prompt), /historia en español/)
+  assert.deepEqual(changes, [])
+  const audio = view.getByLabelText('Selected voice sample') as HTMLAudioElement
+  let stopped = 0
+  Object.defineProperty(audio, 'paused', { value: false, configurable: true })
+  audio.pause = () => { stopped++; Object.defineProperty(audio, 'paused', { value: true }) }
+  fireEvent.change(view.getByLabelText('Sample sentence language'), { target: { value: 'en' } })
+  assert.equal(stopped, 1)
+  assert.equal(view.queryByLabelText('Selected voice sample'), null)
+})
+
+test('switching voices cancels only the owned audition and never exposes its late audio under the new voice', async t => {
+  const { render, fireEvent, waitFor, cleanup } = await import('@testing-library/react')
+  const { CharacterVoiceFields } = await import('../src/features/characters/CharacterVoiceFields')
+  const original = globalThis.fetch, cancelled: string[] = []
+  let release!: (response: Response) => void, pending = false, count = 0
+  globalThis.fetch = async input => {
+    const path = String(input)
+    if (path.endsWith('/generate')) return json({ job_id: ++count === 1 ? 'old-voice' : 'new-voice', status: 'queued' })
+    if (path.includes('/cancel/')) { cancelled.push(path); return json({}) }
+    if (path.endsWith('/status/old-voice')) { pending = true; return new Promise<Response>(resolve => { release = resolve }) }
+    return json({ job_id: 'new-voice', status: 'completed', output_files: ['new-voice.wav'] })
+  }
+  t.after(() => { cleanup(); globalThis.fetch = original })
+  const view = render(<CharacterVoiceFields workspace="default" value={voice} onChange={() => {}} />)
+  fireEvent.click(view.getByRole('button', { name: 'Generate voice sample' }))
+  await waitFor(() => assert.ok(pending))
+  view.rerender(<CharacterVoiceFields workspace="default" value={{ ...voice, voiceId: 'aiden' }} onChange={() => {}} />)
+  await waitFor(() => assert.deepEqual(cancelled, ['/api/v1/cancel/old-voice']))
+  release(json({ job_id: 'old-voice', status: 'completed', output_files: ['wrong-voice.wav'] }))
+  assert.equal(view.queryByLabelText('Selected voice sample'), null)
+  fireEvent.click(view.getByRole('button', { name: 'Generate voice sample' }))
+  await waitFor(() => assert.match(view.getByLabelText('Selected voice sample').getAttribute('src')!, /new-voice.wav/))
+  assert.deepEqual(cancelled, ['/api/v1/cancel/old-voice'])
+})
diff --git a/ui/tests/customCharacterVoice.test.ts b/ui/tests/customCharacterVoice.test.ts
new file mode 100644
index 000000000..99b946dac
--- /dev/null
+++ b/ui/tests/customCharacterVoice.test.ts
@@ -0,0 +1,96 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { CHARACTER_VOICE_LANGUAGES, isCharacterVoiceReady, parseCharacterVoice, type CustomCharacterVoice } from '../src/lib/characterVoice'
+import { createCharacterKit, resolvedCharacterTts } from '../src/lib/characterKit'
+import { generateSceneSpeechClip } from '../src/lib/sceneSpeech'
+
+const custom: CustomCharacterVoice = { provider: 'local', model: 'qwen3_tts_base', voiceId: 'reference',
+  name: 'My Spanish narrator', referenceAudio: '/api/v1/uploads/audio/recording.wav',
+  transcript: 'Esta es mi voz. Hoy vamos a contar una historia.', language: 'spanish' }
+
+test('reference voices and existing presets survive public JSON without credentials or host paths', () => {
+  assert.deepEqual(parseCharacterVoice(JSON.parse(JSON.stringify(custom))), custom)
+  const preset = { provider: 'local', model: 'qwen3_tts_customvoice', voiceId: 'ryan', instructions: 'Warm' }
+  assert.deepEqual(parseCharacterVoice(preset), preset)
+  assert.equal(isCharacterVoiceReady(undefined), true)
+  for (const language of CHARACTER_VOICE_LANGUAGES) assert.equal(isCharacterVoiceReady({ ...custom, language }), true)
+  assert.equal(resolvedCharacterTts({ ...createCharacterKit('Narrator'), voice: custom }).voiceName, custom.name)
+  assert.equal(resolvedCharacterTts({ ...createCharacterKit('Narrator'), voice: custom }).voiceId, 'reference')
+  assert.deepEqual(parseCharacterVoice({ ...custom, name: '  Narrator  ', transcript: '  Hola.  ' }),
+    { ...custom, name: 'Narrator', transcript: 'Hola.' })
+})
+
+test('unfinished drafts and unsupported reference fields cannot be saved or generated', () => {
+  for (const patch of [{ name: '' }, { name: ' '.repeat(10) }, { name: 'a'.repeat(121) }, { name: 12 },
+    { transcript: '' }, { transcript: '\n' }, { transcript: 'a'.repeat(4001) }, { transcript: null },
+    { referenceAudio: '' }, { language: 'martian' }, { language: [] }, { provider: 'remote' },
+    { voiceId: 'ryan' }, { apiKey: 'not-a-secret' }, { instructions: 'unsupported by Base' }]) {
+    assert.equal(isCharacterVoiceReady({ ...custom, ...patch }), false, JSON.stringify(patch))
+    assert.throws(() => parseCharacterVoice({ ...custom, ...patch }))
+  }
+  for (const key of Object.keys(custom)) {
+    const missing = { ...custom } as Record<string, unknown>
+    delete missing[key]
+    assert.throws(() => parseCharacterVoice(missing), key)
+  }
+})
+
+test('reference URLs keep exact public roots and source workspaces; remote and ambiguous paths are rejected', () => {
+  for (const referenceAudio of ['/api/v1/uploads/voice.wav', '/api/v1/uploads/audio/mi%20voz.wav',
+    '/api/v1/file/assets/actors/voice.wav?workspace=original', '/api/v1/file/voice.flac?workspace=My%20Voices']) {
+    assert.equal(parseCharacterVoice({ ...custom, referenceAudio })?.model, 'qwen3_tts_base')
+  }
+  for (const referenceAudio of ['https://example.com/voice.wav', '//example.com/voice.wav', 'blob:voice',
+    'data:audio/wav;base64,AAAA', '/home/private.wav', '/api/v1/uploads/../voice.wav',
+    '/api/v1/uploads/%2e%2e/voice.wav', '/api/v1/uploads/%252e%252e/voice.wav',
+    '/api/v1/uploads/audio%5cvoice.wav', '/api/v1/uploads/.private/voice.wav',
+    '/api/v1/uploads/voice.wav?token=example', '/api/v1/uploads/voice.wav#fragment',
+    '/api/v1/uploads/voice.wav?', '/api/v1/uploads/voice%00.wav', '/api/v1/uploads/%ZZ.wav',
+    '/api/v1/uploads/voice.json', '/api/v1/uploads/voice.webm', '/api/v1/uploads/voice wav.wav', '/api/v1/uploads//voice.wav',
+    '/api/v1/file/voice.wav', '/api/v1/file/voice.wav?workspace=', '/api/v1/file/voice.wav?workspace=..',
+    '/api/v1/file/voice.wav?workspace=one&workspace=two', '/api/v1/file/voice.wav?workspace=one&key=example',
+    '/api/v1/file/voice.wav?workspace=%ZZ', '/api/v1/file/voice.wav?workspace=%FF']) {
+    assert.throws(() => parseCharacterVoice({ ...custom, referenceAudio }), referenceAudio)
+  }
+})
+
+test('Base generation adopts the exact reference from its source workspace and outputs into the scene workspace', async () => {
+  const requests: Record<string, unknown>[] = [], adopted: Record<string, unknown>[] = []
+  const voice = { ...custom, referenceAudio: '/api/v1/file/assets/narrator.wav?workspace=Voice%20Library' }
+  const saved = JSON.stringify(voice)
+  const result = await generateSceneSpeechClip({ model: voice.model, voice, prompt: 'Nueva frase.', durationSeconds: 5, workspace: 'episode' }, {
+    adoptAudio: async params => { adopted.push(params); return { filename: 'narrator.wav', path: '/server/Voice Library/assets/narrator.wav', url: voice.referenceAudio } },
+    submitGeneration: async params => { requests.push(params); return { job_id: 'owned-base', status: 'queued' } },
+    fetchJobStatus: async () => ({ status: 'completed', output_files: ['line.wav'] } as never),
+  })
+  assert.deepEqual(adopted, [{ audio_path: voice.referenceAudio, workspace: 'Voice Library' }])
+  assert.equal(requests.length, 1)
+  assert.equal(requests[0].model_type, 'qwen3_tts_base')
+  assert.equal(requests[0].model_mode, 'spanish')
+  assert.equal(requests[0].audio_prompt_type, 'A')
+  assert.equal(requests[0].audio_guide, '/server/Voice Library/assets/narrator.wav')
+  assert.equal(requests[0].alt_prompt, custom.transcript)
+  assert.equal(requests[0].workspace, 'episode')
+  assert.equal(requests[0].prompt, 'Nueva frase.')
+  assert.equal(result.filename, 'line.wav')
+  assert.equal(JSON.stringify(voice), saved, 'the resolved host path must never replace the reusable reference URL')
+})
+
+test('an upload is adopted from its declared root and a missing reference never queues speech', async () => {
+  const adopted: Record<string, unknown>[] = []
+  await assert.rejects(generateSceneSpeechClip({ model: custom.model, voice: custom, prompt: 'Hello', durationSeconds: 5, workspace: 'episode' }, {
+    adoptAudio: async params => { adopted.push(params); throw new Error('Media file not found') },
+    submitGeneration: async () => { assert.fail('Must not generate with a missing reference') },
+    fetchJobStatus: async () => { assert.fail('Must not poll') },
+  }), /Media file not found/)
+  assert.deepEqual(adopted, [{ audio_path: custom.referenceAudio, workspace: 'episode' }])
+})
+
+test('cancelling while resolving a reference never submits an unwanted generation', async () => {
+  const abort = new AbortController()
+  await assert.rejects(generateSceneSpeechClip({ model: custom.model, voice: custom, prompt: 'Hello', durationSeconds: 5, signal: abort.signal }, {
+    adoptAudio: async () => { abort.abort(); return { filename: 'voice.wav', path: '/server/voice.wav', url: custom.referenceAudio } },
+    submitGeneration: async () => { assert.fail('Must not submit after cancelling') },
+    fetchJobStatus: async () => { assert.fail('Must not poll') },
+  }), /abort/i)
+})
diff --git a/ui/tests/customCharacterVoiceFields.test.tsx b/ui/tests/customCharacterVoiceFields.test.tsx
new file mode 100644
index 000000000..fda714b77
--- /dev/null
+++ b/ui/tests/customCharacterVoiceFields.test.tsx
@@ -0,0 +1,131 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import React, { useState } from 'react'
+import { JSDOM } from 'jsdom'
+import type { CharacterVoice, CustomCharacterVoice } from '../src/lib/characterVoice'
+
+const dom = new JSDOM('<!doctype html><html><body /></html>', { url: 'http://localhost/' })
+Object.assign(globalThis, { window: dom.window, document: dom.window.document, localStorage: dom.window.localStorage,
+  HTMLElement: dom.window.HTMLElement, Event: dom.window.Event, CustomEvent: dom.window.CustomEvent })
+Object.defineProperty(globalThis, 'navigator', { configurable: true, value: dom.window.navigator })
+dom.window.HTMLMediaElement.prototype.pause = () => {}
+const json = (value: unknown) => new Response(JSON.stringify(value), { headers: { 'Content-Type': 'application/json' } })
+const saved: CustomCharacterVoice = { provider: 'local', model: 'qwen3_tts_base', voiceId: 'reference', name: 'My narrator',
+  referenceAudio: '/api/v1/uploads/narrator.wav', transcript: 'This is my own voice.', language: 'auto' }
+
+function mockDecode(t: test.TestContext, duration = 6) {
+  const original = globalThis.OfflineAudioContext
+  const samples = new Float32Array(6 * 16000).fill(.1)
+  globalThis.OfflineAudioContext = class {
+    destination = {}
+    async decodeAudioData() { return { duration } }
+    createBufferSource() { return { connect() {}, start() {} } }
+    async startRendering() { return { getChannelData: () => samples } }
+  } as unknown as typeof OfflineAudioContext
+  t.after(() => { globalThis.OfflineAudioContext = original })
+}
+
+test('imported recording becomes a reusable voice only with name and transcript; saved voices can be selected for another character', async t => {
+  const { render, fireEvent, waitFor, cleanup } = await import('@testing-library/react')
+  const { CharacterVoiceFields } = await import('../src/features/characters/CharacterVoiceFields')
+  const { createCharacterKit } = await import('../src/lib/characterKit')
+  mockDecode(t)
+  const original = globalThis.fetch; let uploads = 0, current: CharacterVoice | undefined
+  globalThis.fetch = async (url, init) => {
+    assert.ok(String(url).endsWith('/upload-audio'))
+    const audio = (init?.body as FormData).get('file') as File
+    assert.equal(audio.type, 'audio/wav'); assert.ok(audio.size > 44)
+    uploads++
+    return json({ filename: 'recording.wav', url: '/api/v1/uploads/recording.wav', path: '/server/private/recording.wav' })
+  }
+  t.after(() => { cleanup(); globalThis.fetch = original })
+  function Editor() {
+    const [value, setValue] = useState<CharacterVoice>()
+    return <CharacterVoiceFields workspace="characters" value={value} onChange={next => { current = next; setValue(next) }}
+      savedKits={[{ ...createCharacterKit('Other actor'), id: 'other', voice: saved }]} />
+  }
+  const view = render(<Editor />)
+  fireEvent.change(view.getByTestId('character-voice'), { target: { value: 'new-reference' } })
+  assert.equal(view.queryByRole('button', { name: 'Generate voice sample' }), null)
+  fireEvent.change(view.getByLabelText('Voice name'), { target: { value: 'Imported actor' } })
+  fireEvent.change(view.getByLabelText('Import audio sample'), { target: { files: [new File(['audio'], 'test.mp3', { type: 'audio/mpeg' })] } })
+  await waitFor(() => assert.ok(view.getByLabelText('Original voice sample')))
+  assert.equal(view.queryByRole('button', { name: 'Generate voice sample' }), null)
+  fireEvent.change(view.getByLabelText('Exact sample transcript'), { target: { value: 'These are the words I recorded.' } })
+  assert.ok(view.getByRole('button', { name: 'Generate voice sample' }))
+  assert.equal(current?.model, 'qwen3_tts_base')
+  assert.equal((current as CustomCharacterVoice).referenceAudio, '/api/v1/uploads/recording.wav')
+  assert.ok(!JSON.stringify(current).includes('/server/private'))
+  fireEvent.change(view.getByTestId('character-voice'), { target: { value: 'saved:other' } })
+  assert.deepEqual(current, saved)
+  assert.equal(uploads, 1, 'selecting a saved voice neither uploads nor generates')
+})
+
+test('invalid duration leaves the previous voice intact and does not upload a silently cropped recording', async t => {
+  const { render, fireEvent, cleanup } = await import('@testing-library/react')
+  const { CustomCharacterVoiceFields } = await import('../src/features/characters/CustomCharacterVoiceFields')
+  mockDecode(t, 31)
+  const original = globalThis.fetch; let requests = 0
+  globalThis.fetch = async () => { requests++; throw new Error('Must not upload') }
+  t.after(() => { cleanup(); globalThis.fetch = original })
+  const changes: unknown[] = []
+  const view = render(<CustomCharacterVoiceFields value={saved} onChange={value => changes.push(value)} />)
+  fireEvent.change(view.getByLabelText('Import audio sample'), { target: { files: [new File(['audio'], 'long.wav', { type: 'audio/wav' })] } })
+  await view.findByText(/The sample must last 3–30 seconds/)
+  assert.deepEqual(changes, []); assert.equal(requests, 0)
+  assert.equal(view.getByLabelText('Original voice sample').getAttribute('src'), saved.referenceAudio)
+})
+
+test('cancelling microphone permission disposes a late stream without replacing the saved voice', async t => {
+  const { render, fireEvent, waitFor, cleanup } = await import('@testing-library/react')
+  const { CustomCharacterVoiceFields } = await import('../src/features/characters/CustomCharacterVoiceFields')
+  let grant!: (stream: MediaStream) => void, stopped = 0
+  const originalRecorder = globalThis.MediaRecorder
+  Object.defineProperty(dom.window, 'isSecureContext', { value: true, configurable: true })
+  Object.defineProperty(navigator, 'mediaDevices', { configurable: true, value: { getUserMedia: () => new Promise<MediaStream>(resolve => { grant = resolve }) } })
+  globalThis.MediaRecorder = class { constructor() { throw new Error('Cancelled permission must not start recording') } } as unknown as typeof MediaRecorder
+  t.after(() => { cleanup(); globalThis.MediaRecorder = originalRecorder; Reflect.deleteProperty(navigator, 'mediaDevices') })
+  const changes: unknown[] = []
+  const view = render(<CustomCharacterVoiceFields value={saved} onChange={value => changes.push(value)} />)
+  fireEvent.click(view.getByRole('button', { name: 'Record with microphone' }))
+  await view.findByText(/Allow microphone access/)
+  fireEvent.click(view.getByRole('button', { name: 'Cancel recording' }))
+  grant({ getTracks: () => [{ stop: () => stopped++ }] } as unknown as MediaStream)
+  await waitFor(() => assert.equal(stopped, 1))
+  assert.deepEqual(changes, [])
+})
+
+test('recording a new reference stops microphone tracks, uploads WAV and requires its new transcript', async t => {
+  const { render, fireEvent, waitFor, cleanup } = await import('@testing-library/react')
+  const { CustomCharacterVoiceFields } = await import('../src/features/characters/CustomCharacterVoiceFields')
+  mockDecode(t)
+  const originalRecorder = globalThis.MediaRecorder, originalFetch = globalThis.fetch
+  let stopped = 0, uploads = 0
+  Object.defineProperty(dom.window, 'isSecureContext', { value: true, configurable: true })
+  Object.defineProperty(navigator, 'mediaDevices', { configurable: true, value: {
+    getUserMedia: async () => ({ getTracks: () => [{ stop: () => stopped++ }] }),
+  } })
+  globalThis.MediaRecorder = class {
+    state = 'inactive'; mimeType = 'audio/webm'
+    ondataavailable?: (event: { data: Blob }) => void
+    onstop?: () => void
+    start() { this.state = 'recording' }
+    stop() { this.state = 'inactive'; this.ondataavailable?.({ data: new Blob(['recorded audio']) }); this.onstop?.() }
+  } as unknown as typeof MediaRecorder
+  globalThis.fetch = async (url, init) => {
+    assert.ok(String(url).endsWith('/upload-audio')); uploads++
+    assert.equal(((init?.body as FormData).get('file') as File).type, 'audio/wav')
+    return json({ filename: 'new.wav', url: '/api/v1/uploads/new.wav', path: '/private/new.wav' })
+  }
+  t.after(() => { cleanup(); globalThis.MediaRecorder = originalRecorder; globalThis.fetch = originalFetch; Reflect.deleteProperty(navigator, 'mediaDevices') })
+  const changes: CustomCharacterVoice[] = []
+  const view = render(<CustomCharacterVoiceFields value={saved} onChange={value => changes.push(value)} />)
+  fireEvent.click(view.getByRole('button', { name: 'Record with microphone' }))
+  await view.findByText(/Recording · 30 seconds/)
+  fireEvent.click(view.getByRole('button', { name: 'Stop recording' }))
+  await waitFor(() => assert.equal(changes.length, 1))
+  assert.equal(stopped, 1); assert.equal(uploads, 1)
+  assert.equal(changes[0].referenceAudio, '/api/v1/uploads/new.wav')
+  assert.equal(changes[0].transcript, '', 'never apply an old transcript to a replacement recording')
+  assert.equal(changes[0].name, saved.name)
+})

From 8cdc68c4a731371a1e093a95fce1dc938260c6c3 Mon Sep 17 00:00:00 2001
From: THEINAOG <216241348+IAnMove@users.noreply.github.com>
Date: Mon, 14 Sep 2026 17:35:36 +0200
Subject: [PATCH 2/3] Register voice integration checks and lock character
 switching during capture

---
 scripts/ci_test_groups.json                   |  1 +
 .../fixtures/architecture_wire_inventory.json |  6 ++
 .../characters/CharacterDefinitionEditor.tsx  |  4 +-
 ui/src/features/series/SeriesVoiceFields.tsx  |  2 +-
 .../customCharacterVoiceCaptureScope.test.tsx | 61 +++++++++++++++++++
 5 files changed, 71 insertions(+), 3 deletions(-)
 create mode 100644 ui/tests/customCharacterVoiceCaptureScope.test.tsx

diff --git a/scripts/ci_test_groups.json b/scripts/ci_test_groups.json
index a55df399b..c5f5fbc85 100644
--- a/scripts/ci_test_groups.json
+++ b/scripts/ci_test_groups.json
@@ -166,6 +166,7 @@
         "tests/test_code_health.py",
         "tests/test_core_runtime.py",
         "tests/test_core_series_assembly.py",
+        "tests/test_custom_character_voice.py",
         "tests/test_debug_trace.py",
         "tests/test_development_branch_policy.py",
         "tests/test_director_h3_identity_continuity.py",
diff --git a/tests/fixtures/architecture_wire_inventory.json b/tests/fixtures/architecture_wire_inventory.json
index faf332140..78195a825 100644
--- a/tests/fixtures/architecture_wire_inventory.json
+++ b/tests/fixtures/architecture_wire_inventory.json
@@ -79,6 +79,12 @@
       "classification": "symbol_importable",
       "reason": "Extracts selected launch symbols with AST/exec; migrate to direct imports when that domain moves."
     },
+    {
+      "file": "tests/test_custom_character_voice.py",
+      "target": "app/_launch_runtime.py",
+      "classification": "symbol_importable",
+      "reason": "Extracts selected launch symbols with AST/exec; migrate to direct imports when that domain moves."
+    },
     {
       "file": "tests/test_director_model_compat.py",
       "target": "app/_launch_runtime.py",
diff --git a/ui/src/features/characters/CharacterDefinitionEditor.tsx b/ui/src/features/characters/CharacterDefinitionEditor.tsx
index f83e4d93a..46290a97a 100644
--- a/ui/src/features/characters/CharacterDefinitionEditor.tsx
+++ b/ui/src/features/characters/CharacterDefinitionEditor.tsx
@@ -133,7 +133,7 @@ function ScopedDefinition({ workspace, slot, disabled, initialKit, onSaved, onAp
           setId(nextId); setNotice('')
           if (!slot) { setName(next?.name ?? ''); setVoice(next?.voice); setModel(undefined) }
         }} />
-      {slot && <button data-testid="apply-character" className="min-h-10 rounded border border-border px-3" disabled={!kit?.speech3d}
+      {slot && <button data-testid="apply-character" className="min-h-10 rounded border border-border px-3" disabled={speechBusy || !kit?.speech3d}
         onClick={() => run(async () => {
           const patch = await characterSlotPatch(kit!, workspace, library!.revision, slot)
           if (alive.current) { setVoice(kit!.voice); setName(kit!.name); onApply?.(patch); setNotice(t('speech.characterApplied')) }
@@ -160,7 +160,7 @@ function ScopedDefinition({ workspace, slot, disabled, initialKit, onSaved, onAp
       {!slot && <CharacterDefinitionSpeechTools workspace={workspace} kit={library?.kits[id]}
         disabled={busy || dirty} saveRef={workshopSave} onDirtyChange={setWorkshopDirty} onBusyChange={setWorkshopBusy}
         onSaved={async saved => { setLibrary(saved); await onSaved?.(saved.kits[id]) }} />}
-      {!slot && kit?.speech3d && <button data-testid="edit-character-face" className="min-h-10 rounded border border-border px-3" onClick={() => run(async () => {
+      {!slot && kit?.speech3d && <button data-testid="edit-character-face" className="min-h-10 rounded border border-border px-3" disabled={speechBusy} onClick={() => run(async () => {
         const patch = await characterSlotPatch(kit, workspace, library!.revision)
         if (!alive.current) return
         const { buildSpeechProduction } = await import('../scene3d/speech/production')
diff --git a/ui/src/features/series/SeriesVoiceFields.tsx b/ui/src/features/series/SeriesVoiceFields.tsx
index 3a1a673a6..8c9bc7e04 100644
--- a/ui/src/features/series/SeriesVoiceFields.tsx
+++ b/ui/src/features/series/SeriesVoiceFields.tsx
@@ -47,7 +47,7 @@ export function SeriesVoiceFields({
               <input className={inputClass} value={String(kitOwnsTts ? tts.provider || '' : character.voiceProfile?.provider || '')} disabled={kitOwnsTts} onChange={event => onPatchVoice(index, { provider: event.target.value })} />
             </SeriesField>
             <SeriesField label={t('canon.voiceId')} hint={t('canon.voiceIdHint')}>
-              <input className={inputClass} value={String(kitOwnsTts ? tts.voiceName || tts.voiceId || '' : character.voiceProfile?.voiceId || '')} disabled={kitOwnsTts} onChange={event => onPatchVoice(index, { voiceId: event.target.value })} />
+              <input className={inputClass} value={String(kitOwnsTts ? tts.voiceId || '' : character.voiceProfile?.voiceId || '')} disabled={kitOwnsTts} onChange={event => onPatchVoice(index, { voiceId: event.target.value })} />
             </SeriesField>
             <SeriesField label={t('canon.language')}>
               <input className={inputClass} value={String(character.voiceProfile?.language || '')} onChange={event => onPatchVoice(index, { language: event.target.value })} />
diff --git a/ui/tests/customCharacterVoiceCaptureScope.test.tsx b/ui/tests/customCharacterVoiceCaptureScope.test.tsx
new file mode 100644
index 000000000..bffd6ffd8
--- /dev/null
+++ b/ui/tests/customCharacterVoiceCaptureScope.test.tsx
@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import React from 'react'
+import { createHash } from 'node:crypto'
+import { JSDOM } from 'jsdom'
+import { createCharacterKit } from '../src/lib/characterKit'
+import type { CustomCharacterVoice } from '../src/lib/characterVoice'
+import { buildSpeechProduction } from '../src/features/scene3d/speech/production'
+
+const dom = new JSDOM('<!doctype html><html><body /></html>', { url: 'http://localhost/' })
+Object.assign(globalThis, { window: dom.window, document: dom.window.document, localStorage: dom.window.localStorage,
+  HTMLElement: dom.window.HTMLElement, Event: dom.window.Event, CustomEvent: dom.window.CustomEvent })
+Object.defineProperty(globalThis, 'navigator', { configurable: true, value: dom.window.navigator })
+dom.window.HTMLMediaElement.prototype.pause = () => {}
+const json = (value: unknown) => new Response(JSON.stringify(value), { headers: { 'Content-Type': 'application/json' } })
+
+test('applying a saved character cannot replace a reference voice while its recording is uploading', async t => {
+  const { render, fireEvent, waitFor, cleanup } = await import('@testing-library/react')
+  const { CharacterDefinitionEditor } = await import('../src/features/characters/CharacterDefinitionEditor')
+  const stored: CustomCharacterVoice = { provider: 'local', model: 'qwen3_tts_base', voiceId: 'reference',
+    name: 'Saved voice', referenceAudio: '/api/v1/uploads/stored.wav', transcript: 'The saved recording.', language: 'auto' }
+  const model = { workspaceId: 'studio', filename: 'actor.glb', url: '/unit-capture-scope.glb' }
+  const kit = { ...createCharacterKit('Actor'), id: 'actor', voice: stored,
+    speech3d: { model, digest: createHash('sha256').update('model-bytes').digest('hex') } }
+  const doc = buildSpeechProduction({ kind: 'dialogue', title: 'Scope test', workspace: 'studio', duration: 5, offset: 0,
+    cast: [{ id: 'actor', name: 'Actor', model }] })
+  const slot = { ...doc.slots[0], character: { id: 'actor', name: 'Actor', kitRef: { id: 'actor', workspace: 'studio' }, voice: stored } }
+  const originalFetch = globalThis.fetch, originalAudio = globalThis.OfflineAudioContext
+  let releaseUpload!: (response: Response) => void, uploadStarted = false
+  const changes: unknown[] = []
+  globalThis.OfflineAudioContext = class {
+    destination = {}
+    async decodeAudioData() { return { duration: 6 } }
+    createBufferSource() { return { connect() {}, start() {} } }
+    async startRendering() { return { getChannelData: () => new Float32Array(6 * 16000).fill(.1) } }
+  } as unknown as typeof OfflineAudioContext
+  globalThis.fetch = async url => {
+    if (String(url).includes('/character-kits/library')) return json({ version: 1, revision: 1, kits: { actor: kit } })
+    if (String(url).endsWith('/upload-audio')) {
+      uploadStarted = true
+      return new Promise<Response>(resolve => { releaseUpload = resolve })
+    }
+    if (String(url) === model.url) return new Response('model-bytes')
+    throw new Error(`Unexpected request: ${String(url)}`)
+  }
+  t.after(() => { cleanup(); globalThis.fetch = originalFetch; globalThis.OfflineAudioContext = originalAudio })
+  const view = render(<CharacterDefinitionEditor workspace="studio" slot={slot} onApply={patch => changes.push(patch)} />)
+  await waitFor(() => assert.equal(view.getByTestId('character-voice').matches(':disabled'), false))
+  fireEvent.change(view.getByLabelText('Voice name'), { target: { value: 'Replacement voice' } })
+  changes.length = 0
+  fireEvent.change(view.getByLabelText('Import audio sample'), { target: { files: [new File(['audio'], 'replacement.mp3', { type: 'audio/mpeg' })] } })
+  await waitFor(() => assert.equal(uploadStarted, true))
+  const apply = view.getByTestId('apply-character')
+  assert.equal(apply.matches(':disabled'), true, 'applying a saved voice must not race its pending replacement upload')
+  fireEvent.click(apply)
+  assert.deepEqual(changes, [])
+  releaseUpload(json({ filename: 'replacement.wav', url: '/api/v1/uploads/replacement.wav', path: '/private/replacement.wav' }))
+  await waitFor(() => assert.equal(view.getByLabelText('Original voice sample').getAttribute('src'), '/api/v1/uploads/replacement.wav'))
+  assert.equal((view.getByLabelText('Voice name') as HTMLInputElement).value, 'Replacement voice')
+  assert.equal((view.getByLabelText('Exact sample transcript') as HTMLTextAreaElement).value, '')
+})

From 60996e50886cf4a959ff9538283d0316360c4565 Mon Sep 17 00:00:00 2001
From: THEINAOG <216241348+IAnMove@users.noreply.github.com>
Date: Mon, 14 Sep 2026 17:42:00 +0200
Subject: [PATCH 3/3] Keep microphone takes when recorder timing exceeds the
 sample cap

---
 .../characters/characterVoiceReference.ts     | 10 ++++++---
 .../characters/useVoiceReferenceCapture.ts    |  8 +++----
 ui/src/i18n/locales/en/scene3dEditor.json     |  2 +-
 ui/src/i18n/locales/es/scene3dEditor.json     |  2 +-
 ui/tests/customCharacterVoiceFields.test.tsx  | 21 +++++++++++++++++--
 5 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/ui/src/features/characters/characterVoiceReference.ts b/ui/src/features/characters/characterVoiceReference.ts
index 066e32dc7..283adf2a5 100644
--- a/ui/src/features/characters/characterVoiceReference.ts
+++ b/ui/src/features/characters/characterVoiceReference.ts
@@ -2,15 +2,19 @@ import { uploadLocalAsset } from '../asset-picker/upload'
 import { voiceWav } from '../scene3d/speech/audio'
 
 /** Normalize both browser recordings and imported audio before storing a reusable voice. */
-export async function uploadVoiceReference(blob: Blob, signal: AbortSignal): Promise<string> {
+export async function uploadVoiceReference(blob: Blob, signal: AbortSignal, source: 'import' | 'microphone' = 'import'): Promise<string> {
   if (!blob.size || blob.size > 20 * 1024 * 1024) throw new Error('voiceFileSize')
   signal.throwIfAborted()
   let buffer: AudioBuffer
   try { buffer = await new OfflineAudioContext(1, 1, 24000).decodeAudioData(await blob.arrayBuffer()) }
   catch { throw new Error('voiceFileDecode') }
   signal.throwIfAborted()
-  if (!Number.isFinite(buffer.duration) || buffer.duration < 3 || buffer.duration > 30) throw new Error('voiceFileDuration')
-  const wav = await voiceWav(buffer)
+  if (!Number.isFinite(buffer.duration) || buffer.duration < 3) throw new Error('voiceFileDuration')
+  // Recorder timers/codec padding may overrun the cap. Keep the advertised
+  // interval instead of discarding an otherwise valid microphone take.
+  const duration = source === 'microphone' ? Math.min(buffer.duration, 30) : buffer.duration
+  if (duration > 30) throw new Error('voiceFileDuration')
+  const wav = await voiceWav(buffer, 0, duration)
   signal.throwIfAborted()
   const uploaded = await uploadLocalAsset(new File([wav], 'voice-reference.wav', { type: 'audio/wav' }), signal)
   return uploaded.url
diff --git a/ui/src/features/characters/useVoiceReferenceCapture.ts b/ui/src/features/characters/useVoiceReferenceCapture.ts
index 7f61d4e7f..f93313898 100644
--- a/ui/src/features/characters/useVoiceReferenceCapture.ts
+++ b/ui/src/features/characters/useVoiceReferenceCapture.ts
@@ -19,14 +19,14 @@ export function useVoiceReferenceCapture(onAudio: (url: string) => void, onBusyC
       ? t('speech.microphoneDenied') : error.message || t('speech.recordingFailed'))
     setState('idle')
   }
-  const upload = async (blob: Blob, signal: AbortSignal) => {
+  const upload = async (blob: Blob, signal: AbortSignal, source: 'import' | 'microphone') => {
     setState('uploading')
-    try { const url = await uploadVoiceReference(blob, signal); if (!signal.aborted) { onAudio(url); setState('idle') } }
+    try { const url = await uploadVoiceReference(blob, signal, source); if (!signal.aborted) { onAudio(url); setState('idle') } }
     catch (cause) { fail(cause, signal) }
   }
   const importAudio = (file: File) => {
     owner.current?.abort(); const request = new AbortController(); owner.current = request; setError('')
-    void upload(file, request.signal)
+    void upload(file, request.signal, 'import')
   }
   const record = () => {
     if (!window.isSecureContext || !navigator.mediaDevices?.getUserMedia || typeof MediaRecorder === 'undefined') {
@@ -35,7 +35,7 @@ export function useVoiceReferenceCapture(onAudio: (url: string) => void, onBusyC
     owner.current?.abort(); const request = new AbortController(); owner.current = request
     setError(''); setState('permission')
     void recordMicrophone(request.signal, {
-      onRecording: () => setState('recording'), onComplete: blob => { void upload(blob, request.signal) },
+      onRecording: () => setState('recording'), onComplete: blob => { void upload(blob, request.signal, 'microphone') },
       onError: cause => fail(cause, request.signal),
     }, 30).then(finish => { if (!request.signal.aborted) stop.current = finish }).catch(cause => fail(cause, request.signal))
   }
diff --git a/ui/src/i18n/locales/en/scene3dEditor.json b/ui/src/i18n/locales/en/scene3dEditor.json
index 2b3c0dc4e..517fbad45 100644
--- a/ui/src/i18n/locales/en/scene3dEditor.json
+++ b/ui/src/i18n/locales/en/scene3dEditor.json
@@ -247,7 +247,7 @@
       "hint": "Use a clean sample of one speaker, without music or other voices. Import or record 3–30 seconds, then enter exactly what it says. The model will use that voice to read new dialogue.",
       "import": "Import audio sample",
       "record": "Record with microphone",
-      "recordHint": "Recording stops after 30 seconds. You can read a 5–15 second sentence and copy it into the transcript.",
+      "recordHint": "Up to 30 seconds are saved. You can read a 5–15 second sentence and copy it into the transcript.",
       "referencePreview": "Original voice sample",
       "transcript": "Exact sample transcript",
       "transcriptPlaceholder": "Enter the same words heard in the audio. This is not the dialogue to generate.",
diff --git a/ui/src/i18n/locales/es/scene3dEditor.json b/ui/src/i18n/locales/es/scene3dEditor.json
index 275c8f943..69b35ce52 100644
--- a/ui/src/i18n/locales/es/scene3dEditor.json
+++ b/ui/src/i18n/locales/es/scene3dEditor.json
@@ -247,7 +247,7 @@
       "hint": "Usa una muestra limpia de una sola persona, sin música ni otras voces. Importa o graba entre 3 y 30 segundos; después escribe exactamente lo que dice. El modelo usará su voz para leer diálogos nuevos.",
       "import": "Importar muestra de audio",
       "record": "Grabar con el micrófono",
-      "recordHint": "La grabación se detiene a los 30 segundos. Puedes leer una frase de 5–15 segundos y copiarla en la transcripción.",
+      "recordHint": "Se guardan hasta 30 segundos. Puedes leer una frase de 5–15 segundos y copiarla en la transcripción.",
       "referencePreview": "Muestra original de la voz",
       "transcript": "Texto exacto de la muestra",
       "transcriptPlaceholder": "Escribe aquí las mismas palabras que se escuchan en el audio. No es el diálogo que se generará.",
diff --git a/ui/tests/customCharacterVoiceFields.test.tsx b/ui/tests/customCharacterVoiceFields.test.tsx
index fda714b77..8c49df055 100644
--- a/ui/tests/customCharacterVoiceFields.test.tsx
+++ b/ui/tests/customCharacterVoiceFields.test.tsx
@@ -15,12 +15,12 @@ const saved: CustomCharacterVoice = { provider: 'local', model: 'qwen3_tts_base'
 
 function mockDecode(t: test.TestContext, duration = 6) {
   const original = globalThis.OfflineAudioContext
-  const samples = new Float32Array(6 * 16000).fill(.1)
   globalThis.OfflineAudioContext = class {
+    constructor(_channels: number, private frames: number) {}
     destination = {}
     async decodeAudioData() { return { duration } }
     createBufferSource() { return { connect() {}, start() {} } }
-    async startRendering() { return { getChannelData: () => samples } }
+    async startRendering() { return { getChannelData: () => new Float32Array(this.frames).fill(.1) } }
   } as unknown as typeof OfflineAudioContext
   t.after(() => { globalThis.OfflineAudioContext = original })
 }
@@ -129,3 +129,20 @@ test('recording a new reference stops microphone tracks, uploads WAV and require
   assert.equal(changes[0].transcript, '', 'never apply an old transcript to a replacement recording')
   assert.equal(changes[0].name, saved.name)
 })
+
+test('a microphone take that overruns its timer retains the first 30 seconds instead of being rejected', async t => {
+  const { uploadVoiceReference } = await import('../src/features/characters/characterVoiceReference')
+  mockDecode(t, 30.25)
+  const original = globalThis.fetch; let uploads = 0
+  globalThis.fetch = async (url, init) => {
+    assert.ok(String(url).endsWith('/upload-audio')); uploads++
+    const audio = (init?.body as FormData).get('file') as File
+    assert.equal(audio.size, 44 + 30 * 16000 * 2, 'saved WAV matches the advertised interval')
+    return json({ filename: 'capped.wav', url: '/api/v1/uploads/capped.wav', path: '/private/capped.wav' })
+  }
+  t.after(() => { globalThis.fetch = original })
+  const blob = new Blob(['full recording']), signal = new AbortController().signal
+  assert.equal(await uploadVoiceReference(blob, signal, 'microphone'), '/api/v1/uploads/capped.wav')
+  await assert.rejects(uploadVoiceReference(blob, signal, 'import'), /voiceFileDuration/)
+  assert.equal(uploads, 1, 'imported recordings are never silently cropped')
+})