video style phase 2

backend/app/llm/provider.py

@@ -66,8 +66,8 @@ FOCUS_MAX_TOKENS = 2000  # three titles and two-line descriptions plus GLM's low
 @lru_cache
 def focus_lm(retry: bool = False) -> dspy.LM:
     """The video wizard's focus suggestions: a little material in, three short topics out, so a small cap keeps it
-    quick. retry=True is the second try after an unusable answer: a different temperature, so it is a fresh call and
-    not that answer again from the cache."""
+    quick. Only for a source with no topics to show. retry=True is the second try after an unusable answer: a
+    different temperature, so it is a fresh call and not that answer again from the cache."""
     return _build(settings.llm_fast_model, effort="low", temperature=0.8 if retry else 0.4,
                   max_tokens=FOCUS_MAX_TOKENS)
 

backend/app/llm/run.py

@@ -1,7 +1,9 @@
 """One door for every generation call: runs the signature, meters tokens, writes a trace, and strips
 em dashes from the outputs. Tests replace `predict` to return canned outputs."""
 
+import logging
 import uuid
+from concurrent.futures import ThreadPoolExecutor
 
 import dspy
 from sqlalchemy.orm import Session
@@ -12,6 +14,8 @@ from app.llm.provider import main_lm, provider_name, track_usage
 from app.models import DspyTrace, Job, Workspace
 from app.services.jobs import record_usage
 
+log = logging.getLogger(__name__)
+
 
 def _dump(value):
     if hasattr(value, "model_dump"):
@@ -35,14 +39,51 @@ def predict(
     with track_usage(lm) as usage, dspy.context(lm=lm):
         pred = dspy.Predict(signature)(**inputs)
     outputs = {name: clean_output(_dump(pred[name])) for name in signature.output_fields}
+    _record(db, workspace_id, job, signature, lm, usage, [(inputs, outputs)])
+    return outputs
+
+
+def predict_many(
+    signature: type[dspy.Signature],
+    inputs_list: list[dict],
+    *,
+    db: Session,
+    workspace_id: uuid.UUID,
+    lm: dspy.LM | None = None,
+    workers: int = 5,
+) -> list[dict | None]:
+    """`predict` once per inputs, in parallel. Only the model calls run in threads: usage, traces and the commit
+    happen here, on the caller's session. A call that fails is None in its place."""
+    if not inputs_list:
+        return []
+    lm = lm or main_lm()
+
+    def call(inputs: dict) -> dict | None:
+        try:
+            with dspy.context(lm=lm):
+                pred = dspy.Predict(signature)(**inputs)
+            return {name: clean_output(_dump(pred[name])) for name in signature.output_fields}
+        except Exception:
+            log.warning("%s failed", signature.__name__, exc_info=True)
+            return None
+
+    with track_usage(lm) as usage, ThreadPoolExecutor(max_workers=min(workers, len(inputs_list))) as pool:
+        results = list(pool.map(call, inputs_list))
+    _record(db, workspace_id, None, signature, lm, usage,
+            [(i, o) for i, o in zip(inputs_list, results, strict=True) if o is not None])
+    return results
+
+
+def _record(db: Session, workspace_id: uuid.UUID, job: Job | None, signature: type[dspy.Signature], lm: dspy.LM,
+            usage, calls: list[tuple[dict, dict]]) -> None:
     if usage.total:
         record_usage(db, workspace_id=workspace_id, kind="llm", provider=provider_name(), model=settings.llm_model,
                      quantity=usage.total, unit="tokens", cost_usd=usage.cost_usd, job=job)
     workspace = db.get(Workspace, workspace_id)
-    db.add(DspyTrace(
-        workspace_id=workspace_id, module=signature.__name__, model=lm.model,
-        inputs={k: (v if len(str(v)) < 4000 else str(v)[:4000]) for k, v in inputs.items()},
-        outputs=outputs, training_allowed=bool(workspace and workspace.training_opt_in),
-    ))
+    for inputs, outputs in calls:
+        db.add(DspyTrace(
+            workspace_id=workspace_id, module=signature.__name__, model=lm.model,
+            inputs={k: (v if len(str(v)) < 4000 else str(v)[:4000]) for k, v in inputs.items()},
+            outputs=outputs, training_allowed=bool(workspace and workspace.training_opt_in),
+        ))
     db.commit()
-    return outputs

backend/app/llm/signatures.py

@@ -275,10 +275,20 @@ class FocusTopic(BaseModel):
                                      "angle it takes, using only this material")
 
 
-class VideoFocusTopics(dspy.Signature):
-    """Suggest three distinct angles a short explainer video could focus on, drawn only from this material. Each has a
-    short, specific topic (different for each of the three) and a two sentence summary of what the video covers about
-    that angle. Never use em dashes."""
+class FocusAngle(FocusTopic):
+    tag: str = Field(description="The candidate tag this angle is built on, copied exactly (its name only), or an "
+                                 "empty string when it comes from the material alone")
+
+
+class VideoFocusAngles(dspy.Signature):
+    """Suggest three distinct angles a short explainer video could focus on, drawn only from this material. Build
+    each angle on a different candidate tag when tags are given (a tag shared by several items makes a good angle that
+    connects them). Each has a short, specific topic (different for each of the three) and a two sentence summary of
+    what the video covers about that angle. Never reuse or closely reword an avoided title: find a new angle instead.
+    Never use em dashes."""
 
     items: list[str] = dspy.InputField(desc="Each item: a title (when there is one), then the start of its text")
-    topics: list[FocusTopic] = dspy.OutputField(desc="Exactly 3 focus topics")
+    candidate_tags: list[str] = dspy.InputField(
+        desc="Topics this material is about: 'Name (in how many items): what it covers'. May be empty")
+    avoid_titles: list[str] = dspy.InputField(desc="Titles already suggested. Do not repeat or reword them")
+    topics: list[FocusAngle] = dspy.OutputField(desc="Exactly 3 focus topics")

backend/app/pipeline/generate.py

@@ -1,5 +1,7 @@
 """Text generation jobs over the corpus: notebook summaries, topic map, voice profile, evergreen scores."""
 
+import logging
+import time
 import uuid
 from collections import Counter, defaultdict
 from datetime import UTC, datetime
@@ -11,11 +13,13 @@ from app.corpus import Corpus, slugify
 from app.llm import run
 from app.llm.provider import fast_lm
 from app.llm.signatures import BuildVoiceProfile, ConsolidateTopics, EvergreenScore, ExtractTopics, SummarizeNotebook
-from app.models import Artifact, DocumentTopic, Job, Notebook, Topic, VoiceProfile
+from app.models import Artifact, Document, DocumentTopic, Job, Notebook, Topic, VoiceProfile
 from app.pipeline.passages import as_citations, notebook_docs, passages_for, tools_for, workspace_docs
 from app.pipeline.research import verify_citations
 from app.services.jobs import update_job
 
+log = logging.getLogger(__name__)
+
 
 class NothingToDo(ValueError):
     pass
@@ -59,26 +63,65 @@ def summarize_notebook(db: Session, job: Job, artifact: Artifact) -> dict:
 # Topic map
 
 
+TAG_TRIES = 3  # per post per job: the model times out or rate limits now and then
+TAG_BACKOFF = (2.0, 6.0)  # seconds before the second and third try
+MAX_TAG_FAILURES = 5  # jobs in a row that could not tag a post: the sweep stops asking for it (and logs it)
+
+
+def needs_topics(meta: dict | None) -> bool:
+    """A post without topics yet that is still worth another try (see worker.topics_backfill)."""
+    meta = meta or {}
+    return not meta.get("topics") and int(meta.get("topics_failures") or 0) < MAX_TAG_FAILURES
+
+
+def save_topic_tags(doc: Document, out: dict) -> list[dict]:
+    """ExtractTopics' answer for a post (at most 8 named topics), kept in metadata_json["topics"]. An answer with no
+    topics is not kept, so the post still counts as untagged. Also used by the video wizard, which tags a post on
+    demand when it has none yet."""
+    tags = [t for t in (out.get("topics") or []) if t.get("name")][:8]
+    if tags:
+        meta = {k: v for k, v in (doc.metadata_json or {}).items() if k != "topics_failures"}
+        doc.metadata_json = {**meta, "topics": tags}
+    return tags
+
+
+def tag_post(db: Session, job: Job | None, workspace_id: uuid.UUID, doc: Document, known: list[str]) -> list[dict]:
+    """One post's topics, tried a few times. Out of tries, the post is counted as failed once more (the sweep asks
+    again later) and [] returned."""
+    error: object = None
+    for attempt in range(TAG_TRIES):
+        if attempt:
+            time.sleep(TAG_BACKOFF[attempt - 1])
+        try:
+            out = run.predict(ExtractTopics, db=db, workspace_id=workspace_id, job=job, lm=fast_lm(),
+                              title=doc.title, text=(doc.clean_text or "")[:12000], known_topics=known)
+        except Exception as exc:
+            error = exc
+            continue
+        if tags := save_topic_tags(doc, out):
+            return tags
+        error = "no topics in the answer"
+    meta = doc.metadata_json or {}
+    doc.metadata_json = {**meta, "topics_failures": int(meta.get("topics_failures") or 0) + 1}
+    log.warning("could not tag post %s (%s): %s", doc.id, doc.title[:60], error)
+    return []
+
+
 def extract_topics(db: Session, job: Job, workspace_id: uuid.UUID, doc_ids: list[str] | None = None) -> dict:
     """Tag posts that have no topics yet (or the given ones), then rebuild the workspace topic table."""
     docs = workspace_docs(db, workspace_id, [uuid.UUID(i) for i in doc_ids] if doc_ids else None)
-    todo = [d for d in docs if doc_ids or "topics" not in (d.metadata_json or {})]
+    todo = [d for d in docs if doc_ids or needs_topics(d.metadata_json)]
     known = sorted({t["name"] for d in docs for t in (d.metadata_json or {}).get("topics", [])})[:200]
-    lm = fast_lm()
+    tagged = 0
     for i, d in enumerate(todo):
         update_job(db, job, progress=0.05 + 0.75 * i / max(len(todo), 1), message=f"Mapping {d.title[:70]}")
-        try:
-            out = run.predict(ExtractTopics, db=db, workspace_id=workspace_id, job=job, lm=lm,
-                              title=d.title, text=(d.clean_text or "")[:12000], known_topics=known)
-        except Exception:
-            continue
-        tags = [t for t in (out.get("topics") or []) if t.get("name")][:8]
-        d.metadata_json = {**(d.metadata_json or {}), "topics": tags}
-        known = sorted(set(known) | {t["name"] for t in tags})[:200]
+        if tags := tag_post(db, job, workspace_id, d, known):
+            tagged += 1
+            known = sorted(set(known) | {t["name"] for t in tags})[:200]
         db.commit()
     update_job(db, job, progress=0.85, message="Drawing constellations")
     count = rebuild_topics(db, job, workspace_id)
-    return {"tagged": len(todo), "topics": count}
+    return {"tagged": tagged, "failed": len(todo) - tagged, "topics": count}
 
 
 def rebuild_topics(db: Session, job: Job | None, workspace_id: uuid.UUID) -> int:

backend/app/routers/topics.py

@@ -234,8 +234,8 @@ def rebuild(ctx: Ctx = Depends(get_ctx), full: bool = False):
     if full:
         # Clear per post tags so every post is mapped again.
         for d in ctx.db.scalars(select(Document).where(Document.workspace_id == ctx.workspace.id)):
-            if d.metadata_json and "topics" in d.metadata_json:
-                d.metadata_json = {k: v for k, v in d.metadata_json.items() if k != "topics"}
+            if d.metadata_json and ({"topics", "topics_failures"} & d.metadata_json.keys()):
+                d.metadata_json = {k: v for k, v in d.metadata_json.items() if k not in ("topics", "topics_failures")}
         ctx.db.commit()
     job = create_job(ctx.db, ctx.workspace.id, "topics", {}, max_attempts=2)
     return serialize_job(job)

backend/app/routers/video_voices.py

@@ -1,6 +1,8 @@
-"""Voices for videos: the workspace's saved voices, the built-in library, and custom voices (design, clone).
+"""Voices for videos: the workspace's saved voices, the built-in library, custom voices (design, clone), and its
+Notestack voices (made on the Voice page; blog2video speaks with the same ElevenLabs account).
 
-"My voices" (user_saved_voices) lives only here: blog2video's saved-voice list is one list for the whole account.
+"My voices" (user_saved_voices, at most MAX_SAVED_VOICES) lives only here: blog2video's saved-voice list is one list
+for the whole account.
 Custom voices are made on our blog2video account, so b2v_custom_voices records which workspace made each one;
 only that workspace can use, play or delete it. Designing, keeping, cloning and samples are premium (★) and come out
 of the workspace's own daily and total counters (video_limits).
@@ -18,6 +20,7 @@ from app.models import B2VCustomVoice, UserSavedVoice
 from app.routers.videos import b2v_ready, upstream
 from app.services import b2v_access, video_limits
 from app.services import blog2video as b2v
+from app.services.notestack_voices import notestack_voices
 
 log = logging.getLogger(__name__)
 
@@ -25,15 +28,25 @@ router = APIRouter(prefix="/api/video-voices", tags=["videos"])
 
 CLONE_MAX_BYTES = 50 * 1024 * 1024
 STARTER_VOICES = 4  # a new workspace starts with this many free built-in voices saved
+MAX_SAVED_VOICES = 5  # "My voices": what step 3 of a new video offers
 
 
 def _labels(v: dict) -> dict:
     return v.get("labels") or {}
 
 
-def _voice_out(v: UserSavedVoice) -> dict:
+def _voice_out(v: UserSavedVoice, ours: set[str] = frozenset()) -> dict:
     return {"voice_id": v.voice_id, "name": v.name, "preview_url": v.preview_url, "gender": v.gender,
-            "accent": v.accent, "premium": v.premium, "is_custom": v.is_custom}
+            "accent": v.accent, "premium": v.premium, "is_custom": v.is_custom,
+            "source": "notestack" if v.voice_id in ours else "blog2video"}
+
+
+def _room(ctx: Ctx) -> bool:
+    return len(_saved(ctx)) < MAX_SAVED_VOICES
+
+
+def _full() -> HTTPException:
+    return HTTPException(409, f"You can keep {MAX_SAVED_VOICES} voices. Remove one first.")
 
 
 def _library_out(v: dict, saved: set[str]) -> dict:
@@ -73,7 +86,10 @@ def voices(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
     ids = {v.voice_id for v in saved}
     custom = ctx.db.scalars(select(B2VCustomVoice).where(B2VCustomVoice.workspace_id == ctx.workspace.id)
                             .order_by(B2VCustomVoice.created_at.desc()))
-    return {"saved": [_voice_out(v) for v in saved],
+    mine = notestack_voices(ctx.db, ctx.workspace.id)
+    ours = {v["voice_id"] for v in mine}
+    return {"saved": [_voice_out(v, ours) for v in saved], "max_saved": MAX_SAVED_VOICES,
+            "notestack": [{**v, "saved": v["voice_id"] in ids} for v in mine],
             "library": [_library_out(v, ids) for v in library if v.get("voice_id")],
             "custom": [{"id": c.b2v_custom_voice_id, "voice_id": c.voice_id, "name": c.name, "source": c.source,
                         "preview_url": c.preview_url, "saved": c.voice_id in ids} for c in custom]}
@@ -85,8 +101,20 @@ class SaveIn(BaseModel):
 
 @router.post("/saved", status_code=201)
 def save_voice(body: SaveIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    if ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": body.voice_id}):
+        return _voice_out(ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": body.voice_id}))
+    if not _room(ctx):
+        raise _full()
     custom = ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.voice_id == body.voice_id,
                                                         B2VCustomVoice.workspace_id == ctx.workspace.id))
+    mine = next((v for v in notestack_voices(ctx.db, ctx.workspace.id) if v["voice_id"] == body.voice_id), None)
+    if mine:
+        # A Notestack voice: premium, like a custom voice. No preview link (the Voice page plays it).
+        video_limits.require_premium(ctx.db, ctx.workspace, "Custom voices")
+        row = ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=mine["voice_id"],
+                                          name=mine["name"][:255], premium=True, is_custom=True))
+        ctx.db.commit()
+        return _voice_out(row, {row.voice_id})
     if custom:
         row = ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=custom.voice_id, name=custom.name,
                                           preview_url=custom.preview_url, premium=True, is_custom=True))
@@ -163,11 +191,13 @@ def _record_custom(ctx: Ctx, made: dict, source: str) -> dict:
                          voice_id=made["voice_id"], name=(made.get("name") or "My voice")[:255], source=source,
                          preview_url=made.get("preview_url"))
     ctx.db.add(row)
-    ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=row.voice_id, name=row.name,
-                                preview_url=row.preview_url, premium=True, is_custom=True))
+    saved = _room(ctx)  # kept in My voices only while there is room; otherwise added from the list later
+    if saved:
+        ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=row.voice_id, name=row.name,
+                                    preview_url=row.preview_url, premium=True, is_custom=True))
     ctx.db.commit()
     return {"id": row.b2v_custom_voice_id, "voice_id": row.voice_id, "name": row.name, "source": source,
-            "preview_url": row.preview_url, "saved": True}
+            "preview_url": row.preview_url, "saved": saved}
 
 
 def _make_custom(ctx: Ctx, source: str, send) -> dict:

backend/app/routers/videos.py

@@ -28,10 +28,10 @@ from app.auth import Ctx, get_ctx
 from app.config import settings
 from app.llm import run
 from app.llm.provider import focus_lm
-from app.llm.signatures import VideoFocusTopics
+from app.llm.signatures import VideoFocusAngles
 from app.models import Artifact, B2VVideo, Chat, Document, Message, Notebook, Upload
 from app.routers.sources import is_locked
-from app.services import b2v_access, video_limits, video_quota
+from app.services import b2v_access, video_focus, video_limits, video_quota
 from app.services import blog2video as b2v
 from app.services.artifacts import serialize_artifact
 from app.services.plans import Plan, plan_limit_error
@@ -200,6 +200,8 @@ class VideoCreateIn(VideoOptions):
     # One of the suggested focus topics (/focus-topics): the video is mainly about it. None = the material as a whole.
     focus: str | None = Field(None, max_length=200)
     focus_detail: str | None = Field(None, max_length=400)  # the topic's description: what the video should cover
+    # Or the user's own topic, in their words: followed as far as the material supports it (instead of `focus`).
+    focus_prompt: str | None = Field(None, max_length=500)
 
     @model_validator(mode="after")
     def one_source(self):
@@ -209,6 +211,13 @@ class VideoCreateIn(VideoOptions):
             self.document_id, self.document_ids = self.document_ids[0], None
         return self
 
+    @model_validator(mode="after")
+    def one_focus(self):
+        self.focus_prompt = re.sub(r"\s+", " ", self.focus_prompt or "").strip() or None
+        if self.focus_prompt and (self.focus or "").strip():
+            raise ValueError("Pick a suggested topic or write your own, not both")
+        return self
+
 
 class VideoBatchIn(VideoOptions):
     urls: list[str] = Field(min_length=1, max_length=MAX_LINKS)
@@ -298,10 +307,16 @@ def _source_text(ctx: Ctx, body: FocusIn | VideoCreateIn, limit: int = MAX_CONTE
 
 
 def _instructions(body: VideoCreateIn) -> str:
-    """What blog2video's script writer is told ahead of the material: what a chat is, and the focus picked (worded
-    for the house style's depth). Empty when neither applies."""
+    """What blog2video's script writer is told ahead of the material: what a chat is, and the focus picked or written
+    by the user (worded for the house style's depth). Empty when neither applies."""
     parts = [CHAT_CONTEXT] if body.chat_ids else []
-    if focus := (body.focus or "").strip():
+    if prompt := (body.focus_prompt or "").replace('"', "'"):
+        depth = {"short": " Make it a brief overview.", "medium": " Make it a deep dive."}
+        parts.append(f'The user wants this video to focus on: "{prompt}". Follow it only as far as the material below '
+                     "supports it: use what the material says about it and leave the rest out. If the material does "
+                     "not cover it, ignore this request and make a general video about the material."
+                     + depth.get(b2v_access.house_length(body.video_style), ""))
+    elif focus := (body.focus or "").strip():
         detail = re.sub(r"\s+", " ", body.focus_detail or "").strip().rstrip(".")
         cover = f" What to cover: {detail}." if detail else ""
         length = b2v_access.house_length(body.video_style)
@@ -324,7 +339,7 @@ def _source(ctx: Ctx, body: VideoCreateIn) -> tuple[dict, str]:
         if not re.match(r"https?://", body.url):
             raise HTTPException(400, "Enter a link that starts with http:// or https://")
         return {"url": body.url}, body.title or body.url
-    if body.document_id and not body.focus:
+    if body.document_id and not (body.focus or body.focus_prompt):
         doc = _doc(ctx, body.document_id)
         if re.match(r"https?://", doc.url or ""):
             return {"url": doc.url, "title": doc.title[:255]}, doc.title
@@ -449,21 +464,22 @@ def _excerpt(text: str | None, limit: int) -> str:
     return text[:limit].rsplit(" ", 1)[0] + "..."
 
 
-def _focus_material(ctx: Ctx, body: FocusIn) -> list[str]:
-    """What the focus suggestions read: each post's title and the start of its text, or a chat's title and first
-    exchange (per chat). A little text, so a vague title or an untitled chat still says what it is about. Checked like a create
-    (another workspace's source 404s, locked posts 400)."""
+def _focus_material(ctx: Ctx, body: FocusIn) -> tuple[dict[str, str], list[Document]]:
+    """What the focus suggestions read, per post or chat (by id): each post's title and the start of its text, or a
+    chat's title and first exchange. A little text, so a vague title or an untitled chat still says what it is about.
+    Also the posts themselves (none for chats). Checked like a create (another workspace's source 404s, locked posts
+    400)."""
     if body.chat_ids:
         loaded = _load_chats(ctx, body.chat_ids)
         answer_len = 600 if len(loaded) == 1 else 300
-        items = []
+        material = {}
         for chat, msgs in loaded:
             question = next((m.content for m in msgs if m.role == "user"), "")
             answer = next((m.content for m in msgs if m.role == "assistant"), "")
             parts = [chat.title or "", _excerpt(question, 300), _excerpt(_cite_free(answer), answer_len)]
             if item := "\n".join(p for p in parts if p):
-                items.append(item)
-        return items
+                material[str(chat.id)] = item
+        return material, []
     ids = set(body.document_ids or [body.document_id])
     docs = list(ctx.db.scalars(select(Document).where(Document.id.in_(ids),
                                                       Document.workspace_id == ctx.workspace.id)))
@@ -471,28 +487,42 @@ def _focus_material(ctx: Ctx, body: FocusIn) -> list[str]:
         raise HTTPException(404, "Post not found")
     if locked := sum(is_locked(d) for d in docs):
         raise _not_indexed(locked)
+    docs.sort(key=lambda d: d.published_at or d.created_at, reverse=True)
     each = 800 if len(docs) == 1 else 400
-    items = ["\n".join(p for p in (d.title or "", _excerpt(d.clean_text, each)) if p) for d in docs[:5]]
-    return [i for i in items if i]
+    items = {str(d.id): "\n".join(p for p in (d.title or "", _excerpt(d.clean_text, each)) if p) for d in docs}
+    return {k: v for k, v in items.items() if v}, docs
 
 
 @router.post("/focus-topics")
 def focus_topics(body: FocusIn, ctx: Ctx = Depends(get_ctx)):
-    """Three topics a video from this source could focus on, suggested by the AI from each item's title and the start
-    of its text. Asked for while the wizard is still on step 1, shown on step 2."""
-    items = _focus_material(ctx, body)
-    if not items:
+    """Up to three topics a video from this source could focus on: the topics the workspace already has for it,
+    shown as they are (untagged posts are tagged on demand; a chat's are the cited posts' topics). The AI writes them
+    only when there are none. Asked for and shown on the wizard's step 1, once the source is chosen."""
+    material, docs = _focus_material(ctx, body)
+    if not material:
         return {"topics": []}
+    ws = ctx.workspace.id
+    if body.chat_ids:
+        cited, docs = video_focus.chat_citations(ctx.db, ws, body.chat_ids)
+        sources = {chat: cited.get(chat, {}) for chat in material}
+    else:
+        sources = {str(d.id): {d.id: 1.0} for d in docs}
+    video_focus.ensure_tags(ctx.db, ws, docs)
+    if cards := video_focus.pick_cards(video_focus.build_pool(ctx.db, ws, sources, docs)):
+        return {"topics": [{"title": c.name, "description": c.summary} for c in cards]}
+    items = list(material.values())[:FOCUS_ITEMS]
     topics: list[dict] = []
     # One retry when the answer has fewer than 3 usable topics (a placeholder for every title, repeats).
     for retry in (False, True):
-        out = run.predict(VideoFocusTopics, db=ctx.db, workspace_id=ctx.workspace.id, lm=focus_lm(retry), items=items)
+        out = run.predict(VideoFocusAngles, db=ctx.db, workspace_id=ws, lm=focus_lm(retry), items=items,
+                          candidate_tags=[], avoid_titles=[])
         _add_topics(topics, out.get("topics"))
         if len(topics) >= 3:
             break
     return {"topics": topics[:3]}
 
 
+FOCUS_ITEMS = 5  # posts or chats the AI reads when there are no topics to show
 FOCUS_PLACEHOLDERS = {"title", "topic", "description", "summary", "name", "angle", "focus"}
 
 

backend/app/routers/voice.py

@@ -11,6 +11,7 @@ from app.auth import Ctx, get_ctx
 from app.config import settings
 from app.models import Document, Job, Upload, VoiceConsent, VoiceProfile
 from app.services import tts
+from app.services.notestack_voices import forget_video_voice
 from app.services.jobs import create_job, record_usage, serialize_job
 from app.services.plans import effective_plan, plan_limit_error
 from app.services.storage import storage
@@ -206,10 +207,15 @@ async def add_from_library(body: LibraryAddIn, ctx: Ctx = Depends(get_ctx)):
         voice_id = await run_in_threadpool(tts.add_library_voice, body.public_owner_id, body.voice_id, body.name)
     except tts.TTSError as exc:
         raise HTTPException(502, str(exc)) from exc
+    vp = _ensure_profile(ctx)
+    voices = dict(vp.host_voices or {})
+    # Listed, so it can be added to the workspace's video voices too.
+    added = [v for v in voices.get("added") or [] if v.get("voice_id") != voice_id]
+    voices["added"] = [*added, {"voice_id": voice_id, "name": body.name[:100]}]
     if body.use_as in ("host_a", "host_b"):
-        vp = _ensure_profile(ctx)
-        vp.host_voices = {**(vp.host_voices or {}), body.use_as: voice_id}
-        ctx.db.commit()
+        voices[body.use_as] = voice_id
+    vp.host_voices = voices
+    ctx.db.commit()
     return {"voice_id": voice_id, **_serialize(ctx)}
 
 
@@ -369,5 +375,7 @@ async def revoke_consent(ctx: Ctx = Depends(get_ctx)):
     vp = _profile(ctx)
     if vp and vp.host_voices:
         vp.host_voices = {k: v for k, v in vp.host_voices.items() if v != consent.elevenlabs_voice_id}
+    if consent.elevenlabs_voice_id:
+        forget_video_voice(ctx.db, ctx.workspace.id, consent.elevenlabs_voice_id)
     ctx.db.commit()
     return _serialize(ctx)

backend/app/services/b2v_access.py

@@ -14,6 +14,7 @@ from sqlalchemy import select
 from app.auth import Ctx
 from app.models import Artifact, B2VCustomVoice, B2VStyle, B2VTemplate, B2VVideo
 from app.services import blog2video as b2v
+from app.services.notestack_voices import is_notestack_voice
 from app.services.plans import Plan, effective_plan
 from app.services.video_limits import require_premium
 
@@ -157,7 +158,8 @@ def check_style(ctx: Ctx, style: str) -> None:
 
 
 def check_voice(ctx: Ctx, voice_id: str, plan: Plan) -> None:
-    """A built-in voice (premium if blog2video marks it paid) or one of this workspace's custom voices."""
+    """A built-in voice (premium if blog2video marks it paid), or one of this workspace's custom or Notestack
+    voices."""
     prebuilt = {v.get("voice_id"): v for v in b2v.prebuilt_voices()}
     if voice_id in prebuilt:
         if prebuilt[voice_id].get("plan") == "paid":
@@ -167,6 +169,10 @@ def check_voice(ctx: Ctx, voice_id: str, plan: Plan) -> None:
                                                   B2VCustomVoice.workspace_id == ctx.workspace.id)):
         require_premium(ctx.db, ctx.workspace, "Custom voices", plan)
         return
+    # One of this workspace's Notestack voices (clone, designed, added): same ElevenLabs account, premium like custom.
+    if is_notestack_voice(ctx.db, ctx.workspace.id, voice_id):
+        require_premium(ctx.db, ctx.workspace, "Custom voices", plan)
+        return
     raise not_found("Voice not found")
 
 

backend/app/services/jobs.py

@@ -46,6 +46,12 @@ def serialize_job(job: Job) -> dict:
 # Producer side
 
 
+def pending_job(db: Session, workspace_id: uuid.UUID, kind: str) -> bool:
+    """A job of this kind is already queued or running for the workspace."""
+    return db.scalar(select(Job.id).where(Job.workspace_id == workspace_id, Job.kind == kind,
+                                          Job.status.in_(("queued", "running"))).limit(1)) is not None
+
+
 def create_job(
     db: Session,
     workspace_id: uuid.UUID,

backend/app/services/notestack_voices.py

@@ -0,0 +1,37 @@
+"""The workspace's own ElevenLabs voices, made or added on the Voice page: its clone, designed voices, and voices added
+from the ElevenLabs library. blog2video speaks with the same ElevenLabs account, so these can be used in videos too
+(as `custom_voice_id`); video_voices lists them and b2v_access accepts them."""
+
+import uuid
+
+from sqlalchemy import delete, select
+from sqlalchemy.orm import Session
+
+from app.models import UserSavedVoice, VoiceConsent, VoiceProfile
+
+
+def notestack_voices(db: Session, workspace_id: uuid.UUID) -> list[dict]:
+    """[{voice_id, name, kind}], kind: clone | designed | library. The clone first, no repeats."""
+    out: list[dict] = []
+    consent = db.scalar(select(VoiceConsent).where(VoiceConsent.workspace_id == workspace_id,
+                                                   VoiceConsent.revoked_at.is_(None))
+                        .order_by(VoiceConsent.created_at.desc()))
+    if consent and consent.elevenlabs_voice_id:
+        out.append({"voice_id": consent.elevenlabs_voice_id, "name": "My voice", "kind": "clone"})
+    vp = db.scalar(select(VoiceProfile).where(VoiceProfile.workspace_id == workspace_id))
+    voices = (vp.host_voices if vp else None) or {}
+    for kind, key in (("designed", "custom"), ("library", "added")):
+        for v in voices.get(key) or []:
+            if v.get("voice_id") and all(o["voice_id"] != v["voice_id"] for o in out):
+                out.append({"voice_id": v["voice_id"], "name": v.get("name") or "Voice", "kind": kind})
+    return out
+
+
+def is_notestack_voice(db: Session, workspace_id: uuid.UUID, voice_id: str) -> bool:
+    return any(v["voice_id"] == voice_id for v in notestack_voices(db, workspace_id))
+
+
+def forget_video_voice(db: Session, workspace_id: uuid.UUID, voice_id: str) -> None:
+    """A Notestack voice that is gone (clone revoked) leaves the workspace's saved video voices too."""
+    db.execute(delete(UserSavedVoice).where(UserSavedVoice.workspace_id == workspace_id,
+                                            UserSavedVoice.voice_id == voice_id))

backend/app/services/video_focus.py

@@ -0,0 +1,156 @@
+"""The video wizard's focus cards: the topics the workspace already has for the source, shown as they are.
+
+Each post is tagged by the background `topics` job (generate.extract_topics); a post still without tags is tagged
+here on demand. A source's tags make its pool, each scored by weight and by how much of the source shares it (a
+chat's tags are those of the posts its answers cite). The cards are the best merged topics (the Topic Map's, with a
+summary), spread over the source's posts, then the posts' own tags (a name only) when there are fewer than three.
+"""
+
+import uuid
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from app.config import settings
+from app.corpus import slugify
+from app.llm import run
+from app.llm.provider import fast_lm
+from app.llm.signatures import ExtractTopics
+from app.models import Citation, Document, DocumentTopic, Message, Topic
+from app.pipeline.generate import save_topic_tags
+from app.routers.sources import is_locked
+from app.services.jobs import create_job, pending_job
+
+INLINE_TAG_CAP = 5  # untagged posts tagged while the wizard waits; the rest go to the background job
+TAG_TEXT = 6000  # characters of a post read when tagging it on demand (the background job reads 12000)
+CARDS = 3
+
+
+@dataclass
+class Candidate:
+    name: str
+    summary: str
+    score: float
+    sources: set[str]  # the posts (or chats) that carry it
+    merged: bool  # a topic of the topic table (has a summary), not only a post's own tag
+
+
+# Tags
+
+
+def ensure_tags(db: Session, workspace_id: uuid.UUID, docs: list[Document]) -> None:
+    """Tag the newest few untagged posts now, in parallel, and leave the rest to the background job, which also
+    merges these new tags into the topic table. A failed call leaves that post untagged: never an error here."""
+    untagged = [d for d in docs if not (d.metadata_json or {}).get("topics") and not is_locked(d)]
+    if not untagged or not settings.llm_api_key:
+        return
+    untagged.sort(key=lambda d: d.published_at or d.created_at, reverse=True)
+    now = untagged[:INLINE_TAG_CAP]
+    known = sorted(db.scalars(select(Topic.name).where(Topic.workspace_id == workspace_id)))[:200]
+    outs = run.predict_many(ExtractTopics, [{"title": d.title, "text": (d.clean_text or "")[:TAG_TEXT],
+                                             "known_topics": known} for d in now],
+                            db=db, workspace_id=workspace_id, lm=fast_lm())
+    for doc, out in zip(now, outs, strict=True):
+        if out is not None:
+            save_topic_tags(doc, out)
+    db.commit()
+    # With no ids the job tags every post still untagged (the rest of these too) and rebuilds the topic table.
+    if not pending_job(db, workspace_id, "topics"):
+        create_job(db, workspace_id, "topics", {}, max_attempts=2)
+
+
+def chat_citations(db: Session, workspace_id: uuid.UUID,
+                   chat_ids: list[uuid.UUID]) -> tuple[dict[str, dict[uuid.UUID, float]], list[Document]]:
+    """For each chat, the posts its answers cite (weighted by how often, the most cited 1.0), and those posts.
+    Locked posts are left out: the chat itself is fine to use."""
+    rows = db.execute(
+        select(Message.chat_id, Citation.document_id, func.count())
+        .join(Citation, Citation.message_id == Message.id)
+        .where(Message.chat_id.in_(chat_ids))
+        .group_by(Message.chat_id, Citation.document_id)
+    ).all()
+    docs = {d.id: d for d in db.scalars(select(Document).where(
+        Document.id.in_({doc_id for _, doc_id, _ in rows}), Document.workspace_id == workspace_id)) if not is_locked(d)}
+    counts: dict[str, dict[uuid.UUID, int]] = defaultdict(dict)
+    for chat_id, doc_id, n in rows:
+        if doc_id in docs:
+            counts[str(chat_id)][doc_id] = n
+    cited = {chat: {d: n / max(per.values()) for d, n in per.items()} for chat, per in counts.items()}
+    return cited, list(docs.values())
+
+
+def build_pool(db: Session, workspace_id: uuid.UUID, sources: dict[str, dict[uuid.UUID, float]],
+               docs: list[Document]) -> list[Candidate]:
+    """Every tag of the source's posts, best first. A source is a post (itself, weight 1) or a chat (the posts it
+    cites). Score: the tag's weight summed over the sources that carry it, times the share of sources that do, so a
+    theme running through the selection beats one post's strongest tag."""
+    tags = _doc_tags(db, workspace_id, docs)
+    score: dict[str, float] = defaultdict(float)
+    carried: dict[str, set[str]] = defaultdict(set)
+    summaries: dict[str, str] = {}
+    merged: dict[str, bool] = defaultdict(bool)
+    for source, weights in sources.items():
+        best: dict[str, float] = {}
+        for doc_id, w in weights.items():
+            for name, (tag_weight, summary, is_merged) in tags.get(doc_id, {}).items():
+                best[name] = max(best.get(name, 0.0), tag_weight * w)
+                summaries.setdefault(name, summary)
+                merged[name] |= is_merged
+        for name, v in best.items():
+            score[name] += v
+            carried[name].add(source)
+    total = max(len(sources), 1)
+    pool = [Candidate(name, summaries[name], score[name] * len(carried[name]) / total, carried[name], merged[name])
+            for name in score]
+    return sorted(pool, key=lambda c: (-c.score, c.name))
+
+
+def _doc_tags(db: Session, workspace_id: uuid.UUID,
+              docs: list[Document]) -> dict[uuid.UUID, dict[str, tuple[float, str, bool]]]:
+    """Post -> {topic name: (weight, summary, merged)}: the topic table's (merged) topics and the post's own tags. The
+    merge folds a post's specific tags into a few broad workspace topics ("Content Repurposing" into "Finance
+    Substacks & Audience Growth"), which alone leaves a single post one or two angles; the merged names are what lets
+    posts share a tag. An own tag is named as the topic table's matching topic if any, and skipped if already there."""
+    out: dict[uuid.UUID, dict[str, tuple[float, str, bool]]] = defaultdict(dict)
+    rows = db.execute(
+        select(DocumentTopic.document_id, DocumentTopic.weight, Topic.name, Topic.summary)
+        .join(Topic, Topic.id == DocumentTopic.topic_id)
+        .where(DocumentTopic.document_id.in_([d.id for d in docs]), Topic.workspace_id == workspace_id)
+    ).all()
+    for doc_id, weight, name, summary in rows:
+        out[doc_id][name] = (float(weight or 0.5), summary or "", True)
+    own = [d for d in docs if (d.metadata_json or {}).get("topics")]
+    if own:
+        known = {t.slug: t for t in db.scalars(select(Topic).where(Topic.workspace_id == workspace_id))}
+        for d in own:
+            have = {slugify(n, 120) for n in out[d.id]}
+            for t in d.metadata_json["topics"]:
+                topic = known.get(slugify(t["name"], 120))
+                name = topic.name if topic else t["name"]
+                if slugify(name, 120) in have:
+                    continue
+                have.add(slugify(name, 120))
+                summary = (topic.summary or "") if topic else ""
+                out[d.id][name] = (float(t.get("weight") or 0.5), summary, topic is not None)
+    return out
+
+
+def pick_cards(pool: list[Candidate], n: int = CARDS) -> list[Candidate]:
+    """The cards: merged topics first, then own tags. Within each, best score first, halved for each card already on
+    every post the topic has, so several posts' cards do not all come from one post."""
+    chosen: list[Candidate] = []
+    covered: Counter[str] = Counter()  # source -> cards on it so far
+
+    def worth(c: Candidate) -> float:
+        return c.score * 0.5 ** min(covered[s] for s in c.sources)
+
+    for group in ([c for c in pool if c.merged], [c for c in pool if not c.merged]):
+        rest = list(enumerate(group))  # the pool's order breaks ties
+        while rest and len(chosen) < n:
+            i, best = max(rest, key=lambda ic: (worth(ic[1]), -ic[0]))
+            chosen.append(best)
+            covered.update(best.sources)
+            rest.remove((i, best))
+    return chosen

backend/app/worker.py

@@ -29,6 +29,7 @@ from app.config import settings
 from app.db import SessionLocal, engine
 from app.models import (
     Artifact,
+    Document,
     Job,
     Source,
     Subscription,
@@ -47,7 +48,15 @@ from app.pipeline.ingest import FeedNotFound, entry_from_upload, extract_article
 from app.services import launchpad, tts, video_quota
 from app.services.email import email_service
 from app.services.email_verification import purge_old_codes
-from app.services.jobs import claim_next, create_job, record_usage, retry_or_fail, stale_jobs, update_job
+from app.services.jobs import (
+    claim_next,
+    create_job,
+    pending_job,
+    record_usage,
+    retry_or_fail,
+    stale_jobs,
+    update_job,
+)
 from app.services.plans import effective_plan
 from app.services.renderer import PermanentJobError, request_render
 from app.services.storage import keys, storage
@@ -67,21 +76,16 @@ HANDED_OFF = object()  # the job continues elsewhere (renderer) and reports back
 # Handlers: (db, job) -> Done | HANDED_OFF. Raise to trigger a retry.
 
 
-def _pending(db: Session, workspace_id: uuid.UUID, kind: str) -> bool:
-    return db.scalar(select(Job.id).where(Job.workspace_id == workspace_id, Job.kind == kind,
-                                          Job.status.in_(("queued", "running"))).limit(1)) is not None
-
-
 def _after_import(db: Session, job: Job, workspace_id: uuid.UUID, changed: list[str]) -> None:
     """New or changed posts are mapped into the topic constellation and scored for resurfacing, and the
     first import builds the writing voice, so none of these need a button press."""
     if not changed or not settings.llm_api_key:
         return
     create_job(db, workspace_id, "topics", {"document_ids": changed}, max_attempts=2)
-    if not _pending(db, workspace_id, "resurface_scan"):
+    if not pending_job(db, workspace_id, "resurface_scan"):
         create_job(db, workspace_id, "resurface_scan", {}, max_attempts=2)
     vp = db.scalar(select(VoiceProfile).where(VoiceProfile.workspace_id == workspace_id))
-    if not (vp and vp.profile_json) and not _pending(db, workspace_id, "voice_profile"):
+    if not (vp and vp.profile_json) and not pending_job(db, workspace_id, "voice_profile"):
         create_job(db, workspace_id, "voice_profile", {"document_ids": []}, max_attempts=2)
 
 
@@ -307,6 +311,19 @@ def single_flight(name: str):
                 conn.commit()
 
 
+def topics_backfill(session_factory: Callable[[], Session] = SessionLocal) -> None:
+    """Every indexed post gets topics: one whose tagging failed (the model timed out, rate limited, answered nothing)
+    or that came before posts were tagged on import is asked for again here, one topics job per workspace that has
+    some, unless one is already queued. A post that keeps failing stops being asked (generate.MAX_TAG_FAILURES)."""
+    if not settings.llm_api_key:
+        return
+    with session_factory() as db:
+        rows = db.execute(select(Document.workspace_id, Document.metadata_json).where(Document.path.is_not(None)))
+        for workspace_id in {ws for ws, meta in rows if generate.needs_topics(meta)}:
+            if not pending_job(db, workspace_id, "topics"):
+                create_job(db, workspace_id, "topics", {}, max_attempts=2)
+
+
 def update_email_batch(session_factory: Callable[[], Session] = SessionLocal) -> None:
     """Sends one daily batch per scheduled campaign at its send hour (UTC)."""
     now = datetime.now(UTC)
@@ -363,6 +380,7 @@ PERIODIC = [
     Periodic("publish_due", 30, launchpad.publish_due),
     Periodic("sync_engagement", 3600, launchpad.sync_engagement),
     Periodic("update_email_batch", 300, update_email_batch),
+    Periodic("topics_backfill", 900, topics_backfill),
     Periodic("daily_cleanup", 24 * 3600, daily_cleanup),
     Periodic("video_period_reset", 3600, video_quota.reset_due_video_periods),
     Periodic("video_refund_sweep", 600, video_quota.sweep_failed_videos),

backend/tests/test_buildout.py

@@ -329,6 +329,75 @@ def test_topic_map_and_notebook_from_topic(client, auth, run_jobs, feed, llm):
     assert nb["added"] == 1
 
 
+def topic_metas(session_factory) -> dict[str, dict]:
+    with session_factory() as db:
+        return {d.title: d.metadata_json or {} for d in db.query(Document).filter(Document.path.is_not(None))}
+
+
+def test_a_post_the_model_fails_on_is_tried_again(client, auth, run_jobs, feed, llm, monkeypatch, session_factory):
+    from app.pipeline import generate
+    monkeypatch.setattr(generate, "TAG_BACKOFF", (0.0, 0.0))
+    connect(client, auth, run_jobs)
+    tries: dict[str, int] = {}
+
+    def extract(title, **_):
+        tries[title] = tries.get(title, 0) + 1
+        if tries[title] == 1:
+            raise TimeoutError("the model timed out")  # once per post: the second try works
+        if tries[title] == 2 and "Pricing" in title:
+            return {"topics": []}  # an empty answer is not a result: tried a third time
+        return {"topics": [{"name": "Writing", "weight": 0.8}]}
+
+    llm["ExtractTopics"] = extract
+    llm["ConsolidateTopics"] = {"groups": []}
+    client.post("/api/topics/rebuild", headers=auth)
+    job = run_jobs()[0]
+    metas = topic_metas(session_factory)
+    assert job.status == "done" and job.result["tagged"] == len(metas) and job.result["failed"] == 0
+    assert all(m["topics"] == [{"name": "Writing", "weight": 0.8}] for m in metas.values())
+    assert max(tries.values()) == 3
+
+
+def test_every_post_gets_topics_through_the_sweep(client, auth, run_jobs, feed, llm, monkeypatch, session_factory):
+    from app import worker
+    from app.config import settings
+    from app.pipeline import generate
+    monkeypatch.setattr(generate, "TAG_BACKOFF", (0.0, 0.0))
+    monkeypatch.setattr(settings, "llm_api_key", "test-key")
+    llm["ConsolidateTopics"] = {"groups": []}
+    llm["ExtractTopics"] = lambda **_: (_ for _ in ()).throw(TimeoutError("the model is down"))
+    connect(client, auth, run_jobs)  # the import's topics job runs too, and tags nothing
+    metas = topic_metas(session_factory)
+    assert metas and all("topics" not in m and m["topics_failures"] == 1 for m in metas.values())
+
+    worker.topics_backfill(session_factory)
+    worker.topics_backfill(session_factory)  # one job per workspace, not one per sweep
+    llm["ExtractTopics"] = {"topics": [{"name": "Pricing", "weight": 0.9}]}  # the model is back
+    jobs = run_jobs()
+    assert len(jobs) == 1 and jobs[0].result["tagged"] == len(metas)
+    assert all(m["topics"] and "topics_failures" not in m for m in topic_metas(session_factory).values())
+    worker.topics_backfill(session_factory)
+    assert not run_jobs()  # all tagged: nothing to do
+
+
+def test_the_sweep_gives_up_on_a_post_that_keeps_failing(client, auth, run_jobs, feed, llm, monkeypatch,
+                                                         session_factory):
+    from app import worker
+    from app.config import settings
+    from app.pipeline import generate
+    monkeypatch.setattr(generate, "TAG_BACKOFF", (0.0, 0.0))
+    monkeypatch.setattr(settings, "llm_api_key", "test-key")
+    llm["ConsolidateTopics"] = {"groups": []}
+    llm["ExtractTopics"] = lambda **_: (_ for _ in ()).throw(TimeoutError("always"))
+    connect(client, auth, run_jobs)
+    for _ in range(generate.MAX_TAG_FAILURES):
+        worker.topics_backfill(session_factory)
+        run_jobs()
+    assert all(m["topics_failures"] == generate.MAX_TAG_FAILURES for m in topic_metas(session_factory).values())
+    worker.topics_backfill(session_factory)
+    assert not run_jobs()
+
+
 def test_voice_profile_build_and_edit(client, auth, run_jobs, feed, llm):
     connect(client, auth, run_jobs)
     profile = {"tone": ["warm"], "sentence_length": "short", "vocabulary": ["readers"], "structure_habits": [],

backend/tests/test_videos.py

@@ -20,15 +20,22 @@ from app.models import (
     B2VTemplate,
     B2VVideo,
     Chat,
+    Citation,
     Document,
+    DocumentTopic,
+    Job,
     Message,
     Notebook,
     Subscription,
+    Topic,
     UsageCounter,
+    User,
     UserSavedVoice,
+    VoiceConsent,
+    VoiceProfile,
     Workspace,
 )
-from app.services import blog2video, video_limits, video_quota
+from app.services import blog2video, video_focus, video_limits, video_quota
 from tests.conftest import last_code
 
 KEY = "b2v_live_test_key"
@@ -599,7 +606,7 @@ def test_focus_topics_for_posts_a_chat_and_one_post(client, owner, db_session, s
             {"title": "Why prices go up", "description": "Why raises happen. Once a year, with notice."},
             {"title": "Grandfathering early readers", "description": "Keep early prices."},
             {"title": "Annual raises", "description": "One raise a year."}]
-    assert [s["signature"] for s in suggest] == ["VideoFocusTopics"] * 3
+    assert [s["signature"] for s in suggest] == ["VideoFocusAngles"] * 3  # no topics to show: the AI writes them
     # Each item is a title and the start of its text: a little, never the whole post or transcript.
     posts, chat_item, one = (s["items"] for s in suggest)
     assert len(posts) == 2 and all(p.startswith("On Pricing\n") for p in posts)
@@ -660,6 +667,189 @@ def test_focus_topics_check_the_source(client, owner, other, db_session, suggest
     assert r.status_code == 400 and not suggest
 
 
+# Focus topics: the workspace's own, shown as they are
+
+
+@pytest.fixture()
+def angles(monkeypatch):
+    """The AI, canned: VideoFocusAngles (only when there are no topics to show) answers three fixed angles.
+    ExtractTopics (tagging on demand) answers per post from `tag_answers` (title -> tags; None = the call failed)."""
+    from app.llm import run
+    calls: dict = {"focus": [], "tagged": [], "tag_answers": {}}
+
+    def predict(signature, *, db, workspace_id, job=None, lm=None, **inputs):
+        calls["focus"].append(inputs)
+        return {"topics": [{"topic": f"AI angle {i}", "summary": "Written by the AI.", "tag": ""} for i in range(3)]}
+
+    def predict_many(signature, inputs_list, *, db, workspace_id, lm=None, workers=5):
+        calls["tagged"].append([i["title"] for i in inputs_list])
+        answers = [calls["tag_answers"].get(i["title"], []) for i in inputs_list]
+        return [None if a is None else {"topics": [{"name": n, "weight": 0.8} for n in a]} for a in answers]
+
+    monkeypatch.setattr(run, "predict", predict)
+    monkeypatch.setattr(run, "predict_many", predict_many)
+    monkeypatch.setattr(settings, "llm_api_key", "test-key")
+    return calls
+
+
+def tagged_doc(db, ws, slug: str, tags: list[str], title: str = "On Pricing",
+               weights: list[float] | None = None) -> Document:
+    doc = add_doc(db, ws, f"https://ada.example.com/p/{slug}", f"All about {slug}. " * 20)
+    weights = weights or [0.8] * len(tags)
+    doc.title = title
+    doc.metadata_json = {"topics": [{"name": t, "weight": w} for t, w in zip(tags, weights, strict=True)]}
+    db.commit()
+    return doc
+
+
+def merge(db, ws, name: str, summary: str, *links: tuple[Document, float]) -> Topic:
+    """A topic of the topic table (what rebuild_topics makes), linked to posts with a weight."""
+    topic = Topic(workspace_id=ws.id, name=name, slug=name.lower().replace(" ", "-"), summary=summary,
+                  post_count=len(links))
+    db.add(topic)
+    db.flush()
+    db.add_all([DocumentTopic(document_id=d.id, topic_id=topic.id, weight=w) for d, w in links])
+    db.commit()
+    return topic
+
+
+def focus(client, headers, **body) -> list[dict]:
+    r = client.post("/api/videos/focus-topics", json=body, headers=headers)
+    assert r.status_code == 200, r.text
+    return r.json()["topics"]
+
+
+def test_a_tag_shared_by_the_selection_outranks_one_posts_strongest(owner, db_session):
+    _, ws = owner
+    docs = [add_doc(db_session, ws, f"https://ada.example.com/p/{i}", "Text.") for i in range(3)]
+    merge(db_session, ws, "Pricing", "How to price.", *[(d, 0.5) for d in docs])
+    merge(db_session, ws, "Churn", "", (docs[0], 1.0))
+    pool = video_focus.build_pool(db_session, ws.id, {str(d.id): {d.id: 1.0} for d in docs}, docs)
+    assert [c.name for c in pool] == ["Pricing", "Churn"]
+    assert pool[0].summary == "How to price." and len(pool[0].sources) == 3 and pool[0].merged
+
+
+def test_a_posts_own_tags_join_the_merged_topics(owner, db_session):
+    """The merge folds a post's specific tags into a few broad topics; the specific ones still count."""
+    _, ws = owner
+    doc = tagged_doc(db_session, ws, "a", ["Content Repurposing", "Video Marketing", "Finance Writing"])
+    merge(db_session, ws, "Finance Substacks", "Growing a finance newsletter.", (doc, 0.9))
+    merge(db_session, ws, "Finance Writing", "", (doc, 0.4))
+    pool = video_focus.build_pool(db_session, ws.id, {str(doc.id): {doc.id: 1.0}}, [doc])
+    assert sorted((c.name, c.merged) for c in pool) == [
+        ("Content Repurposing", False), ("Finance Substacks", True), ("Finance Writing", True),  # once, merged
+        ("Video Marketing", False)]
+
+
+def test_existing_topics_are_shown_as_they_are_without_the_ai(client, owner, db_session, angles):
+    headers, ws = owner
+    doc = tagged_doc(db_session, ws, "a", ["Chinese LLMs", "Token Pricing", "Software Margins"],
+                     weights=[0.9, 0.7, 0.5])
+    merge(db_session, ws, "AI & China LLM Competition", "Why Chinese LLMs are cheaper.", (doc, 0.9))
+    cards = focus(client, headers, document_id=str(doc.id))
+    # Merged topics first (with their summary), then the post's own tags (a name only), best first.
+    assert cards == [{"title": "AI & China LLM Competition", "description": "Why Chinese LLMs are cheaper."},
+                     {"title": "Chinese LLMs", "description": ""},
+                     {"title": "Token Pricing", "description": ""}]
+    assert not angles["focus"] and not angles["tagged"]  # no AI at all
+
+
+def test_a_fresh_tag_that_names_a_merged_topic_is_shown_with_its_summary(client, owner, db_session, angles):
+    headers, ws = owner
+    merge(db_session, ws, "Annual Raises", "Once a year, with notice.")
+    doc = tagged_doc(db_session, ws, "a", ["annual raises"])
+    assert focus(client, headers, document_id=str(doc.id)) == [
+        {"title": "Annual Raises", "description": "Once a year, with notice."}]  # one topic: one card, no AI
+    assert not angles["focus"]
+
+
+def test_several_posts_show_their_shared_topics_first_spread_over_the_posts(client, owner, db_session, angles):
+    headers, ws = owner
+    a, b, c = (tagged_doc(db_session, ws, s, [f"{s} own"], title=f"Post {s}") for s in "abc")
+    merge(db_session, ws, "Pricing", "Shared by all.", (a, 0.5), (b, 0.5), (c, 0.5))
+    merge(db_session, ws, "A Big", "Post a's main topic.", (a, 1.0))
+    merge(db_session, ws, "A Small", "Post a again.", (a, 0.9))
+    merge(db_session, ws, "B Side", "Post b's.", (b, 0.8))
+    cards = focus(client, headers, document_ids=[str(d.id) for d in (a, b, c)])
+    # Pricing (in all three) first; then post a's topics are already covered, so b's comes before a's second one.
+    assert [x["title"] for x in cards] == ["Pricing", "A Big", "B Side"]
+    assert not angles["focus"]
+
+
+def test_untagged_posts_are_tagged_on_demand_then_shown(client, owner, db_session, angles):
+    headers, ws = owner
+    docs = [add_doc(db_session, ws, f"https://ada.example.com/p/{i}", "Some text. " * 20) for i in range(7)]
+    for i, d in enumerate(docs):
+        d.title, d.published_at = f"Post {i}", datetime(2026, 1, 1 + i, tzinfo=UTC)
+    db_session.commit()
+    angles["tag_answers"] = {f"Post {i}": [f"Theme {i}", "Pricing"] for i in range(7)}
+    angles["tag_answers"]["Post 6"] = None  # that call failed
+    body = {"document_ids": [str(d.id) for d in docs]}
+    cards = focus(client, headers, **body)
+    assert angles["tagged"] == [["Post 6", "Post 5", "Post 4", "Post 3", "Post 2"]]  # the newest five
+    assert cards[0] == {"title": "Pricing", "description": ""} and len(cards) == 3  # in 4 posts: first
+    assert not angles["focus"]
+    db_session.expire_all()
+    assert [d.metadata_json.get("topics", [{}])[0].get("name") for d in docs] == [
+        None, None, "Theme 2", "Theme 3", "Theme 4", "Theme 5", None]
+    jobs = db_session.scalars(select(Job).where(Job.workspace_id == ws.id, Job.kind == "topics")).all()
+    assert len(jobs) == 1 and jobs[0].params == {}
+    focus(client, headers, **body)  # the job is still queued: not again
+    assert len(db_session.scalars(select(Job).where(Job.workspace_id == ws.id, Job.kind == "topics")).all()) == 1
+
+
+def test_with_no_topics_to_show_the_ai_writes_them(client, owner, db_session, angles, monkeypatch):
+    headers, ws = owner
+    monkeypatch.setattr(settings, "llm_api_key", "")  # nothing is tagged
+    doc = add_doc(db_session, ws, "https://ada.example.com/p/a", "Raise prices once a year. " * 5)
+    cards = focus(client, headers, document_id=str(doc.id))
+    assert [c["title"] for c in cards] == ["AI angle 0", "AI angle 1", "AI angle 2"] and not angles["tagged"]
+    assert angles["focus"][0]["candidate_tags"] == [] and angles["focus"][0]["avoid_titles"] == []
+
+
+def cite(db, chat: Chat, *docs: Document) -> None:
+    answer = db.scalars(select(Message).where(Message.chat_id == chat.id, Message.role == "assistant")).first()
+    db.add_all([Citation(message_id=answer.id, document_id=d.id, marker=i + 1, path="sources/x/p.md", line_start=1,
+                         line_end=2) for i, d in enumerate(docs)])
+    db.commit()
+
+
+def test_a_chat_shows_the_topics_of_the_posts_it_cites(client, owner, db_session, angles):
+    headers, ws = owner
+    a = tagged_doc(db_session, ws, "a", ["Annual Raises"])
+    b = tagged_doc(db_session, ws, "b", ["Grandfathering"])
+    tagged_doc(db_session, ws, "c", ["Never Cited"])
+    merge(db_session, ws, "Pricing", "How to price.", (a, 0.9), (b, 0.9))
+    chat = add_chat(db_session, ws, [("user", "How should I price?"),
+                                     ("assistant", "Once a year [1], keep early [2].")])
+    cite(db_session, chat, a, b)
+    cards = focus(client, headers, chat_ids=[str(chat.id)])
+    assert cards[0] == {"title": "Pricing", "description": "How to price."}
+    assert {c["title"] for c in cards[1:]} == {"Annual Raises", "Grandfathering"} and not angles["focus"]
+
+
+def test_a_chats_cited_posts_get_tagged_and_locked_ones_are_skipped(client, owner, db_session, angles):
+    headers, ws = owner
+    fresh = add_doc(db_session, ws, "https://ada.example.com/p/fresh", "New post. " * 20)
+    fresh.title = "Fresh"
+    locked = add_doc(db_session, ws, "https://ada.example.com/p/locked")
+    locked.title, locked.path, locked.metadata_json = "Locked", None, {"locked": True}
+    db_session.commit()
+    angles["tag_answers"] = {"Fresh": ["Pricing", "Churn"]}
+    chat = add_chat(db_session, ws, [("user", "Q?"), ("assistant", "An answer [1] [2].")])
+    cite(db_session, chat, fresh, locked)
+    cards = focus(client, headers, chat_ids=[str(chat.id)])
+    assert angles["tagged"] == [["Fresh"]] and {c["title"] for c in cards} == {"Pricing", "Churn"}
+
+
+def test_a_chat_without_citations_gets_ai_topics(client, owner, db_session, angles):
+    headers, ws = owner
+    chat = add_chat(db_session, ws, [("user", "Hi there"), ("assistant", "Hello! Ask me about your posts.")])
+    cards = focus(client, headers, chat_ids=[str(chat.id)])
+    assert len(cards) == 3 and angles["focus"] and not angles["tagged"]
+    assert angles["focus"][0]["items"] == ["Pricing chat\nHi there\nHello! Ask me about your posts."]
+
+
 @pytest.mark.parametrize("style,length,words", [("custom:20", "short", "overview of that topic"),
                                                 ("custom:21", "medium", "deep dive into that topic")])
 def test_focus_goes_ahead_of_the_material_worded_for_the_style(client, b2v, owner, house, db_session,
@@ -680,6 +870,36 @@ def test_focus_goes_ahead_of_the_material_worded_for_the_style(client, b2v, owne
     assert '"Annual raises"' in head and "What to cover" not in head
 
 
+@pytest.mark.parametrize("style,depth", [("custom:20", "Make it a brief overview."),
+                                         ("custom:21", "Make it a deep dive.")])
+def test_a_custom_topic_goes_ahead_of_the_material(client, b2v, owner, house, db_session, style, depth):
+    headers, ws = owner
+    doc = add_doc(db_session, ws, "https://ada.example.com/p/a", "Raise prices once a year, and say why. " * 3)
+    make_video(client, headers, url=None, document_id=str(doc.id), video_style=style,
+               focus_prompt='  Why the  "yearly" raise\nbeats small ones ')
+    sent = creates(b2v)[-1]["json"]
+    assert "url" not in sent  # the instruction needs the text, not the link
+    head, material = sent["content"].split("\n\n---\n\n", 1)
+    assert head.startswith("The user wants this video to focus on: \"Why the 'yearly' raise beats small ones\".")
+    assert "only as far as the material below supports it" in head and "make a general video" in head
+    assert head.endswith(depth) and material.startswith("Raise prices")
+
+
+def test_a_blank_custom_topic_is_no_focus(client, b2v, owner, db_session):
+    headers, ws = owner
+    doc = add_doc(db_session, ws, "https://ada.example.com/p/a", "Raise prices once a year, and say why. " * 3)
+    make_video(client, headers, url=None, document_id=str(doc.id), focus_prompt="   ")
+    assert creates(b2v)[-1]["json"]["url"] == "https://ada.example.com/p/a"  # the link, as with no focus
+
+
+def test_a_suggested_and_a_custom_topic_together_are_refused(client, b2v, owner, db_session):
+    headers, ws = owner
+    doc = add_doc(db_session, ws, "https://ada.example.com/p/a", "Raise prices once a year, and say why. " * 3)
+    r = client.post("/api/videos", json={"document_id": str(doc.id), "focus": "Annual raises",
+                                         "focus_prompt": "My own angle"}, headers=headers)
+    assert r.status_code == 422 and "not both" in r.text and not creates(b2v)
+
+
 def test_chat_with_a_focus_keeps_the_chat_context_first(client, b2v, owner, house, db_session):
     from app.routers.videos import CHAT_CONTEXT
     headers, ws = owner
@@ -931,6 +1151,59 @@ def test_saved_voices_never_touch_blog2video_saved_list(client, b2v, owner, db_s
     assert not [p for p in b2v.paths() if "/voices/saved" in p]
 
 
+def notestack_voice(db, ws, voice_id="nv_narrator", name="Narrator") -> None:
+    """A voice the workspace designed on the Voice page (same ElevenLabs account as blog2video)."""
+    db.add(VoiceProfile(workspace_id=ws.id, host_voices={"custom": [{"voice_id": voice_id, "name": name}]}))
+    db.commit()
+
+
+def test_my_voices_are_capped_at_five(client, b2v, owner, db_session):
+    headers, ws = owner
+    client.get("/api/video-voices", headers=headers)  # the starter voice
+    for i in range(4):
+        db_session.add(UserSavedVoice(workspace_id=ws.id, voice_id=f"v{i}", name=f"V{i}"))
+    db_session.commit()
+    r = client.post("/api/video-voices/saved", json={"voice_id": BELLA}, headers=headers)
+    assert r.status_code == 409 and "5 voices" in r.json()["detail"]
+    assert client.get("/api/video-voices", headers=headers).json()["max_saved"] == 5
+
+
+def test_notestack_voices_can_be_saved_and_used_in_a_video(client, b2v, owner, other, db_session):
+    headers, ws = owner
+    notestack_voice(db_session, ws)
+    got = client.get("/api/video-voices", headers=headers).json()
+    assert got["notestack"] == [{"voice_id": "nv_narrator", "name": "Narrator", "kind": "designed", "saved": False}]
+    r = client.post("/api/video-voices/saved", json={"voice_id": "nv_narrator"}, headers=headers)
+    assert r.status_code == 201 and r.json()["source"] == "notestack" and r.json()["premium"]
+    saved = client.get("/api/video-voices", headers=headers).json()["saved"]
+    assert [v["source"] for v in saved if v["voice_id"] == "nv_narrator"] == ["notestack"]
+    make_video(client, headers, custom_voice_id="nv_narrator")
+    assert creates(b2v)[-1]["json"]["custom_voice_id"] == "nv_narrator"
+    # Another workspace cannot use it.
+    r = client.post("/api/videos", json={"url": "https://a.test/x", "custom_voice_id": "nv_narrator"},
+                    headers=other[0])
+    assert r.status_code == 404
+
+
+def test_notestack_voices_need_premium_in_videos(client, b2v, owner, db_session, free_plan):
+    headers, ws = owner
+    notestack_voice(db_session, ws)
+    assert client.post("/api/video-voices/saved", json={"voice_id": "nv_narrator"},
+                       headers=headers).status_code == 402
+
+
+def test_revoking_the_clone_drops_it_from_video_voices(client, b2v, owner, db_session, monkeypatch):
+    headers, ws = owner
+    monkeypatch.setattr(settings, "elevenlabs_api_key", "")  # no call out to delete the voice
+    user_id = db_session.scalar(select(User.id))
+    db_session.add(VoiceConsent(workspace_id=ws.id, user_id=user_id, sample_key="ws/x/sample.mp3",
+                                consent_text="ok", elevenlabs_voice_id="nv_clone"))
+    db_session.commit()
+    assert client.post("/api/video-voices/saved", json={"voice_id": "nv_clone"}, headers=headers).status_code == 201
+    client.delete("/api/voice/consent", headers=headers)
+    assert "nv_clone" not in [v["voice_id"] for v in client.get("/api/video-voices", headers=headers).json()["saved"]]
+
+
 def test_design_keep_and_delete_a_custom_voice(client, b2v, owner, other, db_session):
     headers, ws = owner
     previews = client.post("/api/video-voices/design/prompt", json={"prompt": "A calm, warm narrator voice please"},

frontend/src/App.tsx

@@ -1,4 +1,4 @@
-import { Route, Routes } from "react-router-dom";
+import { Navigate, Route, Routes } from "react-router-dom";
 import AppShell from "./components/AppShell";
 import { PublicFooter, PublicNav } from "./components/PublicChrome";
 import PricingTiers from "./components/PricingTiers";
@@ -20,7 +20,6 @@ import Sources from "./pages/Sources";
 import Studio from "./pages/Studio";
 import VideoCreate from "./pages/VideoCreate";
 import VideoEditor from "./pages/VideoEditor";
-import VideoVoices from "./pages/VideoVoices";
 import Videos from "./pages/Videos";
 import TopicMap from "./pages/TopicMap";
 import { ToolPage, ToolsHub } from "./pages/Tools";
@@ -61,7 +60,7 @@ export default function App() {
         <Route path="notebooks/:id" element={<NotebookView />} />
         <Route path="videos" element={<Videos />} />
         <Route path="videos/new" element={<VideoCreate />} />
-        <Route path="videos/voices" element={<VideoVoices />} />
+        <Route path="videos/voices" element={<Navigate to="/app/voice?step=hosts#video-voices" replace />} />
         <Route path="videos/:id" element={<VideoEditor />} />
         <Route path="sources" element={<Sources />} />
         <Route path="map" element={<TopicMap />} />

frontend/src/api/types.ts

@@ -436,6 +436,8 @@ export type VideoSavedVoice = {
   accent: string | null;
   premium: boolean;
   is_custom: boolean;
+  /** notestack: made or added on the Voice page (played through the Voice page's preview, not a link). */
+  source?: "notestack" | "blog2video";
 };
 
 export type VideoLibraryVoice = {
@@ -459,7 +461,17 @@ export type VideoCustomVoice = {
   saved: boolean;
 };
 
-export type VideoVoicesResponse = { saved: VideoSavedVoice[]; library: VideoLibraryVoice[]; custom: VideoCustomVoice[] };
+/** A voice the workspace made or added on the Voice page (its clone, a designed voice, a library voice). */
+export type VideoNotestackVoice = { voice_id: string; name: string; kind: "clone" | "designed" | "library"; saved: boolean };
+
+export type VideoVoicesResponse = {
+  saved: VideoSavedVoice[];
+  library: VideoLibraryVoice[];
+  custom: VideoCustomVoice[];
+  notestack: VideoNotestackVoice[];
+  /** How many voices "My voices" can hold. */
+  max_saved: number;
+};
 
 export type VideoDesignedVoice = {
   generated_voice_id: string;
@@ -507,6 +519,8 @@ export type VideoCreateBody = VideoOptions & {
   focus?: string;
   /** The picked topic's description, sent so blog2video knows what to cover. */
   focus_detail?: string;
+  /** Or the user's own focus topic, followed as far as the posts cover it (never with `focus`). */
+  focus_prompt?: string;
   document_id?: string;
   /** A notebook's ticked posts, combined into one video. */
   document_ids?: string[];

frontend/src/components/video/SourcePicker.tsx

@@ -1,17 +1,16 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { Link } from "react-router-dom";
-import type { Doc, NotebookSummary, WorkspaceChat } from "../../api/types";
+import type { Doc, NotebookSummary } from "../../api/types";
 import { DocPicker } from "../DocPicker";
 import { Dropdown } from "../Dropdown";
-import { formatDate, Loading } from "../ui";
-import { freshlySeeded, loadChats, loadDocs, loadNotebooks, sourceCache } from "./sourceCache";
+import { Loading } from "../ui";
+import { freshlySeeded, loadDocs, loadNotebooks, sourceCache } from "./sourceCache";
 
-/** What a video is made from: a notebook's ticked posts (combined into one video), one post, or ticked notebook chats
- * (combined too; the ticks are held next to the source, like a notebook's posts). */
-export type VideoSource = { kind: "notebook"; id: string } | { kind: "post"; id: string } | { kind: "chats" };
+/** What a video is made from: a notebook's (or the whole archive's) ticked posts, combined into one video, or one
+ * post. */
+export type VideoSource = { kind: "notebook"; id: string } | { kind: "post"; id: string };
 
 const ONE_POST = "__post";
-const CHATS = "__chats";
 /** Most posts one video can combine. */
 export const MAX_VIDEO_POSTS = 5;
 
@@ -21,18 +20,13 @@ export function SourcePicker({
   onSource,
   postIds,
   onPostIds,
-  chatIds,
-  onChatIds,
 }: {
   source: VideoSource | null;
   onSource: (s: VideoSource | null) => void;
   postIds: string[];
   onPostIds: (ids: string[]) => void;
-  chatIds: string[];
-  onChatIds: (ids: string[]) => void;
 }) {
   const [notebooks, setNotebooks] = useState<NotebookSummary[] | null>(sourceCache.notebooks);
-  const [chats, setChats] = useState<WorkspaceChat[] | null>(sourceCache.chats);
   const [docs, setDocs] = useState<Doc[] | null>(null);
   const ticks = useRef(postIds);
   ticks.current = postIds;
@@ -42,12 +36,10 @@ export function SourcePicker({
 
   useEffect(() => {
     loadNotebooks().then(setNotebooks).catch(() => setNotebooks((n) => n ?? []));
-    loadChats().then(setChats).catch(() => setChats((c) => c ?? []));
   }, []);
 
   const notebookId = source?.kind === "notebook" ? source.id : null;
   const postId = source?.kind === "post" ? source.id : null;
-  const onChats = source?.kind === "chats";
 
   useEffect(() => {
     if (!notebookId) return;
@@ -84,15 +76,11 @@ export function SourcePicker({
         <span className="vw-label">Made from</span>
         <Dropdown
           label="Made from"
-          value={choosing || postId ? ONE_POST : onChats ? CHATS : notebookId ?? ONE_POST}
+          value={choosing || postId ? ONE_POST : notebookId ?? ONE_POST}
           onChange={(v) => {
             if (v === ONE_POST) {
               setChoosing(true);
               onSource(null);
-            } else if (v === CHATS) {
-              setChoosing(false);
-              onChatIds([]); // none ticked to start with
-              onSource({ kind: "chats" });
             } else {
               setChoosing(false);
               onSource({ kind: "notebook", id: v });
@@ -102,32 +90,12 @@ export function SourcePicker({
             // The API lists the "All posts" notebook first, so the sections come out in order.
             ...(notebooks ?? []).map((n) => ({ value: n.id, label: n.is_archive ? "My whole archive" : n.title,
                                                hint: `${n.document_count} posts`, group: n.is_archive ? "Archive" : "Notebooks" })),
-            ...(chats?.length ? [{ value: CHATS, label: "Chats", hint: `${chats.length} chat${chats.length === 1 ? "" : "s"}`,
-                                   group: "Chats" }] : []),
             { value: ONE_POST, label: "Create a video on a single post", group: "Single post" },
           ]}
         />
-        <small className="muted vw-hint">
-          {onChats
-            ? "The video explains what the ticked chats are about."
-            : "Choose a notebook, individual posts, a chat or your whole archive."}
-        </small>
+        <small className="muted vw-hint">Choose a notebook, your whole archive or a single post.</small>
       </div>
 
-      {onChats && (
-        <div className="field">
-          <span className="vw-label">Chats</span>
-          <ChatPicker chats={chats} selected={chatIds} onChange={onChatIds} />
-          {chats && chats.length > 0 && (
-            <small className="muted vw-hint">
-              {chatIds.length === 0
-                ? "Tick at least one chat."
-                : `You can select up to ${Math.min(MAX_VIDEO_POSTS, chats.length)} (${chatIds.length} selected). They are combined into one video.`}
-            </small>
-          )}
-        </div>
-      )}
-
       {(choosing || postId) && (
         <DocPicker selected={postId ? [postId] : []} onChange={(ids) => onSource({ kind: "post", id: ids[0] })} single />
       )}
@@ -165,62 +133,3 @@ export function SourcePicker({
     </>
   );
 }
-
-/** Searchable checklist of the workspace's chats (title, notebook, date), up to MAX_VIDEO_POSTS ticked. The posts
- * list's look (DocPicker), so both sources read the same. */
-function ChatPicker({ chats, selected, onChange }: {
-  chats: WorkspaceChat[] | null;
-  selected: string[];
-  onChange: (ids: string[]) => void;
-}) {
-  const [q, setQ] = useState("");
-  const visible = useMemo(() => {
-    const needle = q.trim().toLowerCase();
-    return (chats ?? []).filter((c) => !needle || (c.title ?? "").toLowerCase().includes(needle)
-      || c.notebook_title.toLowerCase().includes(needle));
-  }, [chats, q]);
-
-  if (!chats) {
-    return (
-      <div className="picker">
-        <div className="picker-bar">
-          <input className="input input-sm" placeholder="Search chats" disabled aria-label="Search chats" />
-        </div>
-        <div className="picker-list vw-posts-wait"><Loading label="Loading chats" /></div>
-      </div>
-    );
-  }
-  if (chats.length === 0) return <p className="muted">No chats yet. Ask something in a notebook first.</p>;
-
-  const full = selected.length >= MAX_VIDEO_POSTS;
-  const toggle = (id: string) => {
-    if (selected.includes(id)) return onChange(selected.filter((x) => x !== id));
-    if (!full) onChange([...selected, id]);
-  };
-
-  return (
-    <div className="picker">
-      <div className="picker-bar">
-        <input className="input input-sm" placeholder="Search chats" value={q} onChange={(e) => setQ(e.target.value)}
-               aria-label="Search chats" />
-      </div>
-      <ul className="picker-list">
-        {visible.map((c) => {
-          const on = selected.includes(c.id);
-          return (
-            <li key={c.id}>
-              <label className={`picker-row${on ? " on" : ""}`}>
-                <input type="checkbox" checked={on} disabled={!on && full} onChange={() => toggle(c.id)} />
-                <span className="picker-title">{c.title || "Untitled chat"}</span>
-                <span className="mono muted picker-meta">
-                  {c.notebook_title}{c.updated_at ? ` · ${formatDate(c.updated_at)}` : ""}
-                </span>
-              </label>
-            </li>
-          );
-        })}
-        {visible.length === 0 && <li className="muted">No chats match.</li>}
-      </ul>
-    </div>
-  );
-}

frontend/src/components/video/VideoVoicesSection.tsx

@@ -0,0 +1,208 @@
+import { type ReactNode, useCallback, useEffect, useState } from "react";
+import { videosApi, videoVoicesApi, voiceApi } from "../../api/endpoints";
+import type { VideoSavedVoice, VideoVoicesResponse } from "../../api/types";
+import { errorMessage, Loading, Modal, Tabs } from "../ui";
+import { useUpgrade } from "../../hooks/useUpgrade";
+import { VoiceLibrary } from "./VoiceLibrary";
+import { Premium, PlayButton, useAudio } from "./parts";
+
+const KIND = { clone: "Your cloned voice", designed: "Generated", library: "From the voice library" } as const;
+
+/** Play a voice: blog2video voices have a sample link; Notestack voices have none, so the Voice page speaks a line. */
+function useVoicePlayer(onError: (msg: string) => void) {
+  const { playing, play, stop } = useAudio();
+  const playNotestack = async (voiceId: string) => {
+    if (playing === voiceId) return stop();
+    const res = await voiceApi.preview(voiceId).catch((e) => {
+      onError(errorMessage(e));
+      return null;
+    });
+    if (res?.url) play(voiceId, res.url);
+  };
+  const playSaved = (v: VideoSavedVoice) =>
+    v.source === "notestack" ? playNotestack(v.voice_id) : play(v.voice_id, v.preview_url);
+  return { playing, playNotestack, playSaved };
+}
+
+/** The Voice page's "Video voiceovers" tab: My video voices (what step 3 of a new video offers, up to max_saved) and
+ * "Manage your voiceovers", which adds from the video voice library or the workspace's own Notestack voices. Notestack
+ * voices work in videos because blog2video speaks with the same ElevenLabs account. */
+export function VideoVoicesSection({ renderAddVoice, reloadKey = 0 }: {
+  /** The modal's Add your voice tab: the Voice page's generator. onDone = saved (back to the library); close = close the
+   * modal (cloning opens its own). The new voice is added to the video voices by the Voice page. */
+  renderAddVoice: (onDone: () => void, close: () => void) => ReactNode;
+  /** Bumped by the Voice page after it made a voice, so the list here reloads. */
+  reloadKey?: number;
+}) {
+  const [voices, setVoices] = useState<VideoVoicesResponse | null>(null);
+  const [premium, setPremium] = useState(false);
+  const [managing, setManaging] = useState(false);
+  const [busy, setBusy] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const { playing, playSaved } = useVoicePlayer(setError);
+
+  const load = useCallback(() => videoVoicesApi.list().then(setVoices).catch((e) => setError(errorMessage(e))), []);
+  useEffect(() => {
+    load();
+    videosApi.config().then((c) => setPremium(!!c.premium)).catch(() => undefined);
+  }, [load, reloadKey]);
+
+  const remove = async (voiceId: string) => {
+    setBusy(voiceId);
+    setError(null);
+    try {
+      await videoVoicesApi.unsave(voiceId);
+      await load();
+    } catch (e) {
+      setError(errorMessage(e));
+    } finally {
+      setBusy(null);
+    }
+  };
+
+  return (
+    <div id="video-voices" className="stack">
+      <div className="row between wrap manage-top">
+        <p className="muted">
+          Up to {voices?.max_saved ?? 5} voices, offered in step 3 of a new video. Mix your own voices with the video
+          voice library.
+        </p>
+        <button className="btn btn-primary" disabled={!voices} onClick={() => setManaging(true)}>
+          Manage your voiceovers
+        </button>
+      </div>
+      {error && <p className="error-text">{error}</p>}
+      {!voices && !error && <div className="loading-center inline"><Loading label="Loading voices" /></div>}
+
+      {voices && (
+        <div className="stack">
+          <h3>My video voices <span className="mono muted small">{voices.saved.length} of {voices.max_saved}</span></h3>
+          <div className="vw-voice-list">
+            {voices.saved.map((v) => (
+              <div key={v.voice_id} className="vw-vrow">
+                <PlayButton on={playing === v.voice_id} disabled={v.source !== "notestack" && !v.preview_url}
+                            label={v.name} onClick={() => playSaved(v)} />
+                <div className="vw-vpick static">
+                  <strong>{v.name}</strong>
+                  <span className="muted">
+                    {v.source === "notestack" || v.is_custom ? "Your voice" : [v.gender, v.accent].filter(Boolean).join(" • ")}
+                  </span>
+                </div>
+                {v.premium && <Premium small />}
+                <button className="btn btn-small" disabled={busy === v.voice_id} onClick={() => remove(v.voice_id)}>
+                  Remove
+                </button>
+              </div>
+            ))}
+            {voices.saved.length === 0 && <p className="muted">No voices yet. Add some with Manage your voiceovers.</p>}
+          </div>
+        </div>
+      )}
+
+      {managing && voices && (
+        <ManageVideoVoicesModal voices={voices} premium={premium} onChange={load} onClose={() => setManaging(false)}
+                                renderAddVoice={renderAddVoice} />
+      )}
+    </div>
+  );
+}
+
+/** Add or remove video voices: blog2video's library (and custom voices) plus the workspace's own Notestack voices, or
+ * make a new voice (Add your voice). */
+function ManageVideoVoicesModal({ voices, premium, onChange, onClose, renderAddVoice }: {
+  voices: VideoVoicesResponse;
+  premium: boolean;
+  onChange: () => Promise<unknown>;
+  onClose: () => void;
+  renderAddVoice: (onDone: () => void, close: () => void) => ReactNode;
+}) {
+  const { openUpgrade } = useUpgrade();
+  const [tab, setTab] = useState<"library" | "add">("library");
+  const [busy, setBusy] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const { playing, playNotestack } = useVoicePlayer(setError);
+  const full = voices.saved.length >= voices.max_saved;
+  // Sections: saved (from a voice library) and cloned voices, voices created (designed), and the built-in library.
+  const ownSaved = voices.notestack.filter((v) => v.kind !== "designed");
+  const ownCreated = voices.notestack.filter((v) => v.kind === "designed");
+  const clonedCustom = voices.custom.some((c) => c.source === "clone");
+  const createdCustom = voices.custom.some((c) => c.source !== "clone");
+  const libProps = { voices, premium, full, onChange, onLocked: () => openUpgrade() };
+
+  const ownRow = (v: VideoVoicesResponse["notestack"][number]) => (
+    <div key={v.voice_id} className="vw-vrow">
+      <PlayButton on={playing === v.voice_id} label={v.name} onClick={() => playNotestack(v.voice_id)} />
+      <div className="vw-vpick static">
+        <strong>{v.name}</strong>
+        <span className="muted">{KIND[v.kind]}</span>
+      </div>
+      <Premium small />
+      {v.saved ? (
+        <button className="btn btn-small" disabled={busy === v.voice_id}
+                onClick={() => act(v.voice_id, () => videoVoicesApi.unsave(v.voice_id))}>Remove</button>
+      ) : (
+        <button className="btn btn-small btn-primary" disabled={busy === v.voice_id || full}
+                onClick={() => (premium ? act(v.voice_id, () => videoVoicesApi.save(v.voice_id)) : openUpgrade())}>
+          Add
+        </button>
+      )}
+    </div>
+  );
+
+  async function act(key: string, fn: () => Promise<unknown>) {
+    setBusy(key);
+    setError(null);
+    try {
+      await fn();
+      await onChange();
+    } catch (e) {
+      setError(errorMessage(e));
+    } finally {
+      setBusy(null);
+    }
+  }
+
+  return (
+    <Modal title="Manage your voiceovers" onClose={onClose} wide>
+      <div className="stack">
+        <p className="mono muted small">
+          {voices.saved.length} of {voices.max_saved} added
+          {full ? ". Remove one to add another." : ""}
+        </p>
+        <Tabs
+          tabs={[
+            { id: "library", label: "Voice library" },
+            { id: "add", label: "Add your voice" },
+          ]}
+          value={tab}
+          onChange={setTab}
+        />
+        {error && <p className="error-text">{error}</p>}
+        {tab === "add" ? (
+          renderAddVoice(() => setTab("library"), onClose)
+        ) : (
+          <div className="stack">
+            {(ownSaved.length > 0 || clonedCustom) && (
+              <section className="stack">
+                <h3>Saved and cloned</h3>
+                {ownSaved.length > 0 && <div className="vw-voice-list">{ownSaved.map(ownRow)}</div>}
+                <VoiceLibrary {...libProps} part="custom" customKind="clone" />
+              </section>
+            )}
+            {(ownCreated.length > 0 || createdCustom) && (
+              <section className="stack">
+                <h3>Created by you</h3>
+                {ownCreated.length > 0 && <div className="vw-voice-list">{ownCreated.map(ownRow)}</div>}
+                <VoiceLibrary {...libProps} part="custom" customKind="designed" />
+              </section>
+            )}
+            <section className="stack">
+              <h3>Built-in voices</h3>
+              <VoiceLibrary {...libProps} part="library" />
+            </section>
+          </div>
+        )}
+      </div>
+    </Modal>
+  );
+}

frontend/src/components/video/VoiceLibrary.tsx

@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useState } from "react";
 import { videoVoicesApi } from "../../api/endpoints";
 import type { VideoVoicesResponse } from "../../api/types";
 import { ConfirmButton, errorMessage } from "../ui";
@@ -7,17 +7,21 @@ import { Premium, PlayButton, useAudio } from "./parts";
 const cap = (s?: string | null) => (s ? s[0].toUpperCase() + s.slice(1) : "");
 
 /** The built-in voices to add to "My voices", and this workspace's custom voices. */
-export function VoiceLibrary({ voices, premium, onChange, onLocked }: {
+export function VoiceLibrary({ voices, premium, onChange, onLocked, full = false, part, customKind }: {
   voices: VideoVoicesResponse; premium: boolean; onChange: () => void; onLocked: () => void;
+  /** My voices is at its cap: nothing more can be added until one is removed. */
+  full?: boolean;
+  /** Just one part, with no heading of its own (the caller titles it): the custom voices or the built-in library. */
+  part?: "custom" | "library";
+  /** With part "custom": only cloned or only designed custom voices. */
+  customKind?: "clone" | "designed";
 }) {
-  const [gender, setGender] = useState("");
-  const [accent, setAccent] = useState("");
   const [busy, setBusy] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
   const { playing, play } = useAudio();
 
-  const accents = useMemo(() => [...new Set(voices.library.map((v) => v.accent).filter(Boolean) as string[])].sort(), [voices]);
-  const shown = voices.library.filter((v) => (!gender || v.gender === gender) && (!accent || v.accent === accent));
+  const shown = voices.library;
+  const custom = voices.custom.filter((c) => !customKind || (customKind === "clone") === (c.source === "clone"));
 
   async function act(key: string, fn: () => Promise<unknown>) {
     setBusy(key);
@@ -41,11 +45,11 @@ export function VoiceLibrary({ voices, premium, onChange, onLocked }: {
 
   return (
     <div className="stack">
-      {voices.custom.length > 0 && (
+      {part !== "library" && custom.length > 0 && (
         <section className="stack">
-          <h3>Your custom voices</h3>
+          {!part && <h3>Your custom voices</h3>}
           <div className="vw-voice-list">
-            {voices.custom.map((c) => (
+            {custom.map((c) => (
               <div key={c.id} className="vw-vrow">
                 <PlayButton on={playing === `c${c.id}`} label={c.name} onClick={() => playCustom(c.id, c.preview_url)} />
                 <div className="vw-vpick static">
@@ -54,10 +58,10 @@ export function VoiceLibrary({ voices, premium, onChange, onLocked }: {
                 </div>
                 {c.saved ? (
                   <button className="btn btn-small" disabled={busy === c.voice_id}
-                          onClick={() => act(c.voice_id, () => videoVoicesApi.unsave(c.voice_id))}>Remove from my voices</button>
+                          onClick={() => act(c.voice_id, () => videoVoicesApi.unsave(c.voice_id))}>Remove</button>
                 ) : (
-                  <button className="btn btn-small" disabled={busy === c.voice_id}
-                          onClick={() => act(c.voice_id, () => videoVoicesApi.save(c.voice_id))}>Add to my voices</button>
+                  <button className="btn btn-small" disabled={busy === c.voice_id || full}
+                          onClick={() => act(c.voice_id, () => videoVoicesApi.save(c.voice_id))}>Add</button>
                 )}
                 <ConfirmButton onConfirm={() => act(`d${c.id}`, () => videoVoicesApi.removeCustom(c.id))}>Delete</ConfirmButton>
               </div>
@@ -66,21 +70,9 @@ export function VoiceLibrary({ voices, premium, onChange, onLocked }: {
         </section>
       )}
 
+      {part === "custom" && error && <p className="error-text">{error}</p>}
+      {part !== "custom" && (
       <section className="stack">
-        <div className="row between wrap">
-          <h3>Voice library</h3>
-          <div className="row">
-            <select className="input" value={gender} onChange={(e) => setGender(e.target.value)} aria-label="Gender">
-              <option value="">Any gender</option>
-              <option value="female">Female</option>
-              <option value="male">Male</option>
-            </select>
-            <select className="input" value={accent} onChange={(e) => setAccent(e.target.value)} aria-label="Accent">
-              <option value="">Any accent</option>
-              {accents.map((a) => <option key={a} value={a}>{cap(a)}</option>)}
-            </select>
-          </div>
-        </div>
         {error && <p className="error-text">{error}</p>}
         <div className="vw-voice-list">
           {shown.map((v) => (
@@ -97,18 +89,19 @@ export function VoiceLibrary({ voices, premium, onChange, onLocked }: {
               {v.premium && <Premium small />}
               {v.saved ? (
                 <button className="btn btn-small" disabled={busy === v.voice_id}
-                        onClick={() => act(v.voice_id, () => videoVoicesApi.unsave(v.voice_id))}>Saved ✓</button>
+                        onClick={() => act(v.voice_id, () => videoVoicesApi.unsave(v.voice_id))}>Remove</button>
               ) : (
-                <button className="btn btn-small btn-primary" disabled={busy === v.voice_id}
+                <button className="btn btn-small btn-primary" disabled={busy === v.voice_id || full}
                         onClick={() => (v.premium && !premium ? onLocked() : act(v.voice_id, () => videoVoicesApi.save(v.voice_id)))}>
-                  Save
+                  Add
                 </button>
               )}
             </div>
           ))}
-          {shown.length === 0 && <p className="muted">No voices match.</p>}
+          {shown.length === 0 && <p className="muted">No voices in the library right now.</p>}
         </div>
       </section>
+      )}
     </div>
   );
 }

frontend/src/components/video/sourceCache.ts

@@ -1,11 +1,10 @@
 import { notebooksApi } from "../../api/endpoints";
-import type { Doc, NotebookSummary, WorkspaceChat } from "../../api/types";
+import type { Doc, NotebookSummary } from "../../api/types";
 
 /** The video wizard's step 1 lists, kept for the browser session (until a full reload) so re-opening the wizard
  * shows them at once. Readers show what is cached, then refresh in the background through the loaders below. */
 export const sourceCache = {
   notebooks: null as NotebookSummary[] | null,
-  chats: null as WorkspaceChat[] | null,
   archiveId: null as string | null,
   docs: new Map<string, Doc[]>(),
 };
@@ -13,7 +12,6 @@ export const sourceCache = {
 /** Forget everything, so one account never sees another's posts (called on log in and log out). */
 export function clearSourceCache(): void {
   sourceCache.notebooks = null;
-  sourceCache.chats = null;
   sourceCache.archiveId = null;
   sourceCache.docs.clear();
   seededAt.clear();
@@ -25,12 +23,6 @@ export async function loadNotebooks(): Promise<NotebookSummary[]> {
   return n;
 }
 
-export async function loadChats(): Promise<WorkspaceChat[]> {
-  const c = await notebooksApi.allChats();
-  sourceCache.chats = c;
-  return c;
-}
-
 export async function loadArchiveId(): Promise<string> {
   const nb = await notebooksApi.archive();
   sourceCache.archiveId = nb.id;

frontend/src/pages/VideoCreate.tsx

@@ -1,9 +1,10 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { Link, useNavigate, useSearchParams } from "react-router-dom";
-import { videosApi, videoVoicesApi } from "../api/endpoints";
+import { videosApi, videoVoicesApi, voiceApi } from "../api/endpoints";
 import type {
   VideoCatalog,
   VideoConfig,
+  VideoCreateBody,
   VideoFocusSource,
   VideoFocusTopic,
   VideoOptions,
@@ -18,14 +19,9 @@ import { CheckIcon, SparkleIcon } from "../components/icons/Icons";
 import { errorMessage, Loading, PageHeader } from "../components/ui";
 import { SourcePicker, type VideoSource } from "../components/video/SourcePicker";
 import { loadArchiveId, sourceCache } from "../components/video/sourceCache";
-import { PhoneIcon, PlayButton, ScreenIcon, TemplateThumb, useAudio } from "../components/video/parts";
+import { PlayButton, TemplateThumb, useAudio } from "../components/video/parts";
 import { useUpgrade } from "../hooks/useUpgrade";
 
-const FORMATS = [
-  { id: "landscape", name: "Landscape", label: "Landscape (16:9), for YouTube", Icon: ScreenIcon },
-  { id: "portrait", name: "Portrait", label: "Portrait (9:16), for TikTok and Reels", Icon: PhoneIcon },
-] as const;
-
 const FALLBACK_COLORS = { accent_color: "#7c3aed", bg_color: "#ffffff", text_color: "#000000" };
 
 /** A template and the colours it was designed with. */
@@ -80,15 +76,23 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
       : sourceCache.archiveId ? { kind: "notebook", id: sourceCache.archiveId } : null,
   );
   const [postIds, setPostIds] = useState<string[]>([]);
-  const [chatIds, setChatIds] = useState<string[]>([]);
-  // Step 2's "focus on": the AI's three suggestions for the step 1 choice (sourceKey), and the one picked (none =
+  // Step 1's "focus on": the AI's three suggestions for the source chosen (sourceKey), and the one picked (none =
   // the whole material).
   const [topics, setTopics] = useState<VideoFocusTopic[] | null>(null);
   const topicsFor = useRef(""); // the sourceKey of the suggestions shown or on their way
   const [focus, setFocus] = useState<VideoFocusTopic | null>(null);
+  // Or the user's own topic: one or the other (or neither, for a general video).
+  const [custom, setCustom] = useState("");
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const { playing, play } = useAudio();
+  const { playing, play, stop } = useAudio();
+
+  /** Notestack voices have no stored sample: the Voice page speaks a line in them. */
+  function playVoice(v: VideoSavedVoice) {
+    if (v.source !== "notestack") return play(v.voice_id, v.preview_url);
+    if (playing === v.voice_id) return stop();
+    voiceApi.preview(v.voice_id).then((r) => play(v.voice_id, r.url)).catch((e) => setError(errorMessage(e)));
+  }
 
   const [form, setForm] = useState<VideoOptions>({
     stock_footage_enabled: true,
@@ -141,7 +145,7 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
     }).catch((e) => setLoadError(errorMessage(e)));
     loadVoices()
       .then((v) => v.saved[0] && pickVoice(v.saved[0]))
-      .catch(() => setVoices({ saved: [], library: [], custom: [] }));
+      .catch(() => setVoices({ saved: [], library: [], custom: [], notestack: [], max_saved: 5 }));
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [config?.configured]);
 
@@ -181,19 +185,16 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
     }));
   }
 
-  const sourceReady = source?.kind === "post" || (source?.kind === "chats" && chatIds.length > 0)
-    || (source?.kind === "notebook" && postIds.length > 0);
+  const sourceReady = source?.kind === "post" || (source?.kind === "notebook" && postIds.length > 0);
 
   /** Step 1's choice as API fields: the same for the focus suggestions and the create. */
   const sourceFields = (): VideoFocusSource | null => !source ? null
     : source.kind === "post" ? { document_id: source.id }
-    : source.kind === "chats" ? { chat_ids: chatIds }
     : { document_ids: postIds, notebook_id: source.id };
-  // The focus suggestions belong to one step 1 choice. They are asked for while still on step 1, as soon as the choice
-  // is complete, so they are usually there by step 2; a new source or other ticks asks again. The short wait lets a
-  // run of ticks settle into one request.
+  // The focus suggestions belong to one source choice. They are asked for as soon as the choice is complete and show
+  // below it on step 1; a new source or other ticks asks again. The short wait lets a run of ticks settle into one
+  // request.
   const sourceKey = !source ? ""
-    : source.kind === "chats" ? `chats:${[...chatIds].sort().join(",")}`
     : `${source.kind}:${source.id}:${source.kind === "notebook" ? [...postIds].sort().join(",") : ""}`;
 
   useEffect(() => {
@@ -217,6 +218,12 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
   // does Go to step 2). null = still loading; [] = none to show.
   const shownTopics = topicsFor.current === sourceKey ? topics : null;
 
+  /** The focus for the create: a suggested topic, the user's own, or none (a general video). */
+  function focusFields(): Pick<VideoCreateBody, "focus" | "focus_detail" | "focus_prompt"> {
+    if (focus) return { focus: focus.title, focus_detail: focus.description };
+    return custom.trim() ? { focus_prompt: custom.trim() } : {};
+  }
+
   function options(): VideoOptions {
     const o: VideoOptions = { ...form };
     if (o.voice_gender === "none") delete o.custom_voice_id;
@@ -229,7 +236,7 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
     try {
       const from = sourceFields();
       if (!from) return;
-      const a = await videosApi.create({ ...options(), ...from, ...(focus ? { focus: focus.title, focus_detail: focus.description } : {}) });
+      const a = await videosApi.create({ ...options(), ...from, ...focusFields() });
       navigate(`/app/videos/${a.id}`);
     } catch (e) {
       setError(errorMessage(e)); // 402 also opens the upgrade popup (api/client.ts)
@@ -281,39 +288,100 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
 
         {/* Stays mounted on steps 2 and 3, so going Back keeps the loaded posts and the ticks */}
         <div style={{ display: step === 1 ? "contents" : "none" }}>
-          <SourcePicker source={source} onSource={setSource} postIds={postIds} onPostIds={setPostIds}
-                        chatIds={chatIds} onChatIds={setChatIds} />
+          <SourcePicker source={source} onSource={setSource} postIds={postIds} onPostIds={setPostIds} />
         </div>
 
         {step === 1 && (
           <>
 
-            <div className="vw-row2">
+            {/* Landscape with stock footage, always: the form's defaults, no picker */}
+            <div className="vw-style-row">
               <div className="field">
-                <span className="vw-label">Format</span>
-                <div className="vw-formats" role="radiogroup" aria-label="Video format">
-                  {FORMATS.map(({ id, name, label, Icon }) => (
-                    <button key={id} type="button" role="radio" aria-checked={form.aspect_ratio === id} title={label}
-                            className={form.aspect_ratio === id ? "on" : ""} onClick={() => set({ aspect_ratio: id })}>
-                      <Icon />
-                      {name}
-                    </button>
-                  ))}
-                </div>
+                <span className="vw-label">Video style</span>
+                {catalog === null ? <Loading label="Loading styles" /> : (
+                  <div className="vw-chips vw-style-chips">
+                    {styles.map((s) => (
+                      <button key={s.id} type="button" className={`vw-chip${form.video_style === s.id ? " on" : ""}`}
+                              aria-pressed={form.video_style === s.id} title={s.description ?? undefined}
+                              onClick={() => set({ video_style: s.id })}>
+                        {s.name}{s.kind === "custom" ? " (yours)" : ""}
+                      </button>
+                    ))}
+                  </div>
+                )}
+                {houseStyles && picked?.description && (
+                  <small className="muted vw-style-note">{picked.description}</small>
+                )}
               </div>
-              <div className="field">
-                <span className="vw-label">Stock footage</span>
-                <label className="vw-option">
-                  <input type="checkbox" checked={form.stock_footage_enabled}
-                         onChange={(e) => set({ stock_footage_enabled: e.target.checked })} />
-                  Insert stock footage automatically
+            </div>
+
+            {/* The suggestions are asked for as soon as the source is ready (hidden if there are none); the custom
+                topic is always there */}
+            {sourceReady && (
+              <div className="field vw-focus">
+                <span className="vw-label">What should the video focus on?</span>
+                {shownTopics?.length !== 0 && (
+                  <div className="vw-focus-grid" aria-busy={shownTopics === null}>
+                    {shownTopics === null
+                      ? [0, 1, 2].map((i) => (
+                        <div key={i} className="vw-focus-card wait" aria-hidden="true">
+                          <SparkleIcon size={16} />
+                          <span className="vw-focus-text">
+                            <span className="vw-focus-bar" />
+                            <span className="vw-focus-bar short" />
+                          </span>
+                        </div>
+                      ))
+                      : shownTopics.map((t) => {
+                        const on = focus?.title === t.title;
+                        return (
+                          <button key={t.title} type="button" className={`vw-focus-card${on ? " on" : ""}`}
+                                  aria-pressed={on} onClick={() => {
+                                    setFocus(on ? null : t);
+                                    setCustom("");
+                                  }}>
+                            <SparkleIcon size={16} />
+                            <span className="vw-focus-text">
+                              <strong>{t.title}</strong>
+                              {t.description && <small className="vw-focus-desc">{t.description}</small>}
+                            </span>
+                            {on && <CheckIcon size={16} />}
+                          </button>
+                        );
+                      })}
+                  </div>
+                )}
+                <label className={`vw-focus-custom${custom.trim() ? " on" : ""}`}>
+                  <span className="vw-focus-custom-head">Custom topic</span>
+                  <textarea rows={2} maxLength={500} value={custom}
+                            placeholder="Describe your own, e.g. how rebalancing protects a long-term portfolio"
+                            onFocus={() => setFocus(null)} // choosing the custom topic unpicks a suggested one
+                            onChange={(e) => {
+                              setCustom(e.target.value);
+                              setFocus(null);
+                            }} />
+                  <span className="vw-focus-custom-foot">
+                    <small className="muted">
+                      Keep it to what the selected posts cover; anything they don't cover is left out of the video.
+                    </small>
+                    <small className="muted mono">{custom.length}/500</small>
+                  </span>
                 </label>
+                {shownTopics && (
+                  <small className="muted vw-hint">
+                    {focus ? "The video is mainly about this topic."
+                      : custom.trim() ? "The video follows your topic, as far as the posts cover it."
+                      : "None picked: the video covers the material as a whole."}
+                  </small>
+                )}
               </div>
-            </div>
+            )}
 
             {error && <p className="error-text">{error}</p>}
             <div className="vw-nav">
-              <button className="btn btn-primary vw-next" disabled={!sourceReady} onClick={() => setStep(2)}>
+              {/* Waits for the focus suggestions (shown, or none to show), so they are never skipped past */}
+              <button className="btn btn-primary vw-next" disabled={!sourceReady || shownTopics === null}
+                      onClick={() => setStep(2)}>
                 Go to step 2
               </button>
             </div>
@@ -347,24 +415,6 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
             </div>
 
             <div className="vw-style-row">
-              <div className="field">
-                <span className="vw-label">Video style</span>
-                {catalog === null ? <Loading label="Loading styles" /> : (
-                  <div className="vw-chips vw-style-chips">
-                    {styles.map((s) => (
-                      <button key={s.id} type="button" className={`vw-chip${form.video_style === s.id ? " on" : ""}`}
-                              aria-pressed={form.video_style === s.id} title={s.description ?? undefined}
-                              onClick={() => set({ video_style: s.id })}>
-                        {s.name}{s.kind === "custom" ? " (yours)" : ""}
-                      </button>
-                    ))}
-                  </div>
-                )}
-                {houseStyles && picked?.description && (
-                  <small className="muted vw-style-note">{picked.description}</small>
-                )}
-              </div>
-
               <div className="field">
                 <span className="vw-label">Video colors</span>
                 <div className="vw-colors">
@@ -378,48 +428,9 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
               </div>
             </div>
 
-            {/* Asked for on step 1, so usually here already. Hidden only when the request failed */}
-            {sourceReady && shownTopics?.length !== 0 && (
-              <div className="field vw-focus">
-                <span className="vw-label">What should the video focus on?</span>
-                <div className="vw-focus-grid" aria-busy={shownTopics === null}>
-                  {shownTopics === null
-                    ? [0, 1, 2].map((i) => (
-                      <div key={i} className="vw-focus-card wait" aria-hidden="true">
-                        <SparkleIcon size={18} />
-                        <span className="vw-focus-text">
-                          <span className="vw-focus-bar" />
-                          <span className="vw-focus-bar short" />
-                        </span>
-                      </div>
-                    ))
-                    : shownTopics.map((t) => {
-                      const on = focus?.title === t.title;
-                      return (
-                        <button key={t.title} type="button" className={`vw-focus-card${on ? " on" : ""}`}
-                                aria-pressed={on} onClick={() => setFocus(on ? null : t)}>
-                          <SparkleIcon size={18} />
-                          <span className="vw-focus-text">
-                            <strong>{t.title}</strong>
-                            {t.description && <small className="vw-focus-desc">{t.description}</small>}
-                          </span>
-                          {on && <CheckIcon size={18} />}
-                        </button>
-                      );
-                    })}
-                </div>
-                {shownTopics && (
-                  <small className="muted vw-hint">
-                    {focus ? "The video is mainly about this topic." : "None picked: the video covers the material as a whole."}
-                  </small>
-                )}
-              </div>
-            )}
-
             <div className="vw-nav">
               <button className="btn" onClick={() => setStep(1)}>Back</button>
-              {/* Waits for the focus suggestions (shown, or none to show), so they are never skipped past */}
-              <button className="btn btn-primary vw-next" disabled={shownTopics === null} onClick={() => setStep(3)}>
+              <button className="btn btn-primary vw-next" onClick={() => setStep(3)}>
                 Go to step 3
               </button>
             </div>
@@ -460,19 +471,19 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
               {voices === null ? (
                 <Loading label="Loading voices" />
               ) : saved.length === 0 ? (
-                <p className="muted">No voices saved yet. Add some on the <Link to="/app/videos/voices">Voices</Link> page.</p>
+                <p className="muted">No voices saved yet. Add some on the <Link to="/app/voice?step=hosts#video-voices">Voice</Link> page.</p>
               ) : (
                 <div className="vw-voice-list vw-voice-list-compact" role="radiogroup" aria-label="Narration voice">
                   {saved.map((v) => {
                     const on = form.custom_voice_id === v.voice_id && form.voice_gender !== "none";
                     return (
                       <div key={v.voice_id} className={`vw-vrow${on ? " on" : ""}`}>
-                        <PlayButton on={playing === v.voice_id} disabled={!v.preview_url} label={v.name}
-                                    onClick={() => play(v.voice_id, v.preview_url)} />
+                        <PlayButton on={playing === v.voice_id} disabled={v.source !== "notestack" && !v.preview_url}
+                                    label={v.name} onClick={() => playVoice(v)} />
                         <button type="button" role="radio" aria-checked={on} className="vw-vpick"
                                 disabled={form.voice_gender === "none"} onClick={() => pickVoice(v)}>
                           <strong>{v.name}</strong>
-                          <span className="muted">{v.is_custom ? "Your voice" : [cap(v.gender), cap(v.accent)].filter(Boolean).join(" • ")}</span>
+                          <span className="muted">{v.source === "notestack" ? "Notestack voice" : v.is_custom ? "Your voice" : [cap(v.gender), cap(v.accent)].filter(Boolean).join(" • ")}</span>
                         </button>
                         {on && <span className="vw-hero-check"><CheckIcon size={14} /></span>}
                       </div>

frontend/src/pages/VideoVoices.tsx

@@ -1,76 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { Link } from "react-router-dom";
-import { videosApi, videoVoicesApi } from "../api/endpoints";
-import type { VideoConfig, VideoVoicesResponse } from "../api/types";
-import { errorMessage, Loading, PageHeader } from "../components/ui";
-import { VoiceCreator } from "../components/video/VoiceCreator";
-import { VoiceLibrary } from "../components/video/VoiceLibrary";
-import { Premium, PlayButton, useAudio } from "../components/video/parts";
-import { useUpgrade } from "../hooks/useUpgrade";
-
-/** The workspace's video voices: My voices (what the wizard offers), the library, and custom voices. */
-export default function VideoVoices() {
-  const { openUpgrade } = useUpgrade();
-  const [voices, setVoices] = useState<VideoVoicesResponse | null>(null);
-  const [config, setConfig] = useState<VideoConfig | null>(null);
-  const [creating, setCreating] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const { playing, play } = useAudio();
-
-  const load = useCallback(() => videoVoicesApi.list().then(setVoices).catch((e) => setError(errorMessage(e))), []);
-  useEffect(() => {
-    load();
-    videosApi.config().then(setConfig).catch(() => undefined);
-  }, [load]);
-
-  const premium = !!config?.premium;
-  const custom = config?.limits.custom_voices;
-  const designs = config?.limits.voice_designs_daily;
-
-  return (
-    <div className="page-wrap">
-      <PageHeader eyebrow="Videos" title="Voices">
-        <Link to="/app/videos" className="btn">Back to videos</Link>
-        <button className="btn btn-primary" onClick={() => (premium ? setCreating(true) : openUpgrade())}>
-          Create a voice {!premium && <Premium small />}
-        </button>
-      </PageHeader>
-      {custom && designs && premium && (
-        <p className="mono muted">
-          {custom.used} of {custom.limit} custom voices · {designs.used} of {designs.limit} voice designs today
-        </p>
-      )}
-      {error && <p className="error-text">{error}</p>}
-      {!voices && !error && <Loading label="Loading voices" />}
-      {voices && (
-        <div className="stack">
-          <section className="card stack">
-            <h3>My voices</h3>
-            <p className="muted small">These are the voices offered in step 3 of a new video.</p>
-            <div className="vw-voice-list">
-              {voices.saved.map((v) => (
-                <div key={v.voice_id} className="vw-vrow">
-                  <PlayButton on={playing === v.voice_id} disabled={!v.preview_url} label={v.name}
-                              onClick={() => play(v.voice_id, v.preview_url)} />
-                  <div className="vw-vpick static">
-                    <strong>{v.name}</strong>
-                    <span className="muted">{v.is_custom ? "Your voice" : [v.gender, v.accent].filter(Boolean).join(" • ")}</span>
-                  </div>
-                  {v.premium && <Premium small />}
-                  <button className="btn btn-small" onClick={() => videoVoicesApi.unsave(v.voice_id).then(load).catch((e) => setError(errorMessage(e)))}>
-                    Remove
-                  </button>
-                </div>
-              ))}
-              {voices.saved.length === 0 && <p className="muted">No voices saved. Save some from the library below.</p>}
-            </div>
-          </section>
-          <section className="card">
-            <VoiceLibrary voices={voices} premium={premium} onChange={load} onLocked={() => openUpgrade()} />
-          </section>
-        </div>
-      )}
-      {creating && <VoiceCreator onClose={() => setCreating(false)} onCreated={() => { setCreating(false); load(); videosApi.config().then(setConfig); }} />}
-    </div>
-  );
-}

frontend/src/pages/Videos.tsx

@@ -78,7 +78,7 @@ export default function Videos() {
   return (
     <div className="page-wrap">
       <PageHeader eyebrow="Videos" title="Your videos">
-        <Link to="/app/videos/voices" className="btn">Voices</Link>
+        <Link to="/app/voice?step=hosts#video-voices" className="btn">Voices</Link>
         {out && status?.can_upgrade ? (
           <button className="btn btn-primary" onClick={() => openUpgrade()}>Get more videos</button>
         ) : (

frontend/src/pages/VoiceProfile.tsx

@@ -1,7 +1,10 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { voiceApi } from "../api/endpoints";
+import { type CSSProperties, useCallback, useEffect, useRef, useState } from "react";
+import { useSearchParams } from "react-router-dom";
+import { videoVoicesApi, voiceApi } from "../api/endpoints";
 import type { Delivery, Job, LibraryVoice, Voice, VoiceDesignInput, VoiceDesignPreview, VoiceProfileData, VoiceState } from "../api/types";
 import { DocPicker } from "../components/DocPicker";
+import { PlayButton } from "../components/video/parts";
+import { VideoVoicesSection } from "../components/video/VideoVoicesSection";
 import { ConfirmButton, errorMessage, formatDate, JobProgress, Loading, Modal, PageHeader, Tabs } from "../components/ui";
 import { useJob } from "../hooks/useJob";
 import { useUpgrade } from "../hooks/useUpgrade";
@@ -59,56 +62,12 @@ const PREBUILT: { voice_id: string; name: string; tag: string; icon: Icon }[] =
   { voice_id: "cgSgspJ2msm6clMCkdW9", name: "Jessica", tag: "Bright and lively", icon: "spark" },
 ];
 
-const ICON_PATHS: Record<Icon, string> = {
-  sun: "M12 4V2m0 20v-2m8-8h2M2 12h2m13.66-5.66 1.41-1.41M4.93 19.07l1.41-1.41m0-11.32L4.93 4.93m14.14 14.14-1.41-1.41M16 12a4 4 0 1 1-8 0 4 4 0 0 1 8 0Z",
-  book: "M4 5.5A2.5 2.5 0 0 1 6.5 3H20v15H6.5A2.5 2.5 0 0 0 4 20.5v-15Zm0 15A2.5 2.5 0 0 0 6.5 23H20v-5",
-  mic: "M12 2a3 3 0 0 0-3 3v6a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3Zm7 9a7 7 0 0 1-14 0m7 7v4m-4 0h8",
-  spark: "M12 3l1.9 5.1L19 10l-5.1 1.9L12 17l-1.9-5.1L5 10l5.1-1.9L12 3Zm7 11 .8 2.2L22 17l-2.2.8L19 20l-.8-2.2L16 17l2.2-.8L19 14Z",
-  wave: "M3 12h2m3-5v10m4-13v16m4-11v6m4-3h1",
-  person: "M12 12a4 4 0 1 0 0-8 4 4 0 0 0 0 8Zm-7 9a7 7 0 0 1 14 0",
-};
-
-function VoiceIcon({ icon }: { icon: Icon }) {
-  return (
-    <span className="voice-icon" aria-hidden="true">
-      <svg width="34" height="34" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.4" strokeLinecap="round" strokeLinejoin="round">
-        <path d={ICON_PATHS[icon]} />
-      </svg>
-    </span>
-  );
-}
-
 type Tile = { voice_id: string; name: string; tag: string; icon: Icon; preview_url?: string | null };
 
-function VoicePicker({
-  state,
-  voices,
-  onSaved,
-  onBrowse,
-  onGenerate,
-}: {
-  state: VoiceState;
-  voices: Voice[];
-  onSaved: (s: VoiceState) => void;
-  onBrowse: (host: Host) => void;
-  onGenerate: (host: Host) => void;
-}) {
-  const [host, setHost] = useState<Host>("host_a");
-  const [delivery, setDelivery] = useState<Delivery>(state.delivery[host]);
-  const [dirty, setDirty] = useState(false);
-  const [loading, setLoading] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const { play, playing } = usePlayer();
-  const current = state.host_voices[host];
-  const other: Host = host === "host_a" ? "host_b" : "host_a";
+/** The voices a host can use: the premade four, then the writer's own (clone, generated), then whatever else a host is
+ * set to (e.g. a library voice). Shared by the tiles and the Manage voices modal. */
+function hostTiles(state: VoiceState, voices: Voice[]): Tile[] {
   const byId = new Map(voices.map((v) => [v.voice_id, v]));
-
-  useEffect(() => {
-    setDelivery(state.delivery[host]);
-    setDirty(false);
-  }, [state.delivery, host]);
-
-  // Prebuilt first, then the writer's own voices, then whatever else a host is set to (e.g. a library voice).
   const tiles: Tile[] = PREBUILT.map((p) => ({ ...p, preview_url: byId.get(p.voice_id)?.preview_url }));
   if (state.clone.status === "ready" && state.clone.voice_id) {
     tiles.push({ voice_id: state.clone.voice_id, name: "My voice", tag: "Your clone", icon: "person", preview_url: state.clone.preview_url });
@@ -120,20 +79,54 @@ function VoicePicker({
       tiles.push({ voice_id: id, name: v?.name ?? "Current voice", tag: v?.labels?.accent ?? "Library voice", icon: "wave", preview_url: v?.preview_url });
     }
   }
+  return tiles;
+}
 
+/** Listen to a voice: its sample link when it has one, otherwise a line spoken with the host's delivery. */
+function useListen(host: Host, onError: (msg: string | null) => void) {
+  const [loading, setLoading] = useState<string | null>(null);
+  const { play, playing } = usePlayer();
   const listen = async (t: Tile) => {
     if (playing === t.voice_id || t.preview_url) return play(t.preview_url ?? "", t.voice_id);
     setLoading(t.voice_id);
-    setError(null);
+    onError(null);
     try {
       const { url } = await voiceApi.preview(t.voice_id, { host });
       play(url, t.voice_id);
     } catch (e) {
-      setError(errorMessage(e));
+      onError(errorMessage(e));
     } finally {
       setLoading(null);
     }
   };
+  return { listen, loading, playing };
+}
+
+function VoicePicker({
+  state,
+  voices,
+  onSaved,
+  onManage,
+}: {
+  state: VoiceState;
+  voices: Voice[];
+  onSaved: (s: VoiceState) => void;
+  onManage: (host: Host) => void;
+}) {
+  const [host, setHost] = useState<Host>("host_a");
+  const [delivery, setDelivery] = useState<Delivery>(state.delivery[host]);
+  const [dirty, setDirty] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const { listen, loading, playing } = useListen(host, setError);
+  const current = state.host_voices[host];
+  const other: Host = host === "host_a" ? "host_b" : "host_a";
+
+  useEffect(() => {
+    setDelivery(state.delivery[host]);
+    setDirty(false);
+  }, [state.delivery, host]);
+
+  const tiles = hostTiles(state, voices);
 
   const choose = async (voice_id: string) => {
     if (voice_id === current) return;
@@ -147,6 +140,12 @@ function VoicePicker({
 
   return (
     <div className="stack">
+      <div className="row between wrap manage-top">
+        <p className="muted">Audio overviews are a conversation between two hosts. Tap a voice to use it, or add your own.</p>
+        <button className="btn btn-primary" onClick={() => onManage(host)}>
+          Manage voices
+        </button>
+      </div>
       <Tabs<Host>
         tabs={[
           { id: "host_a", label: "Host A · leads" },
@@ -155,74 +154,63 @@ function VoicePicker({
         value={host}
         onChange={setHost}
       />
-      <ul className="voice-grid" aria-label={`Voices for ${host === "host_a" ? "Host A" : "Host B"}`}>
+      {/* One row per voice, as in Video voiceovers: tap a row to give it to this host */}
+      <div className="vw-voice-list" role="radiogroup" aria-label={`Voices for ${host === "host_a" ? "Host A" : "Host B"}`}>
         {tiles.map((t) => {
           const selected = t.voice_id === current;
           const usedByOther = t.voice_id === state.host_voices[other];
           return (
-            <li key={t.voice_id} className={`voice-tile${selected ? " on" : ""}`}>
-              <button type="button" className="voice-pick" onClick={() => choose(t.voice_id)} aria-pressed={selected}>
-                <VoiceIcon icon={t.icon} />
+            <div key={t.voice_id} className={`vw-vrow${selected ? " on" : ""}`}>
+              <PlayButton on={playing === t.voice_id} label={t.name} onClick={() => listen(t)}
+                          disabled={loading !== null || (!t.preview_url && !state.tts_configured)} />
+              <button type="button" role="radio" aria-checked={selected} className="vw-vpick" onClick={() => choose(t.voice_id)}>
                 <strong>{t.name}</strong>
-                <span className="muted small">{t.tag}</span>
+                <span className="muted">{t.tag}</span>
               </button>
-              {selected && <span className="voice-badge mono">{host === "host_a" ? "Host A" : "Host B"}</span>}
-              {!selected && usedByOther && <span className="voice-badge dim mono">{other === "host_a" ? "Host A" : "Host B"}</span>}
-              <button
-                type="button"
-                className="icon-btn voice-play"
-                onClick={() => listen(t)}
-                disabled={loading !== null || (!t.preview_url && !state.tts_configured)}
-                aria-label={playing === t.voice_id ? `Stop ${t.name}` : `Play ${t.name}`}
-                title={playing === t.voice_id ? "Stop" : "Listen"}
-              >
-                {loading === t.voice_id ? (
-                  "…"
-                ) : (
-                  <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
-                    {playing === t.voice_id ? <path d="M6 5h4v14H6zM14 5h4v14h-4z" /> : <path d="M7 4.5v15l13-7.5z" />}
-                  </svg>
-                )}
-              </button>
-            </li>
+              {selected && <span className="voice-badge-inline mono">{host === "host_a" ? "Host A" : "Host B"}</span>}
+              {!selected && usedByOther && <span className="voice-badge-inline dim mono">{other === "host_a" ? "Host A" : "Host B"}</span>}
+            </div>
           );
         })}
-        <li className="voice-tile voice-new">
-          <button type="button" className="voice-pick" onClick={() => onGenerate(host)} aria-label="Add a voice">
-            <span className="voice-icon plus" aria-hidden="true">
-              <svg width="30" height="30" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round">
-                <path d="M12 5v14M5 12h14" />
-              </svg>
-            </span>
-            <strong>Add a voice</strong>
-            <span className="muted small">Generate or clone your own</span>
-          </button>
-        </li>
-      </ul>
+      </div>
       {error && <p className="error-text">{error}</p>}
-      <details className="delivery">
-        <summary className="mono muted small">Delivery settings for {host === "host_a" ? "Host A" : "Host B"}</summary>
-        {SLIDERS.map((s) => (
-          <label key={s.key} className="slider" title={s.hint}>
-            <span className="row between">
-              <span>{s.label}</span>
-              <span className="mono muted">{Number(delivery[s.key]).toFixed(2)}</span>
-            </span>
-            <input
-              type="range"
-              min={s.min}
-              max={s.max}
-              step={s.step}
-              value={Number(delivery[s.key])}
-              onChange={(e) => {
-                setDelivery({ ...delivery, [s.key]: Number(e.target.value) });
-                setDirty(true);
-              }}
-            />
-          </label>
-        ))}
+      <details className="delivery-card">
+        <summary>
+          Delivery settings for {host === "host_a" ? "Host A" : "Host B"}
+          <svg className="delivery-chevron" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+               strokeWidth="1.8" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+            <path d="m6 9 6 6 6-6" />
+          </svg>
+        </summary>
+        <div className="delivery-grid">
+          {SLIDERS.map((s) => {
+            const value = Number(delivery[s.key]);
+            const pct = ((value - s.min) / (s.max - s.min)) * 100;
+            return (
+              <label key={s.key} className="delivery-slider">
+                <span className="row between">
+                  <span>{s.label}</span>
+                  <span className="delivery-value mono">{value.toFixed(2)}</span>
+                </span>
+                <input
+                  type="range"
+                  min={s.min}
+                  max={s.max}
+                  step={s.step}
+                  value={value}
+                  style={{ "--pct": `${pct}%` } as CSSProperties}
+                  onChange={(e) => {
+                    setDelivery({ ...delivery, [s.key]: Number(e.target.value) });
+                    setDirty(true);
+                  }}
+                />
+                <span className="muted small">{s.hint}</span>
+              </label>
+            );
+          })}
+        </div>
         {dirty && (
-          <div className="row end">
+          <div className="row end delivery-actions">
             <button className="btn btn-small" onClick={() => (setDelivery(state.delivery[host]), setDirty(false))}>
               Reset
             </button>
@@ -238,12 +226,6 @@ function VoicePicker({
           </div>
         )}
       </details>
-      <p className="muted small">
-        Want something else?{" "}
-        <button className="link-btn small" onClick={() => onBrowse(host)}>
-          Browse the full voice library
-        </button>
-      </p>
     </div>
   );
 }
@@ -266,17 +248,20 @@ const PROMPT_IDEAS = [
   "A thoughtful older narrator with a soft Irish lilt",
 ];
 
-function GenerateVoiceModal({
+/** Make a new voice: build it from options, describe it, or clone your own. Inside the Manage voices modals. */
+function GenerateVoicePanel({
   host,
   state,
-  onClose,
+  onDone,
   onSaved,
   onClone,
 }: {
-  host: Host;
+  /** The host the new voice is for; null when made for video voiceovers (no host changes). */
+  host: Host | null;
   state: VoiceState;
-  onClose: () => void;
-  onSaved: (s: VoiceState) => void;
+  /** Saved: the caller closes or switches away. */
+  onDone: () => void;
+  onSaved: (s: VoiceState, voiceId: string) => void;
   onClone: () => void;
 }) {
   const [mode, setMode] = useState<GenMode>("options");
@@ -289,7 +274,7 @@ function GenerateVoiceModal({
   const [error, setError] = useState<string | null>(null);
   const { play, playing } = usePlayer();
   const { openUpgrade } = useUpgrade();
-  const hostLabel = host === "host_a" ? "Host A" : "Host B";
+  const hostLabel = host === "host_a" ? "Host A" : host === "host_b" ? "Host B" : null;
 
   const generate = async () => {
     setBusy("generate");
@@ -312,8 +297,10 @@ function GenerateVoiceModal({
     setBusy("save");
     setError(null);
     try {
-      onSaved(await voiceApi.saveDesign({ generated_voice_id: picked, name: name.trim(), description: result.description, use_as: host }));
-      onClose();
+      const saved = await voiceApi.saveDesign({ generated_voice_id: picked, name: name.trim(), description: result.description,
+                                                ...(host ? { use_as: host } : {}) });
+      onSaved(saved, saved.voice_id);
+      onDone();
     } catch (e) {
       setError(errorMessage(e));
     } finally {
@@ -322,7 +309,7 @@ function GenerateVoiceModal({
   };
 
   return (
-    <Modal title="Generate a new voice" onClose={onClose} wide>
+    <>
       <div className="stack">
         <Tabs<GenMode>
           tabs={[
@@ -382,10 +369,7 @@ function GenerateVoiceModal({
                 <button
                   className="btn btn-primary"
                   disabled={!state.tts_configured}
-                  onClick={() => {
-                    onClose();
-                    onClone();
-                  }}
+                  onClick={onClone}
                 >
                   {state.clone.status === "ready" ? "Record my voice again" : "Start recording"}
                 </button>
@@ -430,7 +414,7 @@ function GenerateVoiceModal({
             <div className="row">
               <input className="input input-sm" placeholder="Name it, e.g. Late night narrator" maxLength={60} value={name} onChange={(e) => setName(e.target.value)} aria-label="Voice name" />
               <button className="btn btn-primary" onClick={save} disabled={busy !== null || !picked || !name.trim()}>
-                {busy === "save" ? "Saving..." : `Save and use as ${hostLabel}`}
+                {busy === "save" ? "Saving..." : hostLabel ? `Save and use as ${hostLabel}` : "Save voice"}
               </button>
             </div>
           </div>
@@ -438,13 +422,13 @@ function GenerateVoiceModal({
         {!state.tts_configured && <p className="muted small">Voice generation is unavailable right now.</p>}
         {error && <p className="error-text">{error}</p>}
       </div>
-    </Modal>
+    </>
   );
 }
 
 // Voice library (commercially licensed voices from ElevenLabs)
 
-function LibraryModal({ host, onClose, onAdded }: { host: Host; onClose: () => void; onAdded: (s: VoiceState) => void }) {
+function LibraryBrowser({ host, onAdded }: { host: Host; onAdded: (s: VoiceState) => void }) {
   const [filters, setFilters] = useState({ search: "", gender: "", age: "", accent: "", use_case: "" });
   const [voices, setVoices] = useState<LibraryVoice[] | null>(null);
   const [page, setPage] = useState(0);
@@ -485,7 +469,7 @@ function LibraryModal({ host, onClose, onAdded }: { host: Host; onClose: () => v
   );
 
   return (
-    <Modal title={`Voice library for ${host === "host_a" ? "Host A" : "Host B"}`} onClose={onClose} wide>
+    <>
       <div className="stack">
         <p className="muted small">
           Voices from the ElevenLabs Voice Library, licensed for commercial use on paid ElevenLabs plans. Adding one puts it in your ElevenLabs account.
@@ -521,7 +505,6 @@ function LibraryModal({ host, onClose, onAdded }: { host: Host; onClose: () => v
                   setError(null);
                   try {
                     onAdded(await voiceApi.addFromLibrary(v, host));
-                    onClose();
                   } catch (e) {
                     setError(errorMessage(e));
                   } finally {
@@ -541,6 +524,48 @@ function LibraryModal({ host, onClose, onAdded }: { host: Host; onClose: () => v
           </button>
         )}
       </div>
+    </>
+  );
+}
+
+// Managing a host's voices: add one from the library, or make your own
+
+type ManageTab = "library" | "add";
+
+function ManageHostVoicesModal({
+  host,
+  state,
+  onClose,
+  onSaved,
+  onClone,
+}: {
+  host: Host;
+  state: VoiceState;
+  onClose: () => void;
+  onSaved: (s: VoiceState) => void;
+  onClone: () => void;
+}) {
+  const [tab, setTab] = useState<ManageTab>("library");
+  const { openUpgrade } = useUpgrade();
+
+  return (
+    <Modal title={`Voices for ${host === "host_a" ? "Host A" : "Host B"}`} onClose={onClose} wide>
+      <div className="stack">
+        <Tabs<ManageTab>
+          tabs={[
+            { id: "library", label: "Voice library" },
+            { id: "add", label: "Add your voice" },
+          ]}
+          value={tab}
+          onChange={setTab}
+        />
+        {/* Either way the voice is set for this host and shows in the rows, so the modal closes */}
+        {tab === "library" && <LibraryBrowser host={host} onAdded={(s) => { onSaved(s); onClose(); }} />}
+        {tab === "add" && (
+          <GenerateVoicePanel host={host} state={state} onSaved={(s) => onSaved(s)} onDone={onClose}
+                              onClone={() => (state.clone.allowed ? onClone() : openUpgrade("writer"))} />
+        )}
+      </div>
     </Modal>
   );
 }
@@ -748,14 +773,21 @@ export default function VoiceProfile() {
   const [state, setState] = useState<VoiceState | null>(null);
   const [draft, setDraft] = useState<VoiceProfileData | null>(null);
   const [voices, setVoices] = useState<Voice[]>([]);
-  const [step, setStep] = useState<Step | null>(null);
+  const [params] = useSearchParams();
+  // ?step=hosts opens Speaking voices (the old Videos > Voices link lands there, on the video voices).
+  const [step, setStep] = useState<Step | null>(params.get("step") === "hosts" ? "hosts" : null);
   const [picking, setPicking] = useState(false);
   const [samples, setSamples] = useState<string[]>([]);
   const [buildJob, setBuildJob] = useState<Job | null>(null);
   const [cloneJob, setCloneJob] = useState<Job | null>(null);
   const [cloning, setCloning] = useState(false);
-  const [browsing, setBrowsing] = useState<Host | null>(null);
-  const [generating, setGenerating] = useState<Host | null>(null);
+  const [managing, setManaging] = useState<Host | null>(null);
+  // The Speaking voices card's two tabs. #video-voices (the old Videos > Voices link) opens the video one.
+  const [speakTab, setSpeakTab] = useState<"hosts" | "video">(
+    typeof window !== "undefined" && window.location.hash === "#video-voices" ? "video" : "hosts",
+  );
+  const [videoKey, setVideoKey] = useState(0);
+  const { openUpgrade } = useUpgrade();
   const [saved, setSaved] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const autoBuilt = useRef(false);
@@ -797,6 +829,7 @@ export default function VoiceProfile() {
   const clone = useJob(cloneJob, () => {
     load();
     loadVoices();
+    setVideoKey((k) => k + 1); // a new clone shows up under video voiceovers' Your voices
   });
 
   if (!state || !step) return <Loading />;
@@ -901,9 +934,41 @@ export default function VoiceProfile() {
       {step === "hosts" && (
         <section className="card stack vp-card">
           <h2>Who reads your work aloud</h2>
-          <p className="muted">Audio overviews are a conversation between two hosts. Tap a voice to use it, or add your own.</p>
+          <Tabs<"hosts" | "video">
+            tabs={[
+              { id: "hosts", label: "Hosts Audios" },
+              { id: "video", label: "Video voiceovers" },
+            ]}
+            value={speakTab}
+            onChange={setSpeakTab}
+          />
+          {speakTab === "video" && (
+            <VideoVoicesSection reloadKey={videoKey}
+                                renderAddVoice={(onDone, close) => (
+                                  <GenerateVoicePanel
+                                    host={null}
+                                    state={state}
+                                    onDone={onDone}
+                                    onSaved={(s, voiceId) => {
+                                      setState(s);
+                                      loadVoices();
+                                      // Made for video voiceovers: added there straight away (room and plan permitting).
+                                      videoVoicesApi.save(voiceId)
+                                        .catch((e) => setError(`Saved to your voices, not added to video voiceovers: ${errorMessage(e)}`))
+                                        .finally(() => setVideoKey((k) => k + 1));
+                                    }}
+                                    onClone={() => {
+                                      close(); // the recorder opens in its own modal
+                                      if (state.clone.allowed) setCloning(true);
+                                      else openUpgrade("writer");
+                                    }}
+                                  />
+                                )} />
+          )}
+          {speakTab === "hosts" && (
+          <>
           {!state.tts_configured && <p className="muted">Voice previews are unavailable right now.</p>}
-          <VoicePicker state={state} voices={voices} onSaved={setState} onBrowse={setBrowsing} onGenerate={setGenerating} />
+          <VoicePicker state={state} voices={voices} onSaved={setState} onManage={setManaging} />
 
           {showClone && (
             <div className="vp-clone">
@@ -937,8 +1002,15 @@ export default function VoiceProfile() {
             </div>
           )}
 
+          </>
+          )}
+
           <div className="row">
-            <button className="btn btn-small" onClick={() => setStep("writing")}>
+            <button className="back-link" onClick={() => setStep("writing")}>
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.8"
+                   strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+                <path d="M19 12H5m6-6-6 6 6 6" />
+              </svg>
               Back to writing voice
             </button>
           </div>
@@ -957,25 +1029,18 @@ export default function VoiceProfile() {
         </Modal>
       )}
       {cloning && <CloneModal state={state} onClose={() => setCloning(false)} onDone={setCloneJob} />}
-      {generating && (
-        <GenerateVoiceModal
-          host={generating}
+      {managing && (
+        <ManageHostVoicesModal
+          host={managing}
           state={state}
-          onClose={() => setGenerating(null)}
+          onClose={() => setManaging(null)}
           onSaved={(s) => {
             setState(s);
             loadVoices();
           }}
-          onClone={() => setCloning(true)}
-        />
-      )}
-      {browsing && (
-        <LibraryModal
-          host={browsing}
-          onClose={() => setBrowsing(null)}
-          onAdded={(s) => {
-            setState(s);
-            loadVoices();
+          onClone={() => {
+            setCloning(true);
+            setManaging(null);
           }}
         />
       )}

frontend/src/styles/pages.css

@@ -458,6 +458,11 @@ select.input option {
   min-height: 80vh;
 }
 
+/* Inside a card (a tab still loading): centred, without claiming most of the window */
+.loading-center.inline {
+  min-height: 200px;
+}
+
 /* The label sits under the spinner, both centred */
 .loading-center .loading {
   flex-direction: column;
@@ -2175,7 +2180,8 @@ select.input option {
   margin: 0;
   padding: 0;
   display: grid;
-  grid-template-columns: repeat(4, minmax(0, 1fr));
+  /* The voices and the Add a voice tile share one row, wrapping only when they no longer fit */
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
   gap: 12px;
 }
 
@@ -3601,3 +3607,154 @@ details.map-legend[open] summary {
   text-overflow: ellipsis;
   white-space: nowrap;
 }
+
+
+.voice-new .voice-pick:disabled {
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+
+/* The host a voice row belongs to (Audio hosts list) */
+.voice-badge-inline {
+  padding: 3px 10px;
+  border-radius: 999px;
+  background: var(--blue);
+  color: var(--white);
+  font-size: 0.72rem;
+  letter-spacing: 0.06em;
+}
+
+.voice-badge-inline.dim {
+  background: var(--surface-2, rgba(255, 255, 255, 0.08));
+  color: var(--text-2);
+}
+
+/* Audio hosts / Video voiceovers: the explainer takes the room, the Manage button sits at the right end */
+.manage-top > p {
+  flex: 1;
+  min-width: 240px;
+  margin: 0;
+}
+
+.manage-top > .btn {
+  flex-shrink: 0;
+  margin-left: auto;
+}
+
+/* A quiet way back: an arrow and text, no button outline */
+.back-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 0;
+  border: 0;
+  background: none;
+  color: var(--text-2);
+  font: inherit;
+  font-size: 0.9rem;
+  cursor: pointer;
+}
+
+.back-link:hover {
+  color: var(--text);
+}
+
+.back-link:hover svg {
+  transform: translateX(-2px);
+}
+
+.back-link svg {
+  transition: transform 0.15s;
+}
+
+/* Delivery settings for a host: a text link with a chevron that opens a two-column grid of sliders */
+.delivery-card summary {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  color: var(--text-2);
+  font-size: 0.9rem;
+  cursor: pointer;
+  list-style: none;
+}
+
+.delivery-card summary::-webkit-details-marker {
+  display: none;
+}
+
+.delivery-card summary:hover {
+  color: var(--text);
+}
+
+.delivery-chevron {
+  flex-shrink: 0;
+  transition: transform 0.2s;
+}
+
+.delivery-card[open] .delivery-chevron {
+  transform: rotate(180deg);
+}
+
+.delivery-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 22px 32px;
+  padding-top: 18px;
+}
+
+.delivery-slider {
+  display: grid;
+  gap: 8px;
+  font-size: 0.9rem;
+}
+
+.delivery-value {
+  padding: 2px 8px;
+  border-radius: 999px;
+  background: rgba(33, 124, 255, 0.14);
+  color: var(--blue);
+  font-size: 0.78rem;
+}
+
+/* A slim track, filled up to the thumb (--pct) */
+.delivery-slider input[type="range"] {
+  width: 100%;
+  height: 4px;
+  border-radius: 999px;
+  background: linear-gradient(to right, var(--blue) var(--pct, 50%), var(--line-strong) var(--pct, 50%));
+  appearance: none;
+  outline: none;
+  cursor: pointer;
+}
+
+.delivery-slider input[type="range"]::-webkit-slider-thumb {
+  width: 16px;
+  height: 16px;
+  border: 2px solid var(--white);
+  border-radius: 50%;
+  background: var(--blue);
+  box-shadow: 0 0 0 4px rgba(33, 124, 255, 0.2);
+  appearance: none;
+}
+
+.delivery-slider input[type="range"]::-moz-range-thumb {
+  width: 14px;
+  height: 14px;
+  border: 2px solid var(--white);
+  border-radius: 50%;
+  background: var(--blue);
+}
+
+.delivery-slider input[type="range"]:focus-visible::-webkit-slider-thumb {
+  box-shadow: 0 0 0 6px rgba(33, 124, 255, 0.35);
+}
+
+.delivery-actions {
+  padding-top: 14px;
+}
+
+@media (max-width: 640px) {
+  .delivery-grid {
+    grid-template-columns: 1fr;
+  }
+}

frontend/src/styles/videos.css

@@ -189,35 +189,6 @@
   opacity: 0.5;
 }
 
-/* Format */
-
-/* Format and stock footage side by side, bottoms aligned; stacked on phones */
-.vw-row2 {
-  display: grid;
-  grid-template-columns: 1fr 1fr;
-  gap: 16px;
-  align-items: end;
-}
-
-.vw-row2 .vw-formats {
-  display: flex;
-}
-
-.vw-row2 .vw-formats button {
-  flex: 1;
-  justify-content: center;
-}
-
-.vw-row2 .vw-option {
-  height: 48px;
-}
-
-@media (max-width: 600px) {
-  .vw-row2 {
-    grid-template-columns: 1fr;
-  }
-}
-
 .vw-hint {
   font-size: 0.78rem;
 }
@@ -227,41 +198,6 @@
   font-size: 0.75rem;
 }
 
-.vw-formats {
-  display: inline-flex;
-  gap: 4px;
-  height: 48px;
-  padding: 4px;
-  border: 1px solid var(--line-strong);
-  border-radius: 12px;
-  background: rgba(0, 0, 0, 0.6);
-}
-
-.vw-formats button {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 0 16px;
-  border: 0;
-  border-radius: 8px;
-  background: none;
-  color: var(--text-2);
-  font: 500 0.9rem var(--font-body);
-  white-space: nowrap;
-  cursor: pointer;
-  transition: background 0.15s, color 0.15s;
-}
-
-.vw-formats button:hover {
-  color: var(--text);
-}
-
-.vw-formats button.on {
-  background: var(--blue);
-  color: var(--white);
-  box-shadow: var(--glow-sm);
-}
-
 /* Templates */
 
 .vw-hero-check {
@@ -434,7 +370,7 @@
   border-radius: 50%;
 }
 
-/* Step 2: video style and colors share one row (wrapping when the chips run long), with smaller swatches */
+/* The style chips (step 1) and the colors (step 2), each in a row of their own, with smaller swatches */
 .vw-style-row {
   display: flex;
   flex-wrap: wrap;
@@ -878,17 +814,17 @@ a.mc-action {
 .vw-focus-grid {
   display: grid;
   grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 12px;
+  gap: 10px;
 }
 
 .vw-focus-card {
   display: flex;
   align-items: flex-start; /* title and description read from the top */
-  gap: 12px;
-  min-height: 72px;
-  padding: 14px 16px;
+  gap: 10px;
+  min-height: 0;
+  padding: 10px 12px;
   border: 1px solid var(--line);
-  border-radius: 16px;
+  border-radius: 12px;
   background: var(--surface);
   color: var(--text);
   font: inherit;
@@ -904,12 +840,14 @@ a.mc-action {
 .vw-focus-text {
   display: grid;
   flex: 1;
-  gap: 6px;
+  gap: 3px;
   min-width: 0;
 }
 
 .vw-focus-text strong {
+  font-size: 0.9rem;
   font-weight: 500;
+  line-height: 1.35;
 }
 
 /* The topic's description: two lines at most */
@@ -917,8 +855,8 @@ a.mc-action {
   display: -webkit-box;
   overflow: hidden;
   color: var(--text-2);
-  font-size: 0.82rem;
-  line-height: 1.4;
+  font-size: 0.78rem;
+  line-height: 1.35;
   -webkit-box-orient: vertical;
   -webkit-line-clamp: 2;
   line-clamp: 2;
@@ -928,6 +866,62 @@ a.mc-action {
   border-color: var(--blue);
 }
 
+/* The user's own topic, under the suggestions: same frame as a card, the box full width */
+.vw-focus-custom {
+  display: grid;
+  gap: 8px;
+  margin-top: 10px;
+  padding: 10px 12px;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  background: var(--surface);
+}
+
+.vw-focus-custom.on {
+  border-color: var(--blue);
+}
+
+.vw-focus-custom-head {
+  font-size: 0.9rem;
+  font-weight: 500;
+}
+
+/* A multi-line box, not the site's pill-shaped one-line .input */
+.vw-focus-custom textarea {
+  width: 100%;
+  min-height: 72px;
+  padding: 10px 12px;
+  border: 1px solid var(--line-strong);
+  border-radius: 10px;
+  background: rgba(0, 0, 0, 0.45);
+  color: var(--text);
+  font: 400 0.88rem/1.45 var(--font-body);
+  resize: none;
+  transition: border-color 0.2s, box-shadow 0.2s;
+}
+
+.vw-focus-custom textarea::placeholder {
+  color: var(--text-3);
+}
+
+.vw-focus-custom textarea:focus {
+  outline: none;
+  border-color: var(--blue);
+  box-shadow: var(--glow-sm);
+}
+
+/* The guide on the left, the character count on the right */
+.vw-focus-custom-foot {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.vw-focus-custom-foot small {
+  font-size: 0.74rem;
+}
+
 .vw-focus-card.wait {
   cursor: default;
   color: var(--text-2);