Refactor VideoTemplateEditor component: remove AI editing features and related state management, streamline template loading, and update styles for improved layout. Enhance CSS for responsive design and visual consistency across various components, including dropdowns, sync stats, and quiz elements. Remove deprecated premium badge styles and adjust layout for chat components.

README.md

@@ -49,7 +49,7 @@ archive, stays in sync with it, cites the exact lines behind every answer, and t
 | Citations | Exact line ranges, verified before you see them | Passage level citations |
 | Not in your sources | Says so; unverifiable claims are dropped | Grounded, passage citations |
 | Audio | Two hosts on ElevenLabs voices, or your consented voice clone | Two host overviews, Google voices |
-| Video | 9:16 shorts, 16:9 explainers, 1:1 audiograms, quote cards, in your brand | Video overviews |
+| Video | 9:16 shorts, 16:9 explainers, 1:1 audiograms, quote cards | Video overviews |
 | Publishing | Launch Kits (threads, LinkedIn, Notes, Bluesky, SEO, carousels) and auto posting | Not a publishing tool |
 | Your voice | Voice profile learned from your posts, used in every draft | General purpose writing |
 | Seeing your archive | Topic constellation with rising and dormant topics, evergreen resurfacing | Idea Constellations per notebook |
@@ -121,7 +121,7 @@ cd renderer && npm install && npm start                    # only needed for vid
 | Launchpad | Calendar and agenda, auto posting to X, LinkedIn and Bluesky, email reminders, tracked links, engagement |
 | Archive | Every generated artifact with filters, players, downloads, retry and delete |
 | Resurfacing | Evergreen scores and reshare angles for old posts, on this day, straight into a kit or the calendar |
-| Settings | Profile, workspace, brand kit, privacy, plan usage meters, connections, sign out everywhere, delete |
+| Settings | Profile, workspace, privacy, plan usage meters, connections, sign out everywhere, delete |
 
 ## Key choices
 

backend/alembic/versions/0006_plans.py

@@ -57,12 +57,15 @@ def upgrade() -> None:
             sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
             sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
         )
+    # Columns a later migration drops (brand_kit) are not in a table 0001 built from today's models: seed what exists.
+    have = {c["name"] for c in sa.inspect(bind).get_columns("plans")}
+    seed = [{k: v for k, v in p.items() if k in have} for p in SEED]
     types = {"features": sa.JSON(), "voice_cloning": sa.Boolean(), "brand_kit": sa.Boolean(),
              "created_at": sa.DateTime(timezone=True), "updated_at": sa.DateTime(timezone=True)}
-    plans = sa.table("plans", *(sa.column(k, types.get(k)) for k in [*SEED[0], "created_at", "updated_at"]))
+    plans = sa.table("plans", *(sa.column(k, types.get(k)) for k in [*seed[0], "created_at", "updated_at"]))
     existing = {row[0] for row in bind.execute(sa.text("SELECT id FROM plans"))}
     now = datetime.now(UTC)
-    missing = [{**p, "created_at": now, "updated_at": now} for p in SEED if p["id"] not in existing]
+    missing = [{**p, "created_at": now, "updated_at": now} for p in seed if p["id"] not in existing]
     if missing:
         op.bulk_insert(plans, missing)
 

backend/app/config.py

@@ -64,6 +64,25 @@ class Settings(BaseSettings):
     r2_presign_ttl_seconds: int = 3600
     max_upload_bytes: int = 300 * 1024 * 1024
 
+    # Posts an infographic reads, and a report that is not built from themes (REPORT_PLANNER below). A quiz or flashcard set reads up to that many straight from the posts; with more (no limit
+    # on how many are picked) it reads a small sample of the ideas already extracted from them, so its size does not grow.
+    artifact_max_posts: int = 20
+    # Characters of post text a report, quiz or flashcard set may read in all (split evenly between the posts, 1,500 at least each).
+    artifact_passage_budget: int = 120_000
+    # The same for a quiz: it needs less text than a report to ask good questions.
+    artifact_quiz_passage_budget: int = 60_000
+    # Ideas (already extracted from each post) in the evidence of a flashcard set, or of a quiz above ARTIFACT_MAX_POSTS posts.
+    artifact_idea_sample: int = 30
+
+    # Reports. "themes": the posts' stored ideas are grouped into weighted themes, a blueprint plans the report, and each section is
+    # written from its own evidence (pipeline/report_themes.py). "legacy": the posts' text goes straight to the writer, at most
+    # ARTIFACT_MAX_POSTS of them. Chats, small selections and posts without stored ideas always use the legacy way.
+    report_planner: str = "themes"
+    # Posts a themed report reads: 0 = every post picked (the plan's indexed_posts still applies).
+    report_max_posts: int = 0
+    # Posts whose ideas are extracted while the report is made (in parallel); the rest are represented by their opening.
+    report_inline_ideas: int = 25
+
     # LLM (LiteLLM model strings; Z.ai GLM by default)
     llm_model: str = "openai/glm-5.3"
     llm_fast_model: str = "openai/glm-5.3-flash"
@@ -86,6 +105,9 @@ class Settings(BaseSettings):
     llm_temperature: float = 1.0  # Z.ai recommends 1.0 for GLM-5.x
     # Reasoning output counts against max_tokens, so leave headroom for the structured answer.
     llm_max_tokens: int = 10000
+    # The output cap of the fast model: quizzes, flashcards, infographics, idea extraction, template suggestions. A cap, not a target:
+    # only the tokens written are charged, and the thinking counts too, so keep room for it. Measured answers are under 3,000.
+    llm_fast_max_tokens: int = 6000
     # GLM-5.x always reasons (it cannot be disabled); this sets how hard. low | high | max
     llm_reasoning_effort: str = "low"
 

backend/app/db.py

@@ -11,13 +11,18 @@ class Base(DeclarativeBase):
 
 
 _sqlite = settings.database_url.startswith("sqlite")
-# Postgres: a connection that dies silently (laptop sleep, network change, Neon dropping it) otherwise leaves a query
-# waiting on the socket forever, and the worker loop with it. Keepalives notice a dead peer within about a minute
-# and the query fails instead; connect_timeout does the same for a connect that never completes.
+# A hosted Postgres (Neon) closes idle connections and drops the odd one on a network blip, and a connection that dies silently
+# (laptop sleep, network change) otherwise leaves a query waiting on the socket forever, and the worker loop with it. TCP
+# keepalives notice a dead peer within about a minute, so the query fails instead and a dead socket is noticed while it sits in
+# the pool; connect_timeout does the same for a connect that never completes. A pooled connection is also replaced before it
+# is handed out (pool_recycle, below Neon's idle timeout), since pool_pre_ping alone can fail on a dead SSL socket with a
+# ProgrammingError ("can't change 'autocommit' now") that SQLAlchemy does not treat as a lost connection, and the request
+# ends in a 500.
 _pg_connect_args = {"connect_timeout": 10, "keepalives": 1, "keepalives_idle": 30, "keepalives_interval": 10,
                     "keepalives_count": 3}
 _connect_args = {"check_same_thread": False, "timeout": 30} if _sqlite else _pg_connect_args
-engine = create_engine(settings.database_url, pool_pre_ping=True, pool_recycle=300, connect_args=_connect_args)
+engine = create_engine(settings.database_url, pool_pre_ping=True, connect_args=_connect_args,
+                       **({} if _sqlite else {"pool_recycle": 240, "pool_use_lifo": True}))
 
 if _sqlite:
     # Local dev: the API and the worker share one file. WAL lets reads run during a write, the busy

backend/app/infographics/image.py

@@ -5,6 +5,7 @@ import functools
 import glob
 import hashlib
 import os
+import re
 import shutil
 import subprocess
 import tempfile
@@ -14,8 +15,9 @@ from threading import Lock
 
 from app.infographics.render import SIZES
 
-TIMEOUT = 60  # seconds for one drawing
-KEEP = 8  # drawings kept in memory
+TIMEOUT = 90  # seconds for one drawing
+SCALE = 2  # pixels per page pixel: a 1600 x 2260 page is drawn as 3200 x 4520, sharp on any screen and in print
+KEEP = 6  # drawings kept in memory
 
 _cache: OrderedDict[str, bytes] = OrderedDict()
 _lock = Lock()
@@ -51,9 +53,9 @@ def chrome() -> str | None:
 
 
 def render_png(html: str, layout: str = "portrait") -> bytes:
-    """The page as a PNG at its own size: tall (1600 x 2260) or wide (2260 x 1600)."""
+    """The page as a PNG, drawn at SCALE times its size: tall (1600 x 2260) or wide (2260 x 1600) before scaling."""
     width, height = SIZES.get(layout, SIZES["portrait"])
-    key = hashlib.sha256(f"{width}x{height}{html}".encode()).hexdigest()
+    key = hashlib.sha256(f"{width}x{height}@{SCALE}{html}".encode()).hexdigest()
     with _lock:
         if key in _cache:
             _cache.move_to_end(key)
@@ -65,7 +67,7 @@ def render_png(html: str, layout: str = "portrait") -> bytes:
     with tempfile.TemporaryDirectory() as tmp:
         src, out = Path(tmp) / "page.html", Path(tmp) / "out.png"
         src.write_text(page, encoding="utf-8")
-        cmd = [binary, "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars", "--force-device-scale-factor=1",
+        cmd = [binary, "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars", f"--force-device-scale-factor={SCALE}",
                f"--user-data-dir={tmp}/profile", f"--window-size={width},{height}", "--virtual-time-budget=8000",
                f"--screenshot={out}", f"file://{src}"]
         try:
@@ -80,3 +82,30 @@ def render_png(html: str, layout: str = "portrait") -> bytes:
         while len(_cache) > KEEP:
             _cache.popitem(last=False)
     return data
+
+
+_FIT = re.compile(r"FIT=([0-9.]+)")
+_MEASURE = ("<script>document.fonts.ready.then(function(){var b=document.querySelector('.ig-body'),i=document.querySelector('.ig-inner');"
+            "var s=1;if(b&&i){var inner=i.scrollHeight*parseFloat(getComputedStyle(i).getPropertyValue('--fit')||1);s=Math.min(1,b.clientHeight/Math.max(inner,1));}"
+            "document.title='FIT='+s.toFixed(3);});</script>")
+
+
+def measure_fit(html: str, layout: str) -> float:
+    """The scale (1 or less) that makes an AI-composed page's body fit its space: the page drawn once, in Chrome, with our own
+    small script measuring it (the page's markup is sanitised, so no other script is in it). 1 when Chrome is missing."""
+    width, height = SIZES.get(layout, SIZES["portrait"])
+    binary = chrome()
+    if not binary:
+        return 1.0
+    page = f'<!doctype html><meta charset="utf-8"><body style="margin:0">{html}{_MEASURE}</body>'
+    with tempfile.TemporaryDirectory() as tmp:
+        src = Path(tmp) / "page.html"
+        src.write_text(page, encoding="utf-8")
+        cmd = [binary, "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars", f"--user-data-dir={tmp}/profile",
+               f"--window-size={width},{height}", "--virtual-time-budget=10000", "--dump-dom", f"file://{src}"]
+        try:
+            out = subprocess.run(cmd, check=True, capture_output=True, timeout=TIMEOUT, text=True).stdout
+        except (subprocess.SubprocessError, OSError):
+            return 1.0
+    found = _FIT.search(out)
+    return max(0.55, min(1.0, float(found.group(1)))) if found else 1.0

backend/app/infographics/themes.py

@@ -19,8 +19,11 @@ THEMES: dict[str, Theme] = {t.id: t for t in (
     Theme("moonbase", "Moon Base", "A lunar surface, a dome and a flag", ("#2b2b30", "#d8d2c4", "#c8745f")),
     Theme("observatory", "Observatory", "A telescope under a chart of stars", ("#14282b", "#8fc2b4", "#d6b66a")),
 )}
-DEFAULT_THEME = "launch"
+DEFAULT_THEME = "midnight"  # the look new infographics start with (the six above are the older fixed themes)
 
 
 def theme_id(value: object) -> str:
-    return value if isinstance(value, str) and value in THEMES else DEFAULT_THEME
+    """A look (design.LOOKS) or one of the older themes; the default when unknown."""
+    from app.infographics.design import LOOKS
+
+    return value if isinstance(value, str) and (value in LOOKS or value in THEMES) else DEFAULT_THEME

backend/app/llm/provider.py

@@ -49,7 +49,7 @@ def main_lm(effort: str | None = None) -> dspy.LM:
 
 @lru_cache
 def fast_lm() -> dspy.LM:
-    return _build(settings.llm_fast_model, effort="low", temperature=None, max_tokens=8000)
+    return _build(settings.llm_fast_model, effort="low", temperature=None, max_tokens=settings.llm_fast_max_tokens)
 
 
 REPORT_MAX_TOKENS = 16000  # a few pages of prose plus GLM's low-effort reasoning
@@ -62,6 +62,27 @@ def report_lm() -> dspy.LM:
                   max_tokens=REPORT_MAX_TOKENS)
 
 
+REPORT_PLAN_MAX_TOKENS = 6000  # the blueprint: a storyline and up to eight short section plans plus reasoning
+REPORT_SECTION_MAX_TOKENS = 4000  # one section (two to five paragraphs) plus reasoning, a quarter of a whole report's cap
+
+
+def _report_model() -> str:
+    return settings.llm_report_model or settings.llm_fast_model
+
+
+@lru_cache
+def report_plan_lm() -> dspy.LM:
+    """Plans a themed report (the blueprint). The report model, with a small cap: the answer is a plan, not prose."""
+    return _build(_report_model(), effort="low", temperature=None, max_tokens=REPORT_PLAN_MAX_TOKENS)
+
+
+@lru_cache
+def report_section_lm(retry: bool = False) -> dspy.LM:
+    """Writes one section of a themed report. retry=True is the second try after a failed one: a different temperature,
+    so it is a fresh call and not the failed one again from the cache."""
+    return _build(_report_model(), effort="low", temperature=0.7 if retry else None, max_tokens=REPORT_SECTION_MAX_TOKENS)
+
+
 @lru_cache
 def triage_lm() -> dspy.LM:
     """Cheap model that decides whether a chat message needs research at all."""
@@ -82,6 +103,16 @@ def focus_lm(retry: bool = False) -> dspy.LM:
                   max_tokens=FOCUS_MAX_TOKENS)
 
 
+SUGGEST_TEMPLATES_MAX_TOKENS = 2000  # four short template ideas plus GLM's low-effort reasoning
+
+
+@lru_cache
+def suggest_templates_lm() -> dspy.LM:
+    """The Create report dialog's suggested templates: four short template ideas out, so a tighter cap than the
+    general fast_lm keeps this quick without cutting into GLM's reasoning headroom."""
+    return _build(settings.llm_fast_model, effort="low", temperature=None, max_tokens=SUGGEST_TEMPLATES_MAX_TOKENS)
+
+
 def configure_default() -> None:
     dspy.configure(lm=main_lm(), adapter=dspy.JSONAdapter())
 

backend/app/llm/run.py

@@ -77,7 +77,8 @@ def predict_many(
 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,
+        model = getattr(lm, "model", None) or settings.llm_model  # the model that answered, not always the main one
+        record_usage(db, workspace_id=workspace_id, kind="llm", provider=provider_name(model), model=model,
                      quantity=usage.total, unit="tokens", cost_usd=usage.cost_usd, job=job)
     workspace = db.get(Workspace, workspace_id)
     for inputs, outputs in calls:

backend/app/llm/signatures.py

@@ -451,6 +451,58 @@ class PlanInfographic(dspy.Signature):
     infographic: InfographicOut = dspy.OutputField()
 
 
+class KeyFigure(BaseModel):
+    value: str = Field(description="A number or a very short fact, at most 12 characters, e.g. 30%, 8 steps, Layer 1")
+    label: str = Field(description="What it counts or means, at most 6 words")
+
+
+class DesignOut(BaseModel):
+    title: str = Field(description="At most 8 words")
+    subtitle: str = Field(description="One line, at most 16 words")
+    eyebrow: str = Field(description="A 1 to 3 word topic label, e.g. Agent engineering")
+    key_figures: list[KeyFigure] = Field(description="The 2 or 3 most important numbers or short facts in the material, shown beside the title")
+    body_html: str = Field(description="The body of the page: 2 to 4 sections of HTML built only from the allowed components")
+    rule: str = Field(description="The one takeaway, at most 14 words")
+    notes: list[str] = Field(description="Exactly 3 supporting notes, at most 14 words each")
+
+
+class DesignInfographic(dspy.Signature):
+    """Design a one page infographic from the material. You write the body of the page as HTML, composed ONLY from the
+    components below, choosing the ones that make the content clearest (a flow chart for steps, a timeline for events,
+    a hierarchy for a whole and its parts, a comparison for two options, cards for the key ideas, stats for numbers that
+    matter). Use only what the material says. When a layout style is asked for, build the page around it. When a focus is
+    given, make it about that, as far as the material covers it. The page is black, blue and white and printed on a
+    poster: plain text only, short lines, no markdown, no emoji, no quotes around names, no em dashes. Write in the
+    language of the material.
+
+    HTML rules: tags allowed are div, section, span, p, ul, ol, li, strong, em, small, br. Use no style, id, href, src,
+    script, svg, img or any attribute except class. Only these class names exist: sec, sec-t, lead, hl, node, n-no, n-t,
+    n-d, flow, col, grid, c2, c3, c4, card, c-k, c-t, c-d, timeline, t-item, t-when, t-t, t-d, tree, t-root, t-kids,
+    compare, side, s-h, stats, stat, s-n, s-l, cols, pills, pill, callout.
+
+    Every part sits in a section: <section class="sec"><div class="sec-t">Short heading</div> COMPONENT </section>.
+    Components:
+    - Flow chart, left to right, at most 4 boxes, arrows are drawn between them for you:
+      <div class="flow"><div class="node"><span class="n-no">01</span><span class="n-t">Title</span><span class="n-d">One short line</span></div> ...</div>
+      Add class hl to the box that matters most (class="node hl"). For more than 4 steps use two flows, or a vertical one: class="flow col" (at most 5 boxes).
+    - Cards in a grid of 2, 3 or 4 columns (class grid c2, grid c3 or grid c4, at most 8 cards):
+      <div class="grid c3"><div class="card"><span class="c-k">Kicker</span><span class="c-t">Title</span><span class="c-d">One short line</span></div> ...</div>
+    - Timeline, at most 5 moments: <div class="timeline"><div class="t-item"><span class="t-when">When</span><span class="t-t">Title</span><span class="t-d">One short line</span></div> ...</div>
+    - Hierarchy, one root and 2 to 4 children: <div class="tree"><div class="node hl t-root"><span class="n-t">Whole</span><span class="n-d">Line</span></div><div class="t-kids"><div class="node"><span class="n-t">Part</span><span class="n-d">Line</span></div> ...</div></div>
+    - Comparison of two sides, 2 to 4 short lines each: <div class="compare"><div class="side"><span class="s-h">Side A</span><ul><li>Line</li></ul></div><div class="side hl"><span class="s-h">Side B</span><ul><li>Line</li></ul></div></div>
+    - Numbers, 2 to 4: <div class="stats"><div class="stat"><span class="s-n">30%</span><span class="s-l">What it counts</span></div> ...</div>
+    - A callout sentence: <div class="callout">One sentence.</div>
+    The key_figures are separate from the body and are shown beside the title, so do not repeat them in the body.
+    Lengths: a box or card title at most 4 words, its line at most 14 words, a heading at most 4 words. Use two to four
+    sections, and mix components (never one grid of 8 cards alone). Keep the whole page short enough for one poster."""
+
+    title: str = dspy.InputField(desc="What the material is from")
+    material: list[str] = dspy.InputField(desc="Ideas from posts, or chat transcripts")
+    focus: str = dspy.InputField(desc="What the infographic should be about, or (none)")
+    layout_style: str = dspy.InputField(desc="The kind of layout asked for, or auto to choose")
+    design: DesignOut = dspy.OutputField()
+
+
 class WriteReport(dspy.Signature):
     """Write the report the reader describes, using only the material given: never add facts from outside it. Follow
     the reader's instructions on structure, style, tone and length. Write in Markdown that starts straight at the
@@ -460,9 +512,8 @@ class WriteReport(dspy.Signature):
     unless the reader's instructions ask for a different structure. Every "## " heading is specific and descriptive of
     what is in that section (for example "The Context Window Bottleneck: Moving Beyond Basic Summarization", never
     "Section 2" or "Details"), and they read in a logical order. Use "### " inside sections, lists, and tables where
-    they help. When the material has numbered lines (FILE blocks), put a [n] marker after each
-    claim it supports and list each n in citations with the path and lines it came from; when it is a chat transcript,
-    write no markers and no citations. Do not write a quiz, flashcards, practice or review questions into the report
+    they help. Do not cite: no [n] markers, footnotes, references or lists of sources in the text; the app shows the reader
+    the sources separately. Do not write a quiz, flashcards, practice or review questions into the report
     unless the reader's instructions
     ask for one: those are offered to the reader separately as visuals they can add. Never write about visuals, mind
     maps, flashcards, quizzes, tables or timelines in the text, and never suggest or describe one, even if the
@@ -476,7 +527,6 @@ class WriteReport(dspy.Signature):
     language: str = dspy.InputField(desc="The language to write in")
     report_title: str = dspy.OutputField(desc="A specific title, 3 to 10 words")
     markdown: str = dspy.OutputField(desc="The report body in Markdown, starting at the first ## heading")
-    citations: list[FileCitation] = dspy.OutputField()
 
 
 class PlannedEmbed(BaseModel):
@@ -521,22 +571,166 @@ class WriteReportSection(dspy.Signature):
     and length; a section is two to five short paragraphs, or a list or table where that reads better. Do not write
     quiz questions, flashcards or
     review questions in the section (those are offered to the reader separately). Do not repeat
-    the heading, and do not use "#" or "##" headings; "###" subheadings are fine. When the material has numbered lines (FILE
-    blocks), put a [n] marker after each claim it supports and list each n in citations with the path and lines; when it
-    is a chat transcript, write no markers and no citations. Never write about visuals, mind maps, flashcards,
+    the heading, and do not use "#" or "##" headings; "###" subheadings are fine. Do not cite: no [n] markers, footnotes,
+    references or lists of sources in the text; the app shows the reader the sources separately. Never write about visuals, mind maps, flashcards,
     quizzes, tables or timelines in the text, and never suggest or describe one, even if the reader's instructions
     mention them: the app offers those to the reader separately, so write only the report itself. Write in the
     language requested. Never use em dashes."""
 
+    # The parts every section shares come first, so a provider can reuse them across the section calls.
     title: str = dspy.InputField()
     report_title: str = dspy.InputField()
+    request: str = dspy.InputField(desc="What the reader wants the report to be")
+    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
+    language: str = dspy.InputField()
     heading: str = dspy.InputField()
     brief: str = dspy.InputField(desc="What this section should say")
+    markdown: str = dspy.OutputField(desc="The section body in Markdown, without its heading")
+
+
+# Themed reports: the posts' stored ideas are grouped into themes, a blueprint plans the whole report, and each section is
+# written from its own evidence (pipeline/report_themes.py, report_blueprint.py, report_evidence.py).
+
+
+class ReportTheme(BaseModel):
+    name: str = Field(description="2 to 5 words, a noun phrase a reader would recognise")
+    summary: str = Field(description="One or two plain sentences on what the posts say about it")
+    idea_ids: list[str] = Field(description="Ids of the ideas that belong to this theme, exactly as listed")
+    matches_request: bool = Field(False, description="True when the reader's request asks for this theme to be focused on, "
+                                                     "included or given more room")
+
+
+class ThemeRelation(BaseModel):
+    a: str = Field(description="A theme name, exactly as you wrote it in themes")
+    b: str = Field(description="Another theme name, exactly as you wrote it in themes")
+    relation: str = Field(description="How they connect, one short sentence")
+
+
+class GroupThemes(dspy.Signature):
+    """Group ideas taken from a writer's posts into themes. Every idea belongs to exactly one theme, listed by its id as
+    given. A theme is something several ideas are about, named the way a reader would name it: not a post title, not a
+    single idea, not 'Other'. Choose 4 to 12 themes, fewer when the ideas really are about few things. Also note how themes
+    connect (one cause of another, one the context of another, two sides of a choice), only where the ideas show it.
+    Where the reader's request asks to focus on, include or give more room to something, set matches_request on the theme
+    that is about it. Never use em dashes."""
+
+    title: str = dspy.InputField(desc="The notebook or posts the ideas come from")
+    request: str = dspy.InputField(desc="What the reader wants the report to be")
+    ideas: list[str] = dspy.InputField(desc="One per line: id | label: note")
+    themes: list[ReportTheme] = dspy.OutputField(desc="4 to 12 themes")
+    relations: list[ThemeRelation] = dspy.OutputField(desc="How themes connect, at most 8, only where the ideas show it")
+
+
+class BlueprintSection(BaseModel):
+    heading: str = Field(description="2 to 8 words, specific to what the section says, never generic")
+    role: Literal["intro", "body", "synthesis", "summary"] = Field(
+        "body", description="intro opens the report, summary closes it, synthesis ties two or more themes together, "
+                            "body covers its themes")
+    brief: str = Field(description="What this section says, 1 to 2 sentences")
+    theme_ids: list[str] = Field(description="Ids of the themes this section is about, as listed. A body section's "
+                                             "themes belong to it alone")
+    depth: Literal["deep", "standard", "brief"] = Field("standard", description="deep for a theme with a large weight "
+                                                        "or one the reader asked for, brief for a small one")
+    must_cover: list[str] = Field(description="2 to 4 specific points this section has to make")
+    embed: PlannedEmbed | None = Field(None, description="A visual to suggest right after this section, only where it "
+                                                         "really helps")
+
+
+class ThemeConnection(BaseModel):
+    theme_ids: list[str] = Field(description="Two or more theme ids that are connected")
+    relation: str = Field(description="How they connect, one short sentence")
+    section: str = Field(description="Heading of the section that should bridge them")
+
+
+class PlanReportBlueprint(dspy.Signature):
+    """Plan a whole report before any of it is written. The themes come with their weight (their share of what the posts say), a
+    tier (major, medium, minor) and whether the reader asked for them. Give every major theme and every theme the reader asked
+    for its own section with depth deep, in an order that builds an argument; put the ones the reader asked for early. Put medium
+    themes in standard sections and merge the minor ones into one brief section. A theme is the subject of exactly one section.
+    Write a storyline of three to five sentences: what the report as a whole says, so every section can be written toward it.
+    Start with an intro section and end with a summary section unless the reader asks for something else; the summary must
+    restate the major themes. Where themes connect, say which section bridges them (connections), and add a synthesis section
+    only if the connection deserves its own. Each section's must_cover is specific to it and shares no point with another.
+    Choose at most max_sections sections. Never plan a section that is itself a quiz, flashcards, practice questions or a
+    mind map: when allowed_kinds is not empty those are visuals, suggested through a section's embed (at most four in all, each
+    kind once, only the kinds allowed): a mind_map to show how many linked themes fit together (at most one, near the start or
+    the end), flashcards to learn a set of terms or facts, a quiz to check understanding after a dense section, and an
+    infographic, a one page picture of the main ideas, which every report with that kind allowed should suggest once, on the
+    last section before the summary. Suggest the others only where they really help; none where plain prose reads better. When
+    allowed_kinds is empty, plan no embeds, and a quiz or practice section is allowed only if the reader's request asks for
+    one. Use only what the themes cover. Never use em dashes."""
+
+    title: str = dspy.InputField()
+    request: str = dspy.InputField(desc="What the reader wants the report to be")
+    themes: list[str] = dspy.InputField(desc="One per line: id | name | tier | weight | posts | asked for: summary")
+    relations: list[str] = dspy.InputField(desc="One per line: id <-> id: how they connect, or empty")
+    allowed_kinds: list[str] = dspy.InputField(desc="The visuals that may be suggested, or empty")
+    language: str = dspy.InputField()
+    max_sections: int = dspy.InputField(desc="The most sections to plan")
+    report_title: str = dspy.OutputField(desc="A specific title, 3 to 10 words")
+    storyline: str = dspy.OutputField(desc="Three to five sentences on what the whole report says")
+    sections: list[BlueprintSection] = dspy.OutputField(desc="2 to max_sections sections, in reading order")
+    connections: list[ThemeConnection] = dspy.OutputField(desc="At most 6")
+
+
+class WriteThemedSection(dspy.Signature):
+    """Write one section of a report that has already been planned. You are given the storyline of the whole report and its
+    outline: write toward that storyline, and do not make points that another section owns (covered_elsewhere). Make the
+    points in must_cover. Use only the evidence given; never add facts from outside it. The evidence is grouped by post and
+    comes in two forms: text as the writer wrote it, and short summaries of other posts. Combine what
+    several posts say about the same thing: say where they agree, where they differ or where the writer changed their mind,
+    and never go through the posts one at a time. Where a connection is listed, bridge the themes in a sentence or two.
+    Follow the reader's instructions on style, tone and length; a section is two to five short paragraphs, or a list or table
+    where that reads better; a deep section is longer than a brief one. For role intro, say what the report covers and why it
+    matters; for role summary, restate the main points of the sections as written, in the digests given. Do not repeat the
+    heading, and do not use "#" or "##" headings; "###" subheadings are fine. Do not cite: no [n] markers, footnotes,
+    references or lists of sources in the text, and do not name the posts or their paths; the app shows the reader the
+    sources separately. Do not write quiz questions, flashcards or review questions, and never write about visuals, mind maps,
+    flashcards, quizzes, tables or timelines in the text: the app offers those separately. Write in the language requested.
+    Never use em dashes."""
+
+    # What every section shares comes first, so a provider can reuse it across the section calls.
+    storyline: str = dspy.InputField(desc="What the whole report says")
+    outline: list[str] = dspy.InputField(desc="Every section: number, heading, role, what it says")
+    connections: list[str] = dspy.InputField(desc="Themes the report connects, with the section that bridges them")
     request: str = dspy.InputField(desc="What the reader wants the report to be")
-    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
     language: str = dspy.InputField()
+    heading: str = dspy.InputField(desc="The section to write")
+    role: str = dspy.InputField(desc="intro, body, synthesis or summary")
+    depth: str = dspy.InputField(desc="deep, standard or brief")
+    brief: str = dspy.InputField(desc="What this section should say")
+    must_cover: list[str] = dspy.InputField(desc="Points this section has to make")
+    covered_elsewhere: list[str] = dspy.InputField(desc="Points other sections own: do not make them here")
+    bridges: list[str] = dspy.InputField(desc="Connections this section should bridge, or empty")
+    evidence: list[str] = dspy.InputField(desc="Posts as written, short summaries of other posts, or digests of the written "
+                                               "sections")
     markdown: str = dspy.OutputField(desc="The section body in Markdown, without its heading")
-    citations: list[FileCitation] = dspy.OutputField()
+
+
+class WriteThemedReport(dspy.Signature):
+    """Write a whole report that has already been planned, in one piece. You are given the storyline and the planned sections
+    in order, each with what it must cover and the evidence for it. Write in Markdown that starts straight at the first "## "
+    heading (the title goes in report_title, not in the text), with one "## " heading per planned section, in that order and
+    with those headings, and write toward the storyline. Make each section's must_cover points, and do not make a point
+    another section owns. Use only the evidence given; never add facts from outside it. The evidence is grouped by post and
+    comes in two forms: text as the writer wrote it, and short summaries of other posts. Combine what
+    several posts say about the same thing: say where they agree, where they differ or where the writer changed their mind,
+    and never go through the posts one at a time. Where a connection is listed, bridge the themes. A deep section is longer
+    than a brief one. Follow the reader's instructions on style, tone and length. Use "### " inside sections, lists, and tables
+    where they help. Do not cite: no [n] markers, footnotes, references or lists of sources in the text, and do not name the
+    posts or their paths; the app shows the reader the sources separately. Do not write a quiz, flashcards, practice or
+    review questions unless the reader's instructions ask for one, and never write about visuals, mind maps, flashcards or
+    timelines in the text. Write in the language requested. Never use em dashes."""
+
+    title: str = dspy.InputField(desc="The notebook or posts the evidence comes from")
+    storyline: str = dspy.InputField(desc="What the whole report says")
+    request: str = dspy.InputField(desc="What the reader wants the report to be")
+    language: str = dspy.InputField(desc="The language to write in")
+    connections: list[str] = dspy.InputField(desc="Themes the report connects, with the section that bridges them")
+    sections: list[str] = dspy.InputField(desc="The planned sections in order: heading, role, depth, what it says, must cover, "
+                                               "followed by its evidence")
+    report_title: str = dspy.OutputField(desc="A specific title, 3 to 10 words")
+    markdown: str = dspy.OutputField(desc="The report body in Markdown, starting at the first ## heading")
 
 
 class ReportTemplateIdea(BaseModel):
@@ -552,7 +746,7 @@ class SuggestReportTemplates(dspy.Signature):
     a practical how-to, a comparison, a beginner primer and an in-depth analysis, when the material supports them).
     Never use em dashes."""
 
-    items: list[str] = dspy.InputField(desc="The title and the start of each source")
+    items: list[str] = dspy.InputField(desc="Each source: its title, topics and key ideas, or the start of it")
     topic: str = dspy.InputField(desc="What the reader wants the report to be about, or (none)")
     templates: list[ReportTemplateIdea] = dspy.OutputField(desc="Exactly 4")
 

backend/app/models/__init__.py

@@ -1,5 +1,6 @@
 from app.models.content import (
     Artifact,
+    ArtifactFeedback,
     ArtifactShare,
     B2VCustomVoice,
     B2VStyle,
@@ -17,6 +18,8 @@ from app.models.content import (
     MessageFeedback,
     Notebook,
     NotebookDocument,
+    QuizAttempt,
+    ReportTemplateCache,
     SocialAccount,
     Source,
     Topic,
@@ -34,9 +37,11 @@ from app.models.support import SupportConversation, SupportMessage
 from app.models.user import AuthProvider, BillingEvent, PlanRecord, Subscription, User, Workspace, WorkspaceMember
 
 __all__ = [
+    "QuizAttempt",
     "SupportConversation",
     "SupportMessage",
     "Artifact",
+    "ArtifactFeedback",
     "ArtifactShare",
     "AuthProvider",
     "B2VCustomVoice",
@@ -58,6 +63,7 @@ __all__ = [
     "Notebook",
     "PlanRecord",
     "NotebookDocument",
+    "ReportTemplateCache",
     "SocialAccount",
     "Source",
     "Subscription",

backend/app/models/content.py

@@ -155,6 +155,52 @@ class MessageFeedback(IdMixin, TimestampMixin, Base):
     recall: Mapped[dict] = mapped_column(JSON, default=dict)  # copy of Message.recall_json
 
 
+class ArtifactFeedback(IdMixin, TimestampMixin, Base):
+    """A thumbs up or down on one generated report, quiz, flashcard set or infographic, with a snapshot of what it was
+    (title, prompt, sources, options) taken when it was rated, so the ratings stay useful after it is deleted (the link
+    then becomes null). One row per artifact and person: rating again replaces it."""
+
+    __tablename__ = "artifact_feedback"
+    __table_args__ = (UniqueConstraint("artifact_id", "user_id"),)
+
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    artifact_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("artifacts.id", ondelete="SET NULL"), index=True)
+    user_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("users.id", ondelete="SET NULL"))
+    artifact_type: Mapped[str] = mapped_column(String(30))
+    rating: Mapped[int] = mapped_column(Integer)  # 1 up, -1 down
+    reasons: Mapped[list] = mapped_column(JSON, default=list)
+    comment: Mapped[str | None] = mapped_column(Text)
+    snapshot: Mapped[dict] = mapped_column(JSON, default=dict)
+
+
+class QuizAttempt(IdMixin, TimestampMixin, Base):
+    """A person's last finished run of a quiz: what they answered and the score, so opening the quiz again shows the result.
+    One row per quiz and person; finishing it again replaces it."""
+
+    __tablename__ = "quiz_attempts"
+    __table_args__ = (UniqueConstraint("artifact_id", "user_id"),)
+
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    artifact_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("artifacts.id", ondelete="CASCADE"), index=True)
+    user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id", ondelete="CASCADE"))
+    score: Mapped[int] = mapped_column(Integer)
+    total: Mapped[int] = mapped_column(Integer)
+    answers: Mapped[list] = mapped_column(JSON, default=list)  # per question: choice (indexes), text, correct
+
+
+class ReportTemplateCache(IdMixin, TimestampMixin, Base):
+    """The suggested report templates already written for some sources, found again by a hash of exactly what the AI read (each
+    post's stored ideas and topics, and the topic). The same input gives the same templates at once, so the Create report dialog
+    is instant, and a changed post (its ideas change) gets new ones."""
+
+    __tablename__ = "report_template_cache"
+    __table_args__ = (UniqueConstraint("workspace_id", "key"),)
+
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    key: Mapped[str] = mapped_column(String(64))
+    templates: Mapped[list] = mapped_column(JSON, default=list)
+
+
 class WorkspaceMemory(IdMixin, TimestampMixin, Base):
     """The writer's standing notes, one row per workspace, shared by every notebook and chat.
 

backend/app/models/user.py

@@ -13,7 +13,6 @@ from sqlalchemy import (
     String,
     UniqueConstraint,
     Uuid,
-    false,
     true,
 )
 from sqlalchemy.orm import Mapped, mapped_column, relationship
@@ -56,7 +55,6 @@ class Workspace(IdMixin, TimestampMixin, Base):
     training_opt_in: Mapped[bool] = mapped_column(Boolean, default=False)
     # Off: no report of this workspace can be shared by link, and existing links stop working.
     allow_public_links: Mapped[bool] = mapped_column(Boolean, default=True, server_default=true())
-    brand_json: Mapped[dict] = mapped_column(JSON, default=dict)
 
     members: Mapped[list["WorkspaceMember"]] = relationship(back_populates="workspace")
 
@@ -112,11 +110,10 @@ class PlanRecord(TimestampMixin, Base):
     launch_kits: Mapped[int] = mapped_column(Integer, default=0)  # -1 = unlimited
     reports: Mapped[int] = mapped_column(Integer, default=0, server_default="0")  # per month, -1 = unlimited
     infographics: Mapped[int] = mapped_column(Integer, default=0, server_default="0")  # per month, -1 = unlimited
+    audio_overviews: Mapped[int] = mapped_column(Integer, default=-1, server_default="-1")  # allowed (in total on Free); -1 = no cap
     voice_cloning: Mapped[bool] = mapped_column(Boolean, default=False)
-    brand_kit: Mapped[bool] = mapped_column(Boolean, default=False)
     features: Mapped[list] = mapped_column(JSON, default=list)  # bullet points on the pricing page
     # Server defaults: 0006 seeds this table without these columns on a database 0001 built from the models.
-    video_premium: Mapped[bool] = mapped_column(Boolean, default=False, server_default=false())  # premium options
     # False: `videos` is a lifetime total that never refills (Free). True: per month.
     videos_monthly: Mapped[bool] = mapped_column(Boolean, default=True, server_default=true())
     video_limits: Mapped[dict | None] = mapped_column(JSON, default=dict)  # see plans.VIDEO_LIMITS

backend/app/pipeline/flashcards.py

@@ -8,6 +8,7 @@ from app.llm import run
 from app.llm.provider import fast_lm
 from app.llm.signatures import GenerateFlashcards
 from app.models import Artifact, Job
+from app.pipeline import idea_pool
 from app.pipeline.generate import NothingToDo
 from app.pipeline.material import Material, load_material
 from app.services.jobs import update_job
@@ -16,20 +17,29 @@ SAME_LANGUAGE = "the same language as the sources"  # no language picked: write
 CARD_COUNTS = {"fewer": 8, "standard": 16, "more": 24}
 
 
+def _card(c: dict, refs) -> dict | None:
+    """One generated card as the deck plays it, or None when it has no front or no back."""
+    front, back = (c.get("front") or "").strip(), (c.get("back") or "").strip()
+    if not front or not back:
+        return None
+    return {"front": front[:300], "back": back[:800], "sources": refs(c.get("sources"))}
+
+
 def make_cards(db: Session, workspace_id: uuid.UUID, material: Material, *, topic: str = "", count: int = 16,
                difficulty: str = "medium", language: str = SAME_LANGUAGE, job: Job | None = None) -> list[dict]:
     """Cards about the material: a front, a back and verified source lines. Repeats and empty cards are dropped."""
-    out = run.predict(GenerateFlashcards, db=db, workspace_id=workspace_id, job=job, title=material.title,
-                      material=material.text, topic=topic or "(none)", difficulty=difficulty, count=count,
-                      language=language.strip() or SAME_LANGUAGE, lm=fast_lm())
+    inputs = dict(title=material.title, topic=topic or "(none)", difficulty=difficulty, language=language.strip() or SAME_LANGUAGE)
+    # Posts with their ideas stored (the Mind Constellation's): one call over a random sample of those ideas, not the posts' text.
+    text = idea_pool.sample(db, workspace_id, material.docs, topic, chats=material.text) if material.mode == "ideas" else material.text
+    out = run.predict(GenerateFlashcards, db=db, workspace_id=workspace_id, job=job, material=text, count=count,
+                      lm=fast_lm(), **inputs)
     cards, seen = [], set()
-    for c in out.get("cards") or []:
-        front, back = (c.get("front") or "").strip(), (c.get("back") or "").strip()
-        key = front.lower()
-        if not front or not back or key in seen:
+    for raw in out.get("cards") or []:
+        card = _card(raw, material.refs)
+        if not card or card["front"].lower() in seen:
             continue
-        seen.add(key)
-        cards.append({"front": front[:300], "back": back[:800], "sources": material.refs(c.get("sources"))})
+        seen.add(card["front"].lower())
+        cards.append(card)
     return cards[:count]
 
 
@@ -38,7 +48,8 @@ def build_flashcards(db: Session, job: Job, artifact: Artifact) -> dict:
     count = CARD_COUNTS.get(params.get("count") or "standard", CARD_COUNTS["standard"])
     topic = (params.get("topic") or "").strip()
     difficulty = params.get("difficulty") if params.get("difficulty") in ("easy", "medium", "hard") else "medium"
-    material = load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="flashcard set")
+    material = load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="flashcard set",
+                             large_ok=True, ideas_always=True)
     update_job(db, job, progress=0.4, message="Writing the cards")
     cards = make_cards(db, artifact.workspace_id, material, topic=topic, count=count, difficulty=difficulty,
                        language=params.get("language") or SAME_LANGUAGE, job=job)

backend/app/pipeline/generate.py

@@ -112,22 +112,39 @@ def ideas_fresh(d) -> bool:
     return bool(md.get("ideas")) and md.get("ideas_hash") == (d.content_hash or "")
 
 
-def extract_ideas(db: Session, job: Job | None, workspace_id: uuid.UUID, doc_ids: list[str] | None = None) -> dict:
+def extract_ideas(db: Session, job: Job | None, workspace_id: uuid.UUID, doc_ids: list[str] | None = None, *,
+                  parallel: bool = False, limit: int | None = None) -> dict:
     """Read each post that has no current ideas once and keep what it says on the post (label, note, points and
-    the lines they came from). Maps are arranged from these, so they never re-read the posts."""
+    the lines they came from). Maps are arranged from these, so they never re-read the posts. `parallel` reads the
+    posts together instead of one after the other (a report that needs many at once); `limit` reads at most that many."""
     docs = workspace_docs(db, workspace_id, [uuid.UUID(str(i)) for i in doc_ids] if doc_ids is not None else None)
     todo = [d for d in docs if not ideas_fresh(d)]
+    if limit is not None:
+        todo = todo[:limit]
     corpus = Corpus(workspace_id)
     lm = fast_lm()
     done = 0
-    for i, d in enumerate(todo):
+    answers: list[dict | None] | None = None
+    if parallel and todo:
         if job:
-            update_job(db, job, progress=0.05 + 0.85 * i / max(len(todo), 1), message=f"Reading {d.title[:70]}")
-        try:
-            out = run.predict(ExtractIdeas, db=db, workspace_id=workspace_id, job=job, lm=lm, title=d.title,
-                              passage="\n\n".join(passages_for(corpus, [d], budget_chars=IDEAS_BUDGET)))
-        except Exception:
-            continue
+            update_job(db, job, progress=0.05, message=f"Reading {len(todo)} posts for their key ideas")
+        answers = run.predict_many(
+            ExtractIdeas,
+            [dict(title=d.title, passage="\n\n".join(passages_for(corpus, [d], budget_chars=IDEAS_BUDGET))) for d in todo],
+            db=db, workspace_id=workspace_id, lm=lm)
+    for i, d in enumerate(todo):
+        if answers is not None:
+            out = answers[i]
+            if out is None:
+                continue
+        else:
+            if job:
+                update_job(db, job, progress=0.05 + 0.85 * i / max(len(todo), 1), message=f"Reading {d.title[:70]}")
+            try:
+                out = run.predict(ExtractIdeas, db=db, workspace_id=workspace_id, job=job, lm=lm, title=d.title,
+                                  passage="\n\n".join(passages_for(corpus, [d], budget_chars=IDEAS_BUDGET)))
+            except Exception:
+                continue
         tools = tools_for(corpus, [d])
 
         def keep(items, tools=tools, d=d) -> list[dict]:

backend/app/pipeline/infographic.py

@@ -9,15 +9,18 @@ from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from app.corpus import Corpus
-from app.infographics.content import clamp
+from concurrent.futures import ThreadPoolExecutor
+
+from app.infographics.design import LOOKS, STYLES, build_content, render_design
+from app.infographics.image import measure_fit
 from app.infographics.render import build_html
 from app.infographics.themes import theme_id
 from app.llm import run
 from app.llm.provider import fast_lm
-from app.llm.signatures import PlanInfographic
+from app.llm.signatures import DesignInfographic
 from app.models import Artifact, Chat, Document, Job, Notebook
 from app.pipeline.generate import NothingToDo, extract_ideas, ideas_fresh
-from app.pipeline.material import MAX_POSTS, chat_material
+from app.pipeline.material import chat_material, max_posts
 from app.pipeline.passages import notebook_docs, passages_for, workspace_docs
 from app.services.jobs import update_job
 
@@ -67,7 +70,7 @@ def write_content(db: Session, job: Job, artifact: Artifact, params: dict) -> tu
         docs = workspace_docs(db, ws, picked)
     elif not chat_ids and nb:
         docs = notebook_docs(db, nb.id)
-    docs = docs[:MAX_POSTS]
+    docs = docs[:max_posts()]
     chats, chat_blocks = _chat_text(db, ws, chat_ids) if chat_ids else ([], [])
     if not docs and not chat_blocks:
         raise NothingToDo("Pick at least one post or chat for the infographic.")
@@ -76,12 +79,14 @@ def write_content(db: Session, job: Job, artifact: Artifact, params: dict) -> tu
     material = (_ideas_text(db, ws, docs, job) if docs else []) + chat_blocks
     prompt = (params.get("instructions") or "").strip()
     title = docs[0].title if docs else (chats[0].title or "Chat")
-    update_job(db, job, progress=0.35, message="Writing the infographic")
+    update_job(db, job, progress=0.35, message="Designing the infographic")
+    style = params.get("style") if params.get("style") in STYLES else "auto"
     content = None
     for _ in range(2):  # one retry when the model gives too little to draw
-        out = run.predict(PlanInfographic, db=db, workspace_id=ws, job=job, title=title, material=material,
-                          focus=prompt or "(none)", lm=fast_lm())
-        content = clamp(out.get("infographic") or {})
+        out = run.predict(DesignInfographic, db=db, workspace_id=ws, job=job, title=title, material=material,
+                          focus=prompt or "(none)", layout_style=f"{style}: {STYLES[style]}" if style != "auto" else "auto",
+                          lm=fast_lm())
+        content = build_content(out.get("design") or {})
         if content:
             break
     if not content:
@@ -101,6 +106,8 @@ def build_infographic(db: Session, job: Job, artifact: Artifact) -> dict:
     params = job.params
     theme = theme_id(params.get("theme"))
     content, source, _title = write_content(db, job, artifact, params)
+    update_job(db, job, progress=0.8, message="Fitting it to the page")
+    content["fit"] = fit_scales(theme, content)
     artifact.content_json = {**(artifact.content_json or {}), "title": f"Infographic: {content['title']}"[:140],
                              "theme": theme, "prompt": (params.get("instructions") or "").strip(), "source": source,
                              "content": content}
@@ -110,7 +117,22 @@ def build_infographic(db: Session, job: Job, artifact: Artifact) -> dict:
     return {"artifact_id": str(artifact.id)}
 
 
+def fit_scales(theme: str, content: dict) -> dict:
+    """The scale at which the body fits the page, tall and wide (measured in Chrome once, kept with the content)."""
+    look = theme if theme in LOOKS else "midnight"
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        wide, tall = (pool.submit(measure_fit, render_design(look, content, layout, fit=1.0), layout)
+                      for layout in ("landscape", "portrait"))
+        return {"landscape": wide.result(), "portrait": tall.result()}
+
+
 def infographic_html(content: dict, layout: str = "portrait") -> str | None:
-    """The page for a finished infographic's stored text and theme, tall or wide (None when it has none yet)."""
+    """The page for a finished infographic's stored content and look, tall or wide (None when it has none yet). Older
+    infographics (fixed text in a premade theme) still draw in that theme."""
     text = content.get("content")
-    return build_html(theme_id(content.get("theme")), text, layout) if text else None
+    if not text:
+        return None
+    theme = theme_id(content.get("theme"))
+    if "body_html" in text:
+        return render_design(theme if theme in LOOKS else "midnight", text, layout)
+    return build_html(theme, text, layout) if "items" in text else None

backend/app/pipeline/ingest.py

@@ -630,29 +630,39 @@ def store_locked(db: Session, source: Source, entries: list[FeedEntry]) -> tuple
 
 def ingest_source(db: Session, source: Source, job: Job, max_posts: int) -> dict:
     source.sync_status = "syncing"
-    update_job(db, job, status="running", progress=0.02, message="Contacting your feed")
     fetch_limit = max(SCAN_CAP, max_posts)
+    # Live counts the Sources page shows while this runs: found on the site, fetched (read), indexed.
+    live = {"stage": "fetching", "found": 0, "fetched": 0, "fetch_total": 0, "indexed": 0, "index_total": 0}
+
+    def report(progress: float | None = None, message: str | None = None, **counts) -> None:
+        live.update(counts)
+        update_job(db, job, progress=progress, message=message, result=dict(live))
+
+    update_job(db, job, status="running", progress=0.02, message="Contacting your feed", result=dict(live))
 
     if source.feed_url.startswith(SITE_PREFIX):
         update_job(db, job, message="Mapping your site")
         entries = crawl_site(
             source.feed_url.removeprefix(SITE_PREFIX), fetch_limit,
-            on_found=lambda n: update_job(db, job, progress=0.05, message=f"Found {n} pages, reading them"),
-            on_post=lambda done, total: update_job(db, job, progress=0.05 + 0.05 * done / total,
-                                                   message=f"Read {done} of {total} pages"),
-            read_limit=max_posts,
+            on_found=lambda n: report(0.05, f"Found {n} pages, reading them", found=n),
+            on_post=lambda done, total: report(0.05 + 0.05 * done / total, f"Read {done} of {total} pages",
+                                               fetched=done, fetch_total=total),
+            read_limit=max(max_posts, 1),
         )
         title = None
     else:
         title, entries = fetch_feed(source.feed_url, fetch_limit)
+        report(found=len(entries), fetched=len(entries), fetch_total=len(entries))
     source.title = source.title or title
     if source.platform == "substack" and len(entries) < fetch_limit:
         site = f"{urlparse(source.feed_url).scheme}://{urlparse(source.feed_url).netloc}"
-        update_job(db, job, progress=0.05, message="Reading your Substack archive")
+        report(0.05, "Reading your Substack archive")
         try:
             entries += fetch_substack_archive(
                 site, {e.url for e in entries}, fetch_limit,
-                on_page=lambda n: update_job(db, job, message=f"Found {len(entries) + n} posts in the archive"),
+                on_page=lambda n: report(message=f"Found {len(entries) + n} posts in the archive",
+                                         found=len(entries) + n, fetched=len(entries) + n,
+                                         fetch_total=len(entries) + n),
                 body_budget=max(0, max_posts - len(entries)),
             )
         except (httpx.HTTPError, ValueError):
@@ -662,9 +672,9 @@ def ingest_source(db: Session, source: Source, job: Job, max_posts: int) -> dict
     available, beyond = entries[:max_posts], entries[max_posts:]
 
     def progress(done: int, total: int, post_title: str) -> None:
-        update_job(db, job, progress=0.1 + 0.7 * done / total, message=f"{post_title[:80]} is in orbit")
+        report(0.1 + 0.7 * done / total, f"{post_title[:80]} is in orbit", stage="indexing", indexed=done)
 
-    update_job(db, job, progress=0.1, message=f"Indexing {len(available)} posts")
+    report(0.1, f"Indexing {len(available)} posts", stage="indexing", found=len(entries), index_total=len(available))
     indexed, skipped, changed = store_entries(db, source, available, progress)
 
     locked = 0

backend/app/pipeline/material.py

@@ -9,16 +9,36 @@ from dataclasses import dataclass, field
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from app.config import settings
 from app.corpus import Corpus
-from app.models import Chat, Document, Job, Message, Notebook
+from app.models import Chat, Document, Job, Message, Notebook, Workspace
 from app.pipeline.generate import NothingToDo
 from app.pipeline.passages import ScopedTools, notebook_docs, passages_for, tools_for, verify_refs, workspace_docs
 from app.services.jobs import update_job
+from app.services.plans import effective_plan
 
-MAX_POSTS = 20  # posts one artifact reads; the passage budget is shared between them
 CHAT_BUDGET = 60_000  # characters of chat transcripts
 
 
+def max_posts() -> int:
+    """Posts a report or infographic reads, and the most a quiz or flashcard set reads straight from the posts (ARTIFACT_MAX_POSTS);
+    the passage budget is shared between them."""
+    return max(settings.artifact_max_posts, 1)
+
+
+def use_ideas(docs: list[Document], *, large_ok: bool, ideas_always: bool) -> bool:
+    """Read the posts through their stored ideas instead of their text? Only when most of them have ideas stored (the rest are
+    represented by a short opening). A selection above max_posts() (quiz and flashcards) always, when it can; a flashcard set
+    (`ideas_always`) whatever the size. Otherwise, or with too few ideas stored, the posts' text is read as it always was."""
+    from app.pipeline.idea_pool import has_ideas
+
+    if not docs or not (large_ok or ideas_always):
+        return False
+    if len(docs) > max_posts() or ideas_always:
+        return has_ideas(docs) * 2 >= len(docs)
+    return False
+
+
 @dataclass
 class Material:
     title: str  # the notebook, the post, or the first chat's title
@@ -28,6 +48,9 @@ class Material:
     # Turns the model's {path, line_start, line_end} items into verified refs with their quote. Chats give none.
     refs: Callable[[list | None], list[dict]] = lambda _items: []
     tools: ScopedTools | None = None  # reads back cited lines (posts only)
+    # "passages": `text` holds the posts' passages. "ideas": more posts than max_posts(), so `text` holds only chat transcripts and
+    # the posts are read through their stored ideas (pipeline/idea_pool.py).
+    mode: str = "passages"
 
     @property
     def is_chat(self) -> bool:
@@ -52,7 +75,8 @@ def chat_material(db: Session, chats: list[Chat]) -> list[str]:
 
 
 def load_material(db: Session, workspace_id: uuid.UUID, notebook_id: uuid.UUID | None, params: dict, *,
-                  job: Job | None = None, what: str = "quiz") -> Material:
+                  job: Job | None = None, what: str = "quiz", large_ok: bool = False,
+                  ideas_always: bool = False, passage_budget: int | None = None) -> Material:
     """The source a job's params name: posts (`document_ids`, a notebook's, the archive's or a single post), chats
     (`chat_ids`), or both together. With `chat_ids` and no posts it reads only the chats; with neither it reads the whole
     notebook. Raises NothingToDo when there is nothing to read."""
@@ -65,7 +89,11 @@ def load_material(db: Session, workspace_id: uuid.UUID, notebook_id: uuid.UUID |
         docs = workspace_docs(db, workspace_id, picked)
     elif not chat_ids and nb:
         docs = notebook_docs(db, nb.id)
-    docs = docs[:MAX_POSTS]
+    # Quiz and flashcards take as many posts as the plan indexes: their ideas are sampled. The rest read max_posts().
+    docs = docs[:effective_plan(db, db.get(Workspace, workspace_id)).indexed_posts] if large_ok else docs[:max_posts()]
+    ideas_mode = use_ideas(docs, large_ok=large_ok, ideas_always=ideas_always)
+    if large_ok and not ideas_mode:
+        docs = docs[:max_posts()]  # their ideas are not stored yet: read the first posts' text, as a small selection is
 
     chats: list[Chat] = []
     chat_text: list[str] = []
@@ -84,8 +112,9 @@ def load_material(db: Session, workspace_id: uuid.UUID, notebook_id: uuid.UUID |
     if docs:
         corpus = Corpus(workspace_id)
         if job:
-            update_job(db, job, progress=0.1, message=f"Reading {len(docs)} posts")
-        text = passages_for(corpus, docs)
+            update_job(db, job, progress=0.1, message=f"Gathering the key ideas of {len(docs)} posts" if ideas_mode
+                       else f"Reading {len(docs)} posts")
+        text = [] if ideas_mode else passages_for(corpus, docs, budget_chars=passage_budget)
         tools = tools_for(corpus, docs)
         by_path = {d.path: d for d in docs}
 
@@ -110,4 +139,5 @@ def load_material(db: Session, workspace_id: uuid.UUID, notebook_id: uuid.UUID |
     if chat_text:
         source["chat_ids"] = [str(c.id) for c in chats]
     source["count"] = len(docs) + (len(chats) if chat_text else 0)
-    return Material(title=title, text=text + chat_text, docs=docs, refs=refs, tools=tools, source=source)
+    return Material(title=title, text=text + chat_text, docs=docs, refs=refs, tools=tools, source=source,
+                    mode="ideas" if ideas_mode else "passages")

backend/app/pipeline/media.py

@@ -17,7 +17,7 @@ from app.pipeline.passages import notebook_docs, passages_for, tools_for, verify
 from app.pipeline.report import SAME_LANGUAGE
 from app.services import tts
 from app.services.jobs import record_usage, update_job
-from app.services.renderer import PermanentJobError, brand_props, request_render
+from app.services.renderer import PermanentJobError, request_render
 from app.services.storage import keys, storage
 
 
@@ -160,14 +160,13 @@ def make_audiogram(db: Session, job: Job, artifact: Artifact) -> None:
     source = db.get(Artifact, uuid.UUID(job.params["audio_artifact_id"]))
     if not source or source.type != "audio_overview" or not source.storage_key:
         raise PermanentJobError("Pick a finished audio overview for the audiogram.")
-    workspace = db.get(Workspace, artifact.workspace_id)
     content = source.content_json or {}
     duration = float(content.get("duration_s") or 30)
     segments = [{"speaker": s["speaker"], "text": s["text"], "startMs": int(s["start"] * 1000),
                  "endMs": int(s["end"] * 1000)} for s in content.get("segments", [])]
     props = {"title": (content.get("title") or "Audio overview")[:140],
              "audioUrl": storage.presign_get(source.storage_key, ttl=6 * 3600),
-             "durationS": round(min(duration, 600), 2), "segments": segments, "brand": brand_props(workspace)}
+             "durationS": round(min(duration, 600), 2), "segments": segments }
     artifact.content_json = {**(artifact.content_json or {}), "style": "audiogram", "composition": "AudiogramSquare",
                              "audio_artifact_id": str(source.id), "duration_s": props["durationS"]}
     artifact.status = "rendering"
@@ -184,12 +183,11 @@ def make_audiogram(db: Session, job: Job, artifact: Artifact) -> None:
 def author_line(db: Session, workspace_id: uuid.UUID) -> str:
     ws = db.get(Workspace, workspace_id)
     owner = db.get(User, ws.owner_id) if ws else None
-    return (ws.brand_json or {}).get("name") or (owner.name if owner and owner.name else "") or "Notestack"
+    return (owner.name if owner and owner.name else "") or "Notestack"
 
 
 def make_quote_card(db: Session, job: Job, artifact: Artifact) -> None:
     content = artifact.content_json or {}
-    workspace = db.get(Workspace, artifact.workspace_id)
     if not content.get("quote"):
         docs = artifact_docs(db, artifact)
         if not docs:
@@ -212,8 +210,7 @@ def make_quote_card(db: Session, job: Job, artifact: Artifact) -> None:
     if doc and doc.source_id:
         src = db.get(Source, doc.source_id)
         publication = src.title if src else None
-    props = {"quote": content["quote"][:380], "author": author_line(db, artifact.workspace_id),
-             "brand": brand_props(workspace)}
+    props = {"quote": content["quote"][:380], "author": author_line(db, artifact.workspace_id)}
     if publication or (doc and doc.title):
         props["publication"] = (publication or doc.title)[:120]
     artifact.content_json = {**content, "composition": "QuoteCard"}
@@ -226,10 +223,8 @@ def render_carousel(db: Session, job: Job, artifact: Artifact) -> None:
     slides = (artifact.content_json or {}).get("slides") or []
     if not slides:
         raise PermanentJobError("This carousel has no slides.")
-    workspace = db.get(Workspace, artifact.workspace_id)
-    brand = brand_props(workspace)
     stills = [{"heading": s.get("heading", "")[:120], "body": s.get("body", "")[:500], "index": i + 1,
-               "total": len(slides), "brand": brand} for i, s in enumerate(slides)]
+               "total": len(slides)} for i, s in enumerate(slides)]
     artifact.status = "rendering"
     db.commit()
     request_render(job, artifact, "CarouselSlide", stills=stills)

backend/app/pipeline/passages.py

@@ -6,10 +6,11 @@ from types import SimpleNamespace
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from app.config import settings
 from app.corpus import Corpus, CorpusError, ScopedTools
 from app.models import Document, NotebookDocument, VoiceProfile
 
-DEFAULT_BUDGET = 120_000  # characters across all passages; GLM-5.3 has room, this keeps cost sane
+DEFAULT_BUDGET = 120_000  # the default of ARTIFACT_PASSAGE_BUDGET: characters across all passages; this keeps cost sane
 
 
 def notebook_docs(db: Session, notebook_id: uuid.UUID) -> list[Document]:
@@ -28,10 +29,26 @@ def workspace_docs(db: Session, workspace_id: uuid.UUID, ids: list[uuid.UUID] |
     return list(db.scalars(q.order_by(Document.published_at.desc())).all())
 
 
-def passages_for(corpus: Corpus, docs: list[Document], budget_chars: int = DEFAULT_BUDGET) -> list[str]:
+def _body_start(lines: list[str]) -> int:
+    """The index of the first line after the post file's header (the `---` block of title, url, date and source, and the repeated
+    `# Title`): none of it is worth sending, the `FILE path (title)` line already names the post."""
+    i = 0
+    if lines and lines[0].strip() == "---":
+        end = next((k for k in range(1, min(len(lines), 12)) if lines[k].strip() == "---"), None)
+        if end is not None:
+            i = end + 1
+    while i < len(lines) and not lines[i].strip():
+        i += 1
+    if i < len(lines) and lines[i].startswith("# "):
+        i += 1
+    return i
+
+
+def passages_for(corpus: Corpus, docs: list[Document], budget_chars: int | None = None) -> list[str]:
     """One string per post: a header line then `n| text` numbered lines (same numbering as read()).
     The budget is split evenly, so one long post cannot crowd out the rest."""
     corpus.sync()
+    budget_chars = budget_chars or settings.artifact_passage_budget
     per_doc = max(budget_chars // max(len(docs), 1), 1500)
     out = []
     for d in docs:
@@ -40,8 +57,9 @@ def passages_for(corpus: Corpus, docs: list[Document], budget_chars: int = DEFAU
         except CorpusError:
             continue
         body, used = [], 0
+        first = _body_start(lines)  # lines keep their number in the file, so a cited line is still the right one
         for n, line in enumerate(lines, start=1):
-            if not line.strip():
+            if n <= first or not line.strip():
                 continue
             entry = f"{n}| {line}"
             if used + len(entry) > per_doc:

backend/app/pipeline/quiz.py

@@ -4,10 +4,12 @@ import uuid
 
 from sqlalchemy.orm import Session
 
+from app.config import settings
 from app.llm import run
 from app.llm.provider import fast_lm
 from app.llm.signatures import GenerateQuiz
 from app.models import Artifact, Job
+from app.pipeline import idea_pool
 from app.pipeline.generate import NothingToDo
 from app.pipeline.material import Material, load_material
 from app.services.jobs import update_job
@@ -51,12 +53,14 @@ def make_questions(db: Session, workspace_id: uuid.UUID, material: Material, *,
                    language: str = SAME_LANGUAGE, job: Job | None = None) -> list[dict]:
     """Playable questions about the material (fewer than `count` when the model gave unusable ones)."""
     types = [t for t in types or [] if t in QUESTION_TYPES] or list(QUESTION_TYPES[:2])
-    out = run.predict(GenerateQuiz, db=db, workspace_id=workspace_id, job=job, title=material.title,
-                      material=material.text, topic=topic or "(none)", difficulty=difficulty, question_types=types,
-                      count=count, language=language.strip() or SAME_LANGUAGE, lm=fast_lm())
-    cleaned = [c for q in out.get("questions") or [] if (c := _clean(q, material.refs))]
     # A multiple select with a single right answer was turned into a multiple choice: fine when that was asked for too.
     allowed = set(types) | ({"multiple_choice"} if "multiple_select" in types else set())
+    inputs = dict(title=material.title, topic=topic or "(none)", difficulty=difficulty, question_types=types,
+                  language=language.strip() or SAME_LANGUAGE)
+    # Many posts: one call over a random sample of the ideas already extracted from them (idea_pool), not the posts' text.
+    text = idea_pool.sample(db, workspace_id, material.docs, topic, chats=material.text) if material.mode == "ideas" else material.text
+    out = run.predict(GenerateQuiz, db=db, workspace_id=workspace_id, job=job, material=text, count=count, lm=fast_lm(), **inputs)
+    cleaned = [c for q in out.get("questions") or [] if (c := _clean(q, material.refs))]
     return [c for c in cleaned if c["type"] in allowed][:count]
 
 
@@ -66,7 +70,8 @@ def build_quiz(db: Session, job: Job, artifact: Artifact) -> dict:
     count = QUESTION_COUNTS.get(params.get("count") or "standard", QUESTION_COUNTS["standard"])
     difficulty = params.get("difficulty") if params.get("difficulty") in DIFFICULTIES else "medium"
     topic = (params.get("topic") or "").strip()
-    material = load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="quiz")
+    material = load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="quiz", large_ok=True,
+                             passage_budget=settings.artifact_quiz_passage_budget)
     update_job(db, job, progress=0.4, message="Writing the questions")
     questions = make_questions(db, artifact.workspace_id, material, topic=topic, difficulty=difficulty, types=types,
                                count=count, language=params.get("language") or SAME_LANGUAGE, job=job)

backend/app/pipeline/report.py

@@ -1,42 +1,46 @@
 """Reports: a written document (or an interactive one, with visuals) made from a notebook's posts or chats.
 
 Every report is stored as `blocks`, even a plain document (a few prose blocks), so the same page can show, extend and
-share either kind. Each block is {"id", "type", ...}: `prose` has Markdown `text` whose [n] markers point into the
-report's `citations`."""
+share either kind. Each block is {"id", "type", ...}: `prose` has Markdown `text`. A report cites nothing: it carries the
+list of the posts it was made from (`sources`) and the instructions it was written to (`instructions`), which the page shows
+together in a drop-down. (`citations` stays in the content, empty, for the older reports that have them.)"""
 
 import logging
 import re
+import time
 import uuid
+from dataclasses import dataclass, field
 
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from app.config import settings
+from app.corpus import Corpus
 from app.infographics.themes import theme_id
 from app.llm import run
-from app.llm.provider import fast_lm, report_lm
+from app.llm.provider import report_lm, report_section_lm
 from app.llm.signatures import (
     PlanInteractiveReport,
-    SuggestEmbeds,
     WriteReport,
     WriteReportSection,
+    WriteThemedReport,
+    WriteThemedSection,
 )
-from app.models import Artifact, Job
+from app.models import Artifact, Document, Job, Notebook
+from app.pipeline import report_blueprint, report_evidence, report_themes
 from app.pipeline.flashcards import make_cards
 from app.pipeline.generate import NothingToDo, mind_map_content
 from app.pipeline.material import Material, load_material
-from app.pipeline.passages import as_citations
 from app.pipeline.quiz import make_questions
-from app.pipeline.research import verify_citations
 from app.services.artifacts import start_artifact
 from app.services.jobs import update_job
 from app.services.renderer import PermanentJobError
 from app.services.report_templates import default_instructions
 
-SUGGEST_KINDS = ("mind_map", "flashcards", "quiz", "infographic")  # what the AI suggests for a document report
-EMBED_KINDS = SUGGEST_KINDS  # every visual a reader can add with one click
+EMBED_KINDS = ("mind_map", "flashcards", "quiz", "infographic")  # every visual a reader can add with one click
 MAX_PLANNED_VISUALS = 4  # suggestions an interactive report's plan can make
 MAX_SECTIONS = 8
 SAME_LANGUAGE = "the same language as the sources"  # no language picked: write as the material is written
-MAX_SUGGESTIONS = 4
 BLOCK_CARDS, BLOCK_QUESTIONS = 8, 5  # a visual inside a report is a taste of the full thing
 
 log = logging.getLogger(__name__)
@@ -46,7 +50,6 @@ MARKER = re.compile(r"\s*\[\d+\](?:\[\d+\])*")
 
 QUIZ_HEADING = re.compile(r"\b(quiz|test yourself|check your understanding|practice questions|review questions|self[- ]?check)\b", re.I)
 FLASHCARD_HEADING = re.compile(r"\bflash ?cards?\b", re.I)
-ASKED_FOR_VISUAL = re.compile(r"\b(quiz|flash ?cards?|practice questions)\b", re.I)
 
 
 def visual_kind(heading: str) -> str | None:
@@ -62,24 +65,6 @@ MOVED_BRIEF = {"quiz": "Check understanding of the key ideas in this report.",
                "flashcards": "Learn the key terms and facts from this report."}
 
 
-def pull_visual_sections(blocks: list[dict], kinds: list[str]) -> tuple[list[dict], list[dict]]:
-    """A section written as a quiz or flashcards is not part of the text: it is taken out and offered as a suggestion
-    after the section before it, for the reader to add. Never takes out every section."""
-    kept: list[dict] = []
-    moved: list[tuple[int, str]] = []
-    for b in blocks:
-        first = b["text"].split("\n", 1)[0] if b["type"] == "prose" else ""
-        kind = visual_kind(first.lstrip("# ").strip()) if first.startswith("#") else None
-        if kind and kind in kinds and kept:
-            moved.append((len(kept) - 1, kind))
-        else:
-            kept.append(b)
-    number_blocks(kept)
-    return kept, [{"id": f"s{i}", "after_block_id": kept[idx]["id"], "kind": kind, "brief": MOVED_BRIEF[kind],
-                   "why": "Offered here for you to add, not written into the text."}
-                  for i, (idx, kind) in enumerate(moved, start=1)]
-
-
 def merge_suggestions(*groups: list[dict]) -> list[dict]:
     """Suggestions from several places, one per section and kind, renumbered."""
     seen, out = set(), []
@@ -92,6 +77,36 @@ def merge_suggestions(*groups: list[dict]) -> list[dict]:
     return out[:MAX_PLANNED_VISUALS + 2]
 
 
+FALLBACK_BRIEFS = {
+    "infographic": ("A one page picture of the main ideas of this report.", "A quick picture of the whole report."),
+    "flashcards": (MOVED_BRIEF["flashcards"], "Cards to learn the key terms and facts."),
+    "quiz": (MOVED_BRIEF["quiz"], "A short quiz to check understanding."),
+    "mind_map": ("How the main ideas of this report connect.", "See how the ideas fit together."),
+}
+MIN_SUGGESTIONS = 3  # a report always offers at least this many visuals (fewer only when fewer kinds are allowed)
+
+
+def fill_suggestions(suggestions: list[dict], blocks: list[dict], kinds: list[str]) -> list[dict]:
+    """An interactive report always offers something to add (a document never does). Whatever the plan or the writer suggested is
+    kept; then an infographic is added if there is none, and flashcards, a quiz and a mind map in turn until there are
+    MIN_SUGGESTIONS, each after a different section. Plain code, so it never depends on the model remembering to suggest."""
+    prose = [b for b in blocks if b.get("type") == "prose"]
+    if not prose:
+        return suggestions
+    inner = prose[1:-1] or prose  # not the introduction or the summary, when there are others
+    place = {"infographic": inner[-1]["id"], "flashcards": inner[0]["id"], "quiz": inner[len(inner) // 2]["id"],
+             "mind_map": prose[0]["id"]}
+    out = list(suggestions)
+    have = {s["kind"] for s in out}
+    for kind in ("infographic", "flashcards", "quiz", "mind_map"):
+        if kind in kinds and kind not in have and (kind == "infographic" or len(out) < MIN_SUGGESTIONS):
+            brief, why = FALLBACK_BRIEFS[kind]
+            out.append({"id": "", "after_block_id": place[kind], "kind": kind, "brief": brief, "why": why})
+            have.add(kind)
+            log.info("report: no %s suggested by the plan, offering one after %s", kind, place[kind])
+    return out
+
+
 def split_prose(markdown: str) -> list[dict]:
     """Markdown cut into prose blocks at each "## " heading, so a block is one section and can be followed by a visual."""
     parts = re.split(r"(?m)^(?=## )", markdown.strip())
@@ -108,81 +123,29 @@ def number_blocks(blocks: list[dict]) -> list[dict]:
     return blocks
 
 
-def citation_rows(cites, material: Material) -> list[dict]:
-    by_path = {d.path: d for d in material.docs}
-    return [{"marker": c.marker, "path": c.path, "line_start": c.line_start, "line_end": c.line_end,
-             "span": c.quote, "title": by_path[c.path].title, "url": by_path[c.path].url,
-             "document_id": str(by_path[c.path].id)}
-            for c in cites if c.path in by_path]
+def source_rows(material: Material) -> list[dict]:
+    """The posts a report was made from, for its Sources list: titles and the posts' own web addresses."""
+    return source_rows_for(material.docs)
 
 
-def source_rows(material: Material) -> list[dict]:
-    """Where the report came from, for the public page's Sources button: titles and the posts' own web addresses."""
-    return [{"title": d.title, "url": d.url, "document_id": str(d.id)} for d in material.docs]
+def source_rows_for(docs: list[Document]) -> list[dict]:
+    return [{"title": d.title, "url": d.url, "document_id": str(d.id)} for d in docs]
 
 
 def write_document(db: Session, workspace_id: uuid.UUID, job: Job | None, material: Material, instructions: str,
-                   language: str) -> tuple[str, str, list[dict]]:
-    """(title, Markdown, citation rows) for a written report. Citations are checked against the posts' lines and
-    renumbered 1..n; a chat has none, so any marker the model wrote is removed."""
+                   language: str) -> tuple[str, str]:
+    """(title, Markdown) for a written report. Nothing is cited; a marker the model wrote anyway is removed."""
     out = run.predict(WriteReport, db=db, workspace_id=workspace_id, job=job, lm=report_lm(), title=material.title,
                       material=material.text, request=instructions, language=language)
     markdown = (out.get("markdown") or "").strip()
     if not markdown:
         raise NothingToDo("The report came back empty. Try again, or describe it differently.")
-    if material.tools is None:
-        return (out.get("report_title") or material.title).strip(), MARKER.sub("", markdown), []
-    text, cites = verify_citations(material.tools, markdown, as_citations(out.get("citations")))
-    return (out.get("report_title") or material.title).strip(), text, citation_rows(cites, material)
-
-
-def allowed_kinds(material_or_source: Material | dict) -> list[str]:
-    """Which visuals fit this source: a mind map is drawn from posts' stored ideas, so a chat gets cards and a quiz."""
-    has_posts = bool(material_or_source.docs) if isinstance(material_or_source, Material) \
-        else bool(material_or_source.get("document_ids"))
-    return [k for k in SUGGEST_KINDS if k != "mind_map" or has_posts]
-
-
-def suggest_embeds(db: Session, workspace_id: uuid.UUID, job: Job | None, blocks: list[dict],
-                   kinds: list[str]) -> list[dict]:
-    """Up to MAX_SUGGESTIONS places for a visual: after which section, what kind, what it covers, why. Never fails
-    the report: no suggestions is a fine answer."""
-    sections = []
-    for b in blocks:
-        if b["type"] != "prose":
-            continue
-        first, _, rest = b["text"].partition("\n")
-        heading = first.lstrip("# ").strip() if first.startswith("#") else ""
-        start = re.sub(r"\s+", " ", rest or first)[:240]
-        sections.append(f"{b['id']} | {heading or 'Introduction'}: {start}")
-    if len(sections) < 2:
-        return []
-    try:
-        out = run.predict(SuggestEmbeds, db=db, workspace_id=workspace_id, job=job, lm=fast_lm(), sections=sections,
-                          allowed_kinds=kinds)
-    except Exception:
-        return []
-    ids = {b["id"] for b in blocks}
-    taken: set[tuple[str, str]] = {(b.get("after") or "", b["type"]) for b in blocks if b["type"] != "prose"}
-    found = []
-    for s in out.get("suggestions") or []:
-        key = (s.get("after_block_id"), s.get("kind"))
-        if s.get("after_block_id") not in ids or s.get("kind") not in kinds or key in taken or not (s.get("brief") or "").strip():
-            continue
-        taken.add(key)
-        found.append({"id": f"s{len(found) + 1}", "after_block_id": s["after_block_id"], "kind": s["kind"],
-                      "brief": s["brief"].strip()[:300], "why": (s.get("why") or "").strip()[:300]})
-    return found[:MAX_SUGGESTIONS]
-
-
-def shift_markers(text: str, offset: int) -> str:
-    """[n] markers renumbered to [n + offset], so sections written apart share one citation list."""
-    return re.sub(r"\[(\d+)\]", lambda m: f"[{int(m.group(1)) + offset}]", text) if offset else text
+    return (out.get("report_title") or material.title).strip(), MARKER.sub("", markdown)
 
 
 def write_interactive(db: Session, workspace_id: uuid.UUID, job: Job, material: Material, instructions: str,
-                      language: str) -> tuple[str, list[dict], list[dict], list[dict]] | None:
-    """(title, blocks, citation rows, suggestions) for an interactive report: a plan of sections, each written on its
+                      language: str) -> tuple[str, list[dict], list[dict]] | None:
+    """(title, blocks, suggestions) for an interactive report: a plan of sections, each written on its
     own (in parallel). The plan also says where a visual would fit; those spots come back as suggestions, and nothing
     is built until the reader clicks Add. None when planning fails, so the caller can write a plain document."""
     kinds = [k for k in EMBED_KINDS if k != "mind_map" or not material.is_chat]
@@ -219,21 +182,13 @@ def write_interactive(db: Session, workspace_id: uuid.UUID, job: Job, material:
         db=db, workspace_id=workspace_id, lm=report_lm())
 
     blocks: list[dict] = []
-    citations: list[dict] = []
     suggestions: list[dict] = []
     used_kinds: set[str] = set()
     anchor: dict[int, str] = {}  # planned section number -> the block it became
     for n, (sec, out) in enumerate(zip(sections, written, strict=True)):
-        body = ((out or {}).get("markdown") or "").strip()
+        body = MARKER.sub("", ((out or {}).get("markdown") or "").strip())
         if not body:
             continue
-        if material.tools is None:
-            body = MARKER.sub("", body)
-        else:
-            body, cites = verify_citations(material.tools, body, as_citations((out or {}).get("citations")))
-            offset = len(citations)
-            body = shift_markers(body, offset)
-            citations += [{**c, "marker": c["marker"] + offset} for c in citation_rows(cites, material)]
         block = {"type": "prose", "text": f"## {sec['heading'].strip()}\n\n{body}"}
         blocks.append(block)
         number_blocks(blocks)
@@ -252,7 +207,275 @@ def write_interactive(db: Session, workspace_id: uuid.UUID, job: Job, material:
         suggestions.append({"id": "", "after_block_id": after, "kind": kind,
                             "brief": (sec.get("brief") or MOVED_BRIEF[kind]).strip()[:300],
                             "why": "Offered here for you to add, not written into the text."})
-    return report_title, blocks, citations, merge_suggestions(suggestions)
+    return report_title, blocks, merge_suggestions(fill_suggestions(suggestions, blocks, kinds))
+
+
+# A report built around themes (report_themes.py, report_blueprint.py, report_evidence.py)
+
+EVIDENCE_TOTAL = 100_000  # characters of evidence in all for a report written in one piece (about 25k tokens)
+DIGEST_CHARS = 300  # of each written section, for the introduction and the summary that are written after them
+
+
+@dataclass
+class Themed:
+    title: str
+    blocks: list[dict]
+    suggestions: list[dict]
+    source: dict
+    sources: list[dict]
+    plan: dict
+    failed: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ThemedRun:
+    """What the steps of a themed report share."""
+    db: Session
+    workspace_id: uuid.UUID
+    job: Job
+    docs: list[Document]
+    corpus: Corpus
+    bp: report_blueprint.Blueprint
+    themes: list[report_themes.Theme]
+    instructions: str
+    language: str
+    title: str
+
+    @property
+    def by_id(self) -> dict[str, report_themes.Theme]:
+        return {t.id: t for t in self.themes}
+
+    def names(self, s: report_blueprint.Section) -> list[str]:
+        by_id = self.by_id
+        return [by_id[i].name for i in s.theme_ids if i in by_id]
+
+    def sections_info(self) -> list[dict]:
+        return [{"heading": s.heading, "role": s.role, "depth": s.depth, "theme_ids": s.theme_ids, "must_cover": s.must_cover}
+                for s in self.bp.sections]
+
+    def finish(self, title: str, blocks: list[dict], suggestions: list[dict], used_posts: list[str],
+               failed: list[str]) -> Themed:
+        """The Sources list is every post the report was made from: the ones read as written and the ones summarised."""
+        used = [d for d in self.docs if d.path in set(used_posts)] or self.docs
+        log.info("report sources: job=%s posts_total=%d posts_used=%d", self.job.id, len(self.docs), len(used))
+        plan = {"planner": "themes", "storyline": self.bp.storyline, "posts_total": len(self.docs), "posts_used": len(used),
+                "themes": [report_themes.theme_summary(t) for t in self.themes], "sections": self.sections_info(),
+                "connections": self.bp.connections}
+        return Themed(title=title, blocks=blocks, suggestions=suggestions, plan=plan, failed=failed,
+                      source={"kind": "posts", "document_ids": [str(d.id) for d in self.docs], "count": len(self.docs),
+                              "read": len(used), "total": len(self.docs)},
+                      sources=source_rows_for(used))
+
+
+def themed_docs(db: Session, artifact: Artifact, params: dict) -> list[Document]:
+    """The posts a themed report would read, or [] when the report is made the usual way: chats, a small selection, or the
+    legacy planner."""
+    if settings.report_planner != "themes" or params.get("chat_ids"):
+        log.info("report route: legacy artifact=%s reason=%s", artifact.id,
+                 "chats picked" if params.get("chat_ids") else f"REPORT_PLANNER={settings.report_planner}")
+        return []
+    docs = report_themes.select_docs(db, artifact.workspace_id, artifact.notebook_id, params)
+    if len(docs) <= report_themes.SMALL_SELECTION:
+        log.info("report route: legacy artifact=%s reason=small selection (%d posts, themes need more than %d)", artifact.id,
+                 len(docs), report_themes.SMALL_SELECTION)
+        return []
+    return docs
+
+
+def themed_title(db: Session, artifact: Artifact, params: dict, docs: list[Document]) -> str:
+    """What the report is about, named the way load_material names its source."""
+    nb = db.get(Notebook, artifact.notebook_id) if artifact.notebook_id else None
+    if nb and not params.get("document_ids"):
+        return nb.title
+    return docs[0].title + (f" + {len(docs) - 1} more" if len(docs) > 1 else "")
+
+
+def _digest(markdown: str) -> str:
+    """The start of a written section, for the sections written after it to know what it says."""
+    text = MARKER.sub("", re.sub(r"(?m)^#+\s*", "", markdown))
+    return re.sub(r"\s+", " ", text).strip()[:DIGEST_CHARS]
+
+
+def _section_header(n: int, s: report_blueprint.Section, names: list[str]) -> str:
+    return (f"SECTION {n}: {s.heading} (role: {s.role}, depth: {s.depth})\nSays: {s.brief}\n"
+            f"Must cover: {'; '.join(s.must_cover) or '(see what it says)'}\nThemes: {', '.join(names) or '(the whole report)'}")
+
+
+def _section_input(ctx: ThemedRun, s: report_blueprint.Section, evidence: list[str]) -> dict:
+    """Everything WriteThemedSection is given. What every section shares comes first in the signature."""
+    must = list(s.must_cover)
+    if s.role == "summary" and ctx.names(s):
+        must.append(f"Restate the main points about: {', '.join(ctx.names(s))}")
+    return {"storyline": ctx.bp.storyline, "outline": report_blueprint.outline(ctx.bp),
+            "connections": report_blueprint.connection_lines(ctx.bp, ctx.themes), "request": ctx.instructions,
+            "language": ctx.language, "heading": s.heading, "role": s.role, "depth": s.depth, "brief": s.brief,
+            "must_cover": must, "covered_elsewhere": s.covered_elsewhere,
+            "bridges": report_blueprint.connection_lines(ctx.bp, ctx.themes, s.heading), "evidence": evidence}
+
+
+def _write_sections(ctx: ThemedRun, inputs: list[dict]) -> list[dict | None]:
+    """WriteThemedSection for each input, together; one that failed or came back empty gets one more try (another temperature)."""
+    kw = {"db": ctx.db, "workspace_id": ctx.workspace_id}
+    started = time.monotonic()
+    outs = run.predict_many(WriteThemedSection, inputs, lm=report_section_lm(), **kw)
+    again = [k for k, o in enumerate(outs) if not ((o or {}).get("markdown") or "").strip()]
+    log.info("report sections written: asked=%d ok=%d failed=%d seconds=%.1f", len(inputs), len(inputs) - len(again), len(again),
+             time.monotonic() - started)
+    if again:
+        log.warning("report sections failed, trying again: %s", [inputs[k]["heading"] for k in again])
+        redo = run.predict_many(WriteThemedSection, [inputs[k] for k in again], lm=report_section_lm(retry=True), **kw)
+        for k, o in zip(again, redo, strict=True):
+            outs[k] = o
+        gone = [inputs[k]["heading"] for k in again if not ((outs[k] or {}).get("markdown") or "").strip()]
+        log.info("report sections retried: asked=%d recovered=%d still_failed=%s", len(again), len(again) - len(gone), gone)
+    return outs
+
+
+def _themed_document(ctx: ThemedRun) -> Themed | None:
+    """The whole report in one piece: the plan and every section's evidence go to one writer, so one voice writes it all."""
+    budgets = report_evidence.scale_budgets(ctx.bp.sections, EVIDENCE_TOTAL)
+    parts: list[str] = []
+    used: list[str] = []
+    for n, s in enumerate(ctx.bp.sections, start=1):
+        head = _section_header(n, s, ctx.names(s))
+        if s.role in ("body", "synthesis"):
+            ev = report_evidence.build(ctx.corpus, s, ctx.by_id, budgets.get(s.heading))
+            used += ev.posts
+            if ev.blocks:
+                head += "\nEvidence:\n" + "\n\n".join(ev.blocks)
+        parts.append(head)
+    report_themes.progress(ctx.db, ctx.job, 0.5, "Writing the report")
+    log.info("report document: writing in one piece sections=%d evidence_chars=%d (budget %d) posts_used=%d", len(parts),
+             sum(len(p) for p in parts), EVIDENCE_TOTAL, len(set(used)))
+    started = time.monotonic()
+    out = run.predict(WriteThemedReport, db=ctx.db, workspace_id=ctx.workspace_id, job=ctx.job, lm=report_lm(),
+                      title=ctx.title, storyline=ctx.bp.storyline, request=ctx.instructions, language=ctx.language,
+                      connections=report_blueprint.connection_lines(ctx.bp, ctx.themes), sections=parts)
+    markdown = MARKER.sub("", (out.get("markdown") or "").strip())
+    if not markdown:
+        log.warning("report document came back empty, reading the posts instead")
+        return None
+    log.info("report document written: chars=%d seconds=%.1f", len(markdown), time.monotonic() - started)
+    return ctx.finish((out.get("report_title") or ctx.bp.title).strip(), number_blocks(split_prose(markdown)), [], used, [])
+
+
+def _themed_interactive(ctx: ThemedRun, moved: list[tuple[report_blueprint.Section, str, report_blueprint.Section]]) -> Themed | None:
+    """Wave 1: the body sections together, each given the storyline, the outline, what the others cover and only its own
+    evidence. Wave 2: the introduction and the summary, written from what wave 1 produced."""
+    sections = ctx.bp.sections
+    body = [(n, s) for n, s in enumerate(sections) if s.role in ("body", "synthesis")]
+    frame = [(n, s) for n, s in enumerate(sections) if s.role in ("intro", "summary")]
+    used: list[str] = []
+    inputs = []
+    for _, s in body:
+        ev = report_evidence.build(ctx.corpus, s, ctx.by_id)
+        used += ev.posts
+        inputs.append(_section_input(ctx, s, ev.blocks))
+    report_themes.progress(ctx.db, ctx.job, 0.45, f"Writing {len(body)} sections")
+    log.info("report wave 1: body sections=%d evidence_chars=%s", len(body), [sum(len(b) for b in i["evidence"]) for i in inputs])
+    written: dict[int, dict] = {}
+    for (n, _), out in zip(body, _write_sections(ctx, inputs), strict=True):
+        if ((out or {}).get("markdown") or "").strip():
+            written[n] = out
+    if not written:
+        log.warning("report wave 1 wrote nothing, reading the posts instead")
+        return None
+    digests = [f"{s.heading}: {_digest(written[n]['markdown'])}" for n, s in body if n in written]
+    report_themes.progress(ctx.db, ctx.job, 0.8, "Writing the introduction and summary")
+    log.info("report wave 2: intro/summary sections=%d digests=%d", len(frame), len(digests))
+    for (n, _), out in zip(frame, _write_sections(ctx, [_section_input(ctx, s, digests) for _, s in frame]), strict=True):
+        if ((out or {}).get("markdown") or "").strip():
+            written[n] = out
+
+    blocks: list[dict] = []
+    suggestions: list[dict] = []
+    anchor: dict[int, str] = {}
+    used_kinds: set[str] = set()
+    for n, s in enumerate(sections):
+        out = written.get(n)
+        if not out:
+            continue
+        blocks.append({"type": "prose", "text": f"## {s.heading}\n\n{MARKER.sub('', out['markdown'].strip())}"})
+        number_blocks(blocks)
+        anchor[id(s)] = blocks[-1]["id"]
+        embed = s.embed
+        if embed and len(suggestions) < MAX_PLANNED_VISUALS and embed.get("kind") in EMBED_KINDS \
+                and embed["kind"] not in used_kinds and (embed.get("brief") or "").strip():
+            used_kinds.add(embed["kind"])
+            suggestions.append({"id": f"s{len(suggestions) + 1}", "after_block_id": blocks[-1]["id"], "kind": embed["kind"],
+                                "brief": embed["brief"].strip()[:300], "why": (embed.get("why") or "").strip()[:300]})
+    for after, kind, sec in moved:
+        suggestions.append({"id": "", "after_block_id": anchor.get(id(after)) or blocks[0]["id"], "kind": kind,
+                            "brief": (sec.brief or MOVED_BRIEF[kind]).strip()[:300],
+                            "why": "Offered here for you to add, not written into the text."})
+    failed = [s.heading for n, s in enumerate(sections) if n not in written]
+    if failed:
+        log.warning("report sections left out after a retry: %s", failed)
+    log.info("report interactive written: blocks=%d suggestions=%d moved_to_suggestions=%d failed=%d", len(blocks),
+             len(suggestions), len(moved), len(failed))
+    suggestions = fill_suggestions(suggestions, blocks, list(EMBED_KINDS))
+    return ctx.finish(ctx.bp.title, blocks, merge_suggestions(suggestions), used, failed)
+
+
+def write_themed(db: Session, workspace_id: uuid.UUID, job: Job, docs: list[Document], title: str, instructions: str,
+                 language: str, interactive: bool) -> Themed | None:
+    """The report from the posts' themes: group their stored ideas into weighted themes, plan the whole report, build each
+    section's evidence from several posts, then write. A document is written in one piece from the plan; an interactive report
+    section by section, each knowing the storyline, the outline and what the others cover, with the introduction and the
+    summary written last from what the sections say. None when any step cannot be done (too few ideas, no usable plan, nothing
+    written), so the caller reads the posts as a report always did. Never makes a report fail."""
+    started = time.monotonic()
+    log.info("themed report starting: job=%s workspace=%s format=%s posts=%d language=%r", job.id, workspace_id,
+             "interactive" if interactive else "document", len(docs), language)
+    try:
+        report_themes.progress(db, job, 0.05, f"Reading {len(docs)} posts")
+        report_themes.ensure_ideas(db, job, workspace_id, docs)
+        share = report_themes.fresh_share(docs)
+        if share < report_themes.MIN_FRESH_SHARE:
+            log.warning("themed report not possible, reading the posts instead: job=%s only %.0f%% of %d posts have ideas "
+                        "(need %.0f%%)", job.id, share * 100, len(docs), report_themes.MIN_FRESH_SHARE * 100)
+            return None
+        corpus = Corpus(workspace_id)
+        corpus.sync()
+        ideas = report_themes.collect_ideas(docs, corpus)
+        report_themes.progress(db, job, 0.2, f"Finding the themes in {len(docs)} posts")
+        themes, relations = report_themes.group_themes(db, job, workspace_id, title, instructions, ideas)
+        report_themes.progress(db, job, 0.3, "Planning the report")
+        kinds = list(EMBED_KINDS) if interactive else []
+        bp = report_blueprint.plan_blueprint(db, job, workspace_id, title, instructions, themes, relations, kinds, language)
+        log.info("themed report planned: job=%s themes=%d sections=%d seconds=%.1f", job.id, len(themes), len(bp.sections),
+                 time.monotonic() - started)
+        moved: list[tuple[report_blueprint.Section, str, report_blueprint.Section]] = []
+        if interactive:  # a planned section that is really a quiz or flashcards is a suggestion, not text
+            kept: list[report_blueprint.Section] = []
+            for s in bp.sections:
+                kind = visual_kind(s.heading)
+                if kind and kept:
+                    log.info("report section %r is a %s, so it becomes a suggestion after %r", s.heading, kind, kept[-1].heading)
+                    moved.append((kept[-1], kind, s))
+                    if kept[-1].role == "body":  # what the section was about is still said, in the section before it
+                        kept[-1].theme_ids += [i for i in s.theme_ids if i not in kept[-1].theme_ids]
+                else:
+                    kept.append(s)
+            bp.sections = kept
+        if len(bp.sections) < 2:
+            log.warning("themed report not possible, reading the posts instead: job=%s fewer than two sections left", job.id)
+            return None
+        ctx = ThemedRun(db, workspace_id, job, docs, corpus, bp, themes, instructions, language, title)
+        themed = _themed_interactive(ctx, moved) if interactive else _themed_document(ctx)
+        if themed:
+            log.info("themed report done: job=%s posts_total=%d posts_used=%d blocks=%d suggestions=%d failed=%d seconds=%.1f",
+                     job.id, len(docs), themed.plan["posts_used"], len(themed.blocks), len(themed.suggestions),
+                     len(themed.failed), time.monotonic() - started)
+        else:
+            log.warning("themed report wrote nothing, reading the posts instead: job=%s", job.id)
+        return themed
+    except (report_themes.ThemesUnavailable, report_blueprint.BlueprintUnavailable) as exc:
+        log.warning("themed report not possible, reading the posts instead: job=%s reason=%s", job.id, exc)
+    except Exception:
+        db.rollback()
+        log.warning("themed report failed, reading the posts instead: job=%s", job.id, exc_info=True)
+    return None
 
 
 def build_report(db: Session, job: Job, artifact: Artifact) -> dict:
@@ -260,30 +483,40 @@ def build_report(db: Session, job: Job, artifact: Artifact) -> dict:
     topic = (params.get("topic") or "").strip()
     language = (params.get("language") or "").strip() or SAME_LANGUAGE
     report_format = "interactive" if params.get("report_format") == "interactive" else "document"
-    material = load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="report")
+    # Posts with ideas stored are read through their themes, however many are picked; chats and small selections as always.
+    docs = themed_docs(db, artifact, params)
+    material = None if docs else load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="report")
+    about = topic or (themed_title(db, artifact, params, docs) if docs else material.title)
     instructions = (params.get("instructions") or "").strip() or default_instructions(
-        report_format, params.get("template_id"), topic or material.title)
-
-    made = write_interactive(db, artifact.workspace_id, job, material, instructions, language) \
-        if report_format == "interactive" else None
-    if made:
-        title, blocks, citations, suggestions = made
+        report_format, params.get("template_id"), about)
+
+    themed = write_themed(db, artifact.workspace_id, job, docs, themed_title(db, artifact, params, docs), instructions, language,
+                          report_format == "interactive") if docs else None
+    log.info("report: job=%s artifact=%s format=%s way=%s", job.id, artifact.id, report_format,
+             "themes" if themed else "legacy (posts read as text)")
+    if themed:
+        extra = {"plan": themed.plan, **({"failed_sections": themed.failed} if themed.failed else {})}
+        title, blocks, suggestions = themed.title, themed.blocks, themed.suggestions
+        source, sources = themed.source, themed.sources
     else:
-        # A document, or an interactive report whose plan came back unusable: write it as one piece. Never a failure.
-        report_format = "document"
-        update_job(db, job, progress=0.3, message="Writing the report")
-        title, markdown, citations = write_document(db, artifact.workspace_id, job, material, instructions, language)
-        blocks = number_blocks(split_prose(markdown))
-        kinds = allowed_kinds(material)
-        pulled: list[dict] = []
-        if not ASKED_FOR_VISUAL.search(instructions):  # a quiz section the reader did not ask for becomes a suggestion
-            blocks, pulled = pull_visual_sections(blocks, kinds)
-        update_job(db, job, progress=0.9, message="Finding places for visuals")
-        suggestions = merge_suggestions(pulled, suggest_embeds(db, artifact.workspace_id, job, blocks, kinds))
+        material = material or load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="report")
+        extra = {}
+        made = write_interactive(db, artifact.workspace_id, job, material, instructions, language) \
+            if report_format == "interactive" else None
+        if made:
+            title, blocks, suggestions = made
+        else:
+            # A document, or an interactive report whose plan came back unusable: write it as one piece. Never a failure.
+            report_format = "document"
+            update_job(db, job, progress=0.3, message="Writing the report")
+            title, markdown = write_document(db, artifact.workspace_id, job, material, instructions, language)
+            blocks = number_blocks(split_prose(markdown))
+            suggestions = []  # visuals are offered in interactive reports only, never in a document
+        source, sources = material.source, source_rows(material)
     artifact.content_json = {
         "title": title, "format": report_format, "template_id": params.get("template_id"),
-        "instructions": instructions, "language": language, "topic": topic, "source": material.source,
-        "blocks": blocks, "suggestions": suggestions, "citations": citations, "sources": source_rows(material),
+        "instructions": instructions, "language": language, "topic": topic, "source": source,
+        "blocks": blocks, "suggestions": suggestions, "suggestions_offered": True, "citations": [], "sources": sources, **extra,
     }
     artifact.status = "ready"
     db.commit()
@@ -308,7 +541,7 @@ def copy_block(kind: str, existing: Artifact) -> dict:
         return {"title": c.get("title"), "questions": c["questions"]}
     if kind == "flashcards" and c.get("cards"):
         return {"title": c.get("title"), "cards": c["cards"]}
-    if kind == "infographic" and existing.storage_key:  # the picture itself is shared, not copied
+    if kind == "infographic" and c.get("content"):  # the picture itself is shared, not copied
         return {"title": c.get("title"), "artifact_id": str(existing.id), "theme": c.get("theme")}
     raise NothingToDo("That one has nothing to add.")
 
@@ -381,6 +614,7 @@ def handle_report_block(db: Session, job: Job) -> dict:
             block = copy_block(kind, existing)
         else:
             block = make_block(db, job, report, kind, (p.get("brief") or "").strip(), p.get("theme"))
+            keep_visual(db, report, {"type": kind, **block})  # a new one also lands in the notebook's Studio list
     except NothingToDo as exc:
         raise PermanentJobError(str(exc)) from exc
     report.content_json = insert_block(report.content_json or {}, {"type": kind, **block}, p.get("after_block_id"),
@@ -389,8 +623,44 @@ def handle_report_block(db: Session, job: Job) -> dict:
     return {"artifact_id": str(report.id)}
 
 
+def keep_visual(db: Session, report: Artifact, block: dict) -> Artifact | None:
+    """A mind map, flashcards or quiz made inside a report would exist only as that block. It is also saved as an
+    artifact of its own in the notebook, so it shows in the Studio list and "use one you already made" offers it
+    again after the block is removed. Content that is already saved is not saved twice."""
+    kind = block.get("type")
+    source = (report.content_json or {}).get("source") or {}
+    if kind == "flashcards" and block.get("cards"):
+        key, content = "cards", {"cards": block["cards"], "card_count": len(block["cards"])}
+    elif kind == "quiz" and block.get("questions"):
+        key, content = "questions", {"questions": block["questions"], "question_count": len(block["questions"])}
+    elif kind == "mind_map" and block.get("root"):
+        key, content = "root", {"root": block["root"], "node_count": block.get("node_count"),
+                                "post_count": block.get("post_count"),
+                                "document_ids": source.get("document_ids") or []}
+    else:
+        return None  # an infographic already is its own artifact
+    same = db.scalars(select(Artifact).where(Artifact.workspace_id == report.workspace_id, Artifact.type == kind,
+                                             Artifact.notebook_id == report.notebook_id))
+    if any((a.content_json or {}).get(key) == content[key] for a in same):
+        return None
+    saved = Artifact(workspace_id=report.workspace_id, notebook_id=report.notebook_id, type=kind, status="ready",
+                     content_json={"title": block.get("title") or kind, "source": source, **content})
+    db.add(saved)
+    db.commit()
+    return saved
+
+
 def remove_block(content: dict, block_id: str) -> dict | None:
-    """The content without that visual (prose cannot be removed), or None when there is no such visual."""
+    """The content without that visual (prose cannot be removed), with the offer to add it again restored, or None
+    when there is no such visual."""
     blocks = list(content.get("blocks") or [])
-    keep = [b for b in blocks if not (b["id"] == block_id and b["type"] != "prose")]
-    return None if len(keep) == len(blocks) else {**content, "blocks": keep}
+    removed = next((b for b in blocks if b["id"] == block_id and b["type"] != "prose"), None)
+    if not removed:
+        return None
+    keep = [b for b in blocks if b["id"] != block_id]
+    suggestions = list(content.get("suggestions") or [])
+    kind = removed["type"]
+    if kind in FALLBACK_BRIEFS and not any(s["kind"] == kind for s in suggestions):
+        brief, why = FALLBACK_BRIEFS[kind]
+        suggestions.append({"id": "", "after_block_id": removed.get("after"), "kind": kind, "brief": brief, "why": why})
+    return {**content, "blocks": keep, "suggestions": suggestions}

backend/app/routers/artifacts.py

@@ -1,3 +1,4 @@
+import logging
 import re
 import uuid
 from typing import Literal
@@ -10,8 +11,9 @@ from app.auth import Ctx, get_ctx
 from app.config import settings
 from app.infographics.image import ImageUnavailable, render_png
 from app.infographics.themes import theme_id
-from app.models import Artifact, CalendarItem, Chat, Document, Job, Notebook, UserSavedVoice
+from app.models import Artifact, ArtifactFeedback, CalendarItem, Chat, Document, Job, Notebook, QuizAttempt, UserSavedVoice
 from app.routers.notebooks import ensure_archive_notebook
+from app.services import artifact_feedback
 from app.services.artifacts import latest_jobs, serialize_artifact, start_artifact
 from app.services.jobs import create_job, serialize_job
 from app.services.plans import effective_plan, plan_limit_error
@@ -25,6 +27,8 @@ from app.slides.build import stored as stored_deck
 from app.slides.build import view as slide_pages
 from app.slides.themes import theme_id as slide_theme_id
 
+log = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/api/artifacts", tags=["artifacts"])
 
 ArtifactType = Literal["summary", "audio_overview", "video", "quote_card", "carousel", "launch_kit", "mind_map", "quiz",
@@ -69,7 +73,8 @@ class GenerateIn(BaseModel):
     question_types: list[Literal["multiple_choice", "multiple_select", "fill_blank", "short_answer"]] = Field(
         default_factory=lambda: ["multiple_choice", "multiple_select"], min_length=1)
     language: str | None = Field(None, max_length=40)
-    theme: str | None = Field(None, max_length=30)  # infographic: app.infographics.themes; slide_deck: app.slides.themes
+    theme: str | None = Field(None, max_length=30)  # infographic: one of the looks (app.infographics.design.LOOKS); slide_deck: app.slides.themes
+    ig_style: str | None = Field(None, max_length=20)  # infographic: the layout to lean towards (design.STYLES), auto when empty
     # slide_deck: read on its own ("detailed") or shown behind a speaker ("presenter"), and how many slides
     deck_format: Literal["detailed", "presenter"] = "detailed"
     deck_length: Literal["short", "default", "long"] = "default"
@@ -166,6 +171,7 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         if body.format == "debate" and body.hosts == 1:
             raise HTTPException(400, "A debate needs two hosts")
         check_limit(ctx.db, ctx.workspace, "audio_minutes", body.minutes)
+        check_limit(ctx.db, ctx.workspace, "audio_overviews", 1)
         ids = body.document_ids or ([body.document_id] if body.document_id else [])
         hosts = _hosts(ctx, body)
         if body.hosts == 1:
@@ -197,7 +203,8 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         check_limit(ctx.db, ctx.workspace, "infographics", 1)
         ids = body.document_ids or ([body.document_id] if body.document_id else [])
         params = {"document_ids": [str(i) for i in ids], "chat_ids": [str(i) for i in body.chat_ids or []],
-                  "theme": theme_id(body.theme), "instructions": (body.instructions or "").strip()[:600]}
+                  "theme": theme_id(body.theme), "style": body.ig_style or "auto",
+                  "instructions": (body.instructions or "").strip()[:600]}
         title = f"Infographic: {params['instructions'][:60] or target}"
     elif body.type == "slide_deck":
         ids = body.document_ids or ([body.document_id] if body.document_id else [])
@@ -257,13 +264,116 @@ def list_artifacts(
     rows = ctx.db.scalars(query.order_by(Artifact.created_at.desc()).offset(max(offset, 0)).limit(min(limit, 200)))
     rows = list(rows.all())
     jobs = latest_jobs(ctx.db, [a.id for a in rows])
-    return {"total": total, "items": [serialize_artifact(a, jobs.get(a.id)) for a in rows]}
+    items = [serialize_artifact(a, jobs.get(a.id)) for a in rows]
+    return {"total": total, "items": artifact_feedback.attach(ctx.db, ctx.user.id, items)}
+
+
+@router.get("/feedback/export")
+def export_artifact_feedback(ctx: Ctx = Depends(get_ctx), rating: Literal["up", "down"] | None = None, type: str | None = None,
+                             limit: int = 200):
+    """The ratings of generated reports, quizzes, flashcards and infographics, newest first, with what each one was, to see
+    which kinds do well and which do not."""
+    q = select(ArtifactFeedback).where(ArtifactFeedback.workspace_id == ctx.workspace.id)
+    if rating:
+        q = q.where(ArtifactFeedback.rating == (1 if rating == "up" else -1))
+    if type:
+        q = q.where(ArtifactFeedback.artifact_type == type)
+    rows = ctx.db.scalars(q.order_by(ArtifactFeedback.updated_at.desc()).limit(min(limit, 1000))).all()
+    log.info("feedback exported: rows=%d rating=%s type=%s user=%s workspace=%s", len(rows), rating, type, ctx.user.id,
+             ctx.workspace.id)
+    return [{"id": str(f.id), "artifact_id": str(f.artifact_id) if f.artifact_id else None, "type": f.artifact_type,
+             "rating": "up" if f.rating > 0 else "down", "reasons": f.reasons, "comment": f.comment, "snapshot": f.snapshot,
+             "rated_at": f.updated_at.isoformat() if f.updated_at else None} for f in rows]
 
 
 @router.get("/{artifact_id}")
 def get_artifact(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
     a = get_artifact_or_404(ctx, artifact_id)
-    return serialize_artifact(a, latest_jobs(ctx.db, [a.id]).get(a.id))
+    _offer_visuals_once(ctx, a)
+    return artifact_feedback.attach(ctx.db, ctx.user.id, [serialize_artifact(a, latest_jobs(ctx.db, [a.id]).get(a.id))])[0]
+
+
+def _offer_visuals_once(ctx: Ctx, a: Artifact) -> None:
+    """An interactive report made before interactive reports always offered visuals gets them the first time it is opened (once: after
+    that, the ones the reader has added or taken away stay as they are). A document report never offers any."""
+    c = a.content_json or {}
+    if a.type != "report" or a.status != "ready" or c.get("format") != "interactive" or c.get("suggestions_offered") \
+            or not c.get("blocks"):
+        return
+    from app.pipeline.report import EMBED_KINDS, fill_suggestions, merge_suggestions
+
+    has_posts = bool((c.get("source") or {}).get("document_ids"))
+    kinds = [k for k in EMBED_KINDS if k != "mind_map" or has_posts]
+    a.content_json = {**c, "suggestions": merge_suggestions(fill_suggestions(list(c.get("suggestions") or []), c["blocks"], kinds)),
+                      "suggestions_offered": True}
+    ctx.db.commit()
+
+
+class FeedbackIn(BaseModel):
+    rating: Literal["up", "down"] | None  # null takes the rating back
+    reasons: list[str] = []
+    comment: str | None = Field(None, max_length=1000)
+
+
+@router.put("/{artifact_id}/feedback")
+def rate_artifact(artifact_id: uuid.UUID, body: FeedbackIn, ctx: Ctx = Depends(get_ctx)):
+    """Thumbs up or down on a finished report, quiz, flashcard set or infographic. Rating again replaces it; null removes it."""
+    a = get_artifact_or_404(ctx, artifact_id)
+    allowed = artifact_feedback.REASONS.get(a.type)
+    if allowed is None or a.status != "ready":
+        log.warning("feedback refused: artifact=%s type=%s status=%s user=%s", a.id, a.type, a.status, ctx.user.id)
+        raise HTTPException(400, "Only a finished report, quiz, flashcard set or infographic can be rated")
+    row = ctx.db.scalar(select(ArtifactFeedback).where(ArtifactFeedback.artifact_id == a.id, ArtifactFeedback.user_id == ctx.user.id))
+    if body.rating is None:
+        if row:
+            ctx.db.delete(row)
+            ctx.db.commit()
+            log.info("feedback removed: artifact=%s type=%s user=%s workspace=%s", a.id, a.type, ctx.user.id, ctx.workspace.id)
+        return {"feedback": None}
+    if not row:
+        row = ArtifactFeedback(workspace_id=ctx.workspace.id, artifact_id=a.id, user_id=ctx.user.id)
+        ctx.db.add(row)
+    row.artifact_type = a.type
+    row.rating = 1 if body.rating == "up" else -1
+    row.reasons = [r for r in dict.fromkeys(body.reasons) if r in allowed] if body.rating == "down" else []
+    row.comment = (body.comment or "").strip() or None
+    row.snapshot = artifact_feedback.snapshot(a)
+    ctx.db.commit()
+    # The comment's text stays out of the logs (it is the user's own words); its length and the reasons are enough.
+    log.info("feedback saved: artifact=%s type=%s rating=%s reasons=%s comment_chars=%d user=%s workspace=%s",
+             a.id, a.type, body.rating, row.reasons, len(row.comment or ""), ctx.user.id, ctx.workspace.id)
+    return {"feedback": artifact_feedback.feedback_out(row)}
+
+
+class AttemptAnswer(BaseModel):
+    choice: list[int] = Field(default_factory=list, max_length=20)
+    text: str = Field("", max_length=2000)
+    correct: bool | None = None
+
+
+class AttemptIn(BaseModel):
+    answers: list[AttemptAnswer] = Field(max_length=200)
+    score: int = Field(ge=0)
+
+
+@router.put("/{artifact_id}/attempt")
+def save_quiz_attempt(artifact_id: uuid.UUID, body: AttemptIn, ctx: Ctx = Depends(get_ctx)):
+    """The person's finished run of a quiz, kept so the result shows when they open it again. Finishing again replaces it."""
+    a = get_artifact_or_404(ctx, artifact_id)
+    if a.type != "quiz" or a.status != "ready":
+        raise HTTPException(400, "Only a finished quiz keeps a result")
+    total = len((a.content_json or {}).get("questions") or [])
+    if len(body.answers) != total:
+        raise HTTPException(400, "The answers do not match the quiz")
+    row = ctx.db.scalar(select(QuizAttempt).where(QuizAttempt.artifact_id == a.id, QuizAttempt.user_id == ctx.user.id))
+    if not row:
+        row = QuizAttempt(workspace_id=ctx.workspace.id, artifact_id=a.id, user_id=ctx.user.id)
+        ctx.db.add(row)
+    row.total = total
+    row.score = min(body.score, total)
+    row.answers = [x.model_dump() for x in body.answers]
+    ctx.db.commit()
+    return {"attempt": artifact_feedback.attempt_out(row)}
 
 
 @router.get("/{artifact_id}/image")

backend/app/routers/notebooks.py

@@ -36,6 +36,7 @@ from app.pipeline.research import Turn, research
 from app.pipeline.trace import ChatTrace, use_trace
 from app.routers.sources import serialize_document
 from app.services.artifacts import latest_jobs, serialize_artifact
+from app.services import report_suggestions
 from app.services.jobs import create_job, record_usage
 from app.services.memory import list_facts, profile_text
 from app.services.storage import storage
@@ -86,6 +87,8 @@ def _add_docs(ctx: Ctx, nb: Notebook, ids: list[uuid.UUID]) -> int:
     fresh = [d for d in ctx.db.scalars(select(Document).where(Document.id.in_(valid - existing))) if not ideas_fresh(d)]
     if fresh and settings.llm_api_key:
         create_job(ctx.db, ctx.workspace.id, "ideas", {"document_ids": [str(d.id) for d in fresh]}, max_attempts=2)
+    if valid - existing:
+        report_suggestions.queue_warmup(ctx.db, ctx.workspace.id)  # the Create report dialog's templates, ready before it is opened
     return len(valid - existing)
 
 
@@ -254,7 +257,9 @@ def notebook_artifacts(notebook_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
         select(Artifact).where(Artifact.notebook_id == nb.id).order_by(Artifact.created_at.desc())
     ).all())
     jobs = latest_jobs(ctx.db, [a.id for a in rows])
-    return [serialize_artifact(a, jobs.get(a.id)) for a in rows]
+    from app.services import artifact_feedback  # the ratings ride along on each artifact the panel lists
+
+    return artifact_feedback.attach(ctx.db, ctx.user.id, [serialize_artifact(a, jobs.get(a.id)) for a in rows])
 
 
 @router.get("/{notebook_id}/chats")

backend/app/routers/reports.py

@@ -7,12 +7,11 @@ from sqlalchemy import select
 
 from app.auth import Ctx, get_ctx
 from app.llm import run
-from app.llm.provider import fast_lm
-from app.llm.signatures import SuggestReportTemplates
 from app.models import Artifact
-from app.pipeline.report import EMBED_KINDS, remove_block
+from app.pipeline.report import EMBED_KINDS, keep_visual, remove_block
 from app.routers.artifacts import get_artifact_or_404
 from app.routers.videos import FocusIn, _focus_material
+from app.services import report_suggestions
 from app.services.artifacts import latest_jobs, serialize_artifact
 from app.services.jobs import create_job
 from app.services.report_templates import INTERACTIVE, TEMPLATES
@@ -20,7 +19,6 @@ from app.services.usage import check_limit
 
 router = APIRouter(prefix="/api/reports", tags=["reports"])
 
-SUGGEST_ITEMS = 5  # sources the AI reads to suggest templates
 
 
 @router.get("/templates")
@@ -35,25 +33,15 @@ class SuggestIn(FocusIn):
 
 @router.post("/suggest")
 def suggest_templates(body: SuggestIn, ctx: Ctx = Depends(get_ctx)):
-    """Four kinds of report these sources could make, each with its own ready-written instructions. Never an error:
-    when the AI has nothing usable the list is empty and the dialog shows only the fixed templates."""
-    material, _docs = _focus_material(ctx, body)
+    """Four kinds of report these sources could make, each with its own ready-written instructions. The AI reads each post's stored
+    ideas and topics (not its text); the answer is kept, so the same sources get it again at once (and it is prepared in the
+    background as soon as ideas are extracted). Never an error: when there is nothing usable the list is empty and the dialog shows
+    only the fixed templates."""
+    material, docs = _focus_material(ctx, body)
     if not material:
         return {"templates": []}
-    try:
-        out = run.predict(SuggestReportTemplates, db=ctx.db, workspace_id=ctx.workspace.id, lm=fast_lm(),
-                          items=list(material.values())[:SUGGEST_ITEMS], topic=(body.topic or "").strip() or "(none)")
-    except Exception:
-        return {"templates": []}
-    seen, found = set(), []
-    for t in out.get("templates") or []:
-        name, prompt = (t.get("name") or "").strip(), (t.get("prompt") or "").strip()
-        if not name or not prompt or name.lower() in seen:
-            continue
-        seen.add(name.lower())
-        found.append({"id": f"suggested-{len(found) + 1}", "name": name[:60],
-                      "description": (t.get("description") or "").strip()[:200], "prompt": prompt[:1500]})
-    return {"templates": found[:4]}
+    items = report_suggestions.suggestion_items(material, docs)
+    return {"templates": report_suggestions.suggest(ctx.db, ctx.workspace.id, items, (body.topic or "").strip())}
 
 
 class AddBlockIn(BaseModel):
@@ -105,9 +93,11 @@ def add_block(artifact_id: uuid.UUID, body: AddBlockIn, ctx: Ctx = Depends(get_c
 @router.delete("/{artifact_id}/blocks/{block_id}")
 def delete_block(artifact_id: uuid.UUID, block_id: str, ctx: Ctx = Depends(get_ctx)):
     a = _report_or_404(ctx, artifact_id)
+    removed = next((b for b in (a.content_json or {}).get("blocks") or [] if b.get("id") == block_id), None)
     content = remove_block(a.content_json or {}, block_id)
     if content is None:
         raise HTTPException(404, "Visual not found")
+    keep_visual(ctx.db, a, removed)
     a.content_json = content
     ctx.db.commit()
     return serialize_artifact(a, latest_jobs(ctx.db, [a.id]).get(a.id))

backend/app/routers/settings.py

@@ -1,14 +1,9 @@
-import re
-
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends
 from pydantic import BaseModel, Field
-from sqlalchemy import select
 
 from app.auth import Ctx, get_ctx
 from app.config import settings as app_settings
-from app.models import Upload
 from app.services.plans import effective_plan, plan_dict
-from app.services.storage import storage
 from app.services.usage import usage_report
 
 router = APIRouter(prefix="/api/settings", tags=["settings"])
@@ -17,24 +12,18 @@ router = APIRouter(prefix="/api/settings", tags=["settings"])
 class SettingsIn(BaseModel):
     name: str | None = Field(None, max_length=200)
     workspace_name: str | None = Field(None, min_length=1, max_length=200)
-    brand_name: str | None = Field(None, max_length=120)
-    brand_accent: str | None = None
-    logo_upload_id: str | None = None  # "" removes the logo
     training_opt_in: bool | None = None
     allow_public_links: bool | None = None
     email_unsubscribed: bool | None = None
 
 
 def _serialize(ctx: Ctx) -> dict:
-    brand = ctx.workspace.brand_json or {}
     return {
         "user": {"name": ctx.user.name, "email": ctx.user.email, "auth_provider": ctx.user.auth_provider.value,
                  "email_unsubscribed": ctx.user.email_unsubscribed},
         "workspace": {"id": str(ctx.workspace.id), "name": ctx.workspace.name,
                       "training_opt_in": ctx.workspace.training_opt_in,
                       "allow_public_links": ctx.workspace.allow_public_links},
-        "brand": {"name": brand.get("name"), "accent": brand.get("accent") or "#217cff",
-                  "logo_url": storage.presign_get(brand["logo_key"]) if brand.get("logo_key") else None},
         "plan": plan_dict(effective_plan(ctx.db, ctx.workspace)),
         "billing_enabled": app_settings.billing_enabled,
         "usage": usage_report(ctx.db, ctx.workspace),
@@ -45,6 +34,15 @@ def _serialize(ctx: Ctx) -> dict:
     }
 
 
+@router.get("/limits")
+def artifact_limits(_ctx: Ctx = Depends(get_ctx)):
+    """How many posts a report or infographic reads, and a dialog ticks to start with (ARTIFACT_MAX_POSTS), so the pickers match the
+    server. A quiz or flashcard set can read as many posts as the plan indexes (selectable_posts)."""
+    from app.pipeline.material import max_posts
+
+    return {"posts": max_posts(), "selectable_posts": effective_plan(_ctx.db, _ctx.workspace).indexed_posts}
+
+
 @router.get("")
 def get_settings(ctx: Ctx = Depends(get_ctx)):
     return _serialize(ctx)
@@ -62,23 +60,6 @@ def update_settings(body: SettingsIn, ctx: Ctx = Depends(get_ctx)):
         ctx.workspace.allow_public_links = body.allow_public_links
     if body.email_unsubscribed is not None:
         ctx.user.email_unsubscribed = body.email_unsubscribed
-    brand = dict(ctx.workspace.brand_json or {})
-    if body.brand_name is not None:
-        brand["name"] = body.brand_name.strip() or None
-    if body.brand_accent is not None:
-        if not re.fullmatch(r"#[0-9a-fA-F]{6}", body.brand_accent):
-            raise HTTPException(422, "Use a hex color like #217cff")
-        brand["accent"] = body.brand_accent.lower()
-    if body.logo_upload_id is not None:
-        if body.logo_upload_id == "":
-            brand.pop("logo_key", None)
-        else:
-            upload = ctx.db.scalar(select(Upload).where(Upload.id == body.logo_upload_id,
-                                                        Upload.workspace_id == ctx.workspace.id))
-            if not upload or upload.status != "complete" or not upload.content_type.startswith("image/"):
-                raise HTTPException(400, "Upload an image first")
-            brand["logo_key"] = upload.key
-    ctx.workspace.brand_json = brand
     ctx.db.commit()
     return _serialize(ctx)
 

backend/app/routers/sources.py

@@ -10,7 +10,7 @@ from app.corpus import INDEX, Corpus, CorpusError
 from app.models import Document, Job, NotebookDocument, Source, Upload
 from app.pipeline.ingest import IMPORTS_FEED, FeedNotFound, discover_feed, imports_source, rebuild_index
 from app.services.jobs import create_job, serialize_job
-from app.services.plans import effective_plan, plan_limit_error
+from app.services.plans import effective_plan, plan_limit_error, post_room
 from app.services.storage import storage
 
 router = APIRouter(prefix="/api/sources", tags=["sources"])
@@ -74,7 +74,7 @@ async def create_source(body: SourceIn, ctx: Ctx = Depends(get_ctx)):
         select(func.count()).select_from(Source)
         .where(Source.workspace_id == ctx.workspace.id, Source.feed_url != IMPORTS_FEED)
     )
-    if count >= plan.sources:
+    if 0 <= plan.sources <= count:
         raise plan_limit_error(plan, "sources", f"Your plan includes {plan.sources} sources.")
     source = Source(workspace_id=ctx.workspace.id, feed_url=found.feed_url, platform=found.platform,
                     site_url=found.site_url, title=found.title)
@@ -135,8 +135,17 @@ def delete_source(source_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
     return {"ok": True, "removed_posts": len(docs)}
 
 
+def _require_room(ctx: Ctx) -> None:
+    """A link or a file adds a post: refused (with the upgrade prompt) once the plan's posts are all indexed."""
+    plan = effective_plan(ctx.db, ctx.workspace)
+    if post_room(ctx.db, ctx.workspace.id, plan) <= 0:
+        raise plan_limit_error(plan, "indexed_posts", f"Your plan indexes up to {plan.indexed_posts} posts, and they are all "
+                                                       "used. Remove a post or upgrade to add more.")
+
+
 @router.post("/url")
 def import_url(body: SourceIn, ctx: Ctx = Depends(get_ctx)):
+    _require_room(ctx)
     source = imports_source(ctx.db, ctx.workspace.id)
     ctx.db.commit()
     job = create_job(ctx.db, ctx.workspace.id, "import_url", {"source_id": str(source.id), "url": body.url})
@@ -148,6 +157,7 @@ def import_upload(body: UploadImportIn, ctx: Ctx = Depends(get_ctx)):
     upload = ctx.db.scalar(select(Upload).where(Upload.id == body.upload_id, Upload.workspace_id == ctx.workspace.id))
     if not upload or upload.status != "complete":
         raise HTTPException(404, "Upload not found or not finished")
+    _require_room(ctx)
     source = imports_source(ctx.db, ctx.workspace.id)
     ctx.db.commit()
     job = create_job(ctx.db, ctx.workspace.id, "import_upload",

backend/app/routers/video_edit.py

@@ -4,7 +4,7 @@
 
 Only paths in RULES pass (anything else is 404). Before forwarding, the video must be this workspace's
 (b2v_access.video_or_404), every template / voice / style id in a JSON body must be this workspace's (check_refs),
-premium (★) features need a paid plan, and AI edits come out of the workspace's own counter (given back if
+AI edits come out of the workspace's own counter (given back if
 blog2video refuses). A template switch also uses one video, as it does on blog2video.
 
 JSON bodies, multipart uploads (images, voiceovers, portraits) and binary answers (downloads, stills) pass through.
@@ -35,8 +35,6 @@ S = r"\d+"  # a scene id
 @dataclass(frozen=True)
 class Rule:
     ai_edits: int = 0  # AI edits this call uses (per workspace, video_limits "ai_edits")
-    per_scene: bool = False  # ai_edits is per scene_ids entry (avatar batches)
-    premium: str | None = None  # ★: what to call it in the upgrade message
     uses_video: bool = False  # a template switch: one video from the allowance
     raw: bool = False  # binary answer (download, still)
     timeout: float = 30
@@ -94,29 +92,12 @@ RULES: list[tuple[str, re.Pattern, Rule]] = [(m, re.compile(f"^{p}$"), r) for m,
     ("GET", "regenerate-script/preview", Rule()),
     ("POST", "regenerate-script/verify", Rule()),
     ("POST", "regenerate-script/regenerate", Rule()),
-    # AI chat editing ★
-    ("POST", "chat", Rule(ai_edits=1, premium="AI chat editing", timeout=120)),
-    ("GET", "chat/history", Rule(premium="AI chat editing")),
-    # Avatars ★ (blog2video charges the whole batch at authorize: 10 AI edits per scene)
-    ("POST", "avatar-batch/authorize", Rule(ai_edits=10, per_scene=True, premium="Avatars")),
-    ("POST", rf"scenes/{S}/avatar", Rule(premium="Avatars")),
-    ("GET", rf"scenes/{S}/avatar-status", Rule()),
-    ("DELETE", rf"scenes/{S}/avatar", Rule()),
-    ("POST", rf"scenes/{S}/avatar-matte", Rule(premium="Avatars")),
-    ("POST", "avatar-matte-all", Rule(premium="Avatars")),
-    ("POST", "avatar-retry-failed", Rule(premium="Avatars")),
-    ("GET", "avatar-progress", Rule()),
-    ("POST", "avatar-portrait", Rule(premium="Avatars", timeout=60)),
-    ("DELETE", "avatar-portrait", Rule()),
-    ("PATCH", rf"scenes/{S}/avatar-focus", Rule()),
-    ("PATCH", rf"scenes/{S}/avatar-appearance", Rule()),
     # Render, download, frames
     ("POST", "render", Rule(status="rendering")),
     ("GET", "render-status", Rule()),
     ("POST", "cancel-render", Rule()),
     ("GET", "download-url", Rule()),
     ("GET", "download", Rule(raw=True, timeout=120)),
-    ("GET", "download-studio", Rule(raw=True, premium="The Remotion source download", timeout=120)),
     ("GET", "render-still", Rule(raw=True, timeout=60)),
     ("POST", "render-stills", Rule(timeout=120)),
 ]]
@@ -157,19 +138,12 @@ async def _read_body(request: Request) -> tuple[dict | None, dict | None, list |
 
 
 def _charge(ctx: Ctx, rule: Rule, body: dict | None, form: dict | None) -> int:
-    """Premium, references and counters, all before blog2video is called. Returns AI edits taken."""
+    """References and counters, all before blog2video is called. Returns AI edits taken."""
     plan = effective_plan(ctx.db, ctx.workspace)
-    if rule.premium:
-        video_limits.require_premium(ctx.db, ctx.workspace, rule.premium, plan)
     refs = body if isinstance(body, dict) else (form or {})
     with upstream():  # checking a template or voice may need blog2video's catalog
         b2v_access.check_refs(ctx, refs, plan)
     edits = rule.ai_edits
-    if rule.per_scene:
-        scenes = (body or {}).get("scene_ids") if isinstance(body, dict) else None
-        if not isinstance(scenes, list) or not scenes:
-            raise HTTPException(400, "Pick at least one scene")
-        edits *= len(scenes)
     if edits:
         video_limits.take(ctx.db, ctx.workspace, "ai_edits", edits, plan=plan)
     if rule.uses_video and not video_quota.reserve(ctx.db, ctx.workspace.id):

backend/app/routers/video_templates.py

@@ -179,7 +179,6 @@ def delete_template(template_id: int, ctx: Ctx = Depends(get_ctx), _: None = Dep
 
 @dataclass(frozen=True)
 class Rule:
-    ai_edit: bool = False  # ★ one AI edit
     metric: str | None = None  # another counter this uses (a lifetime slot, a daily AI step)
     raw: bool = False
 
@@ -190,8 +189,6 @@ RULES: list[tuple[str, re.Pattern, Rule]] = [(m, re.compile(f"^{p}$"), r) for m,
     ("PUT", "", Rule()),
     ("GET", "code", Rule()),
     ("POST", "upload-logo", Rule()),
-    ("POST", f"scenes/{K}/ai-edit", Rule(ai_edit=True)),
-    ("GET", f"scenes/{K}/ai-edit/status", Rule()),
     ("GET", "scene-drafts", Rule()),
     ("GET", f"scenes/{K}/draft", Rule()),
     ("POST", f"scenes/{K}/draft/apply", Rule()),
@@ -214,10 +211,6 @@ def _rule(method: str, path: str) -> Rule | None:
 def _take(ctx: Ctx, rule: Rule) -> list[str]:
     taken: list[str] = []
     try:
-        if rule.ai_edit:
-            plan = video_limits.require_premium(ctx.db, ctx.workspace, "AI template editing")
-            video_limits.take(ctx.db, ctx.workspace, "ai_edits", plan=plan)
-            taken.append("ai_edits")
         if rule.metric:
             video_limits.take(ctx.db, ctx.workspace, rule.metric)
             taken.append(rule.metric)

backend/app/routers/video_voices.py

@@ -1,24 +1,19 @@
-"""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).
+"""Voices for videos: the workspace's saved voices, the free built-in library, and its Notestack voices (made on the Voice
+page; they speak audio overviews, not videos).
 
 "Your voices" (user_saved_voices, as many as wanted) is the one list for audio overviews and videos, and 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).
 """
 
 import logging
-from typing import Literal
 
-from fastapi import APIRouter, Depends, File, Form, HTTPException, Response, UploadFile
+from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel, Field
 from sqlalchemy import select
 
 from app.auth import Ctx, get_ctx
-from app.models import B2VCustomVoice, UserSavedVoice
+from app.models import 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, save_notestack_voice
 
@@ -26,7 +21,6 @@ log = logging.getLogger(__name__)
 
 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
 
 
@@ -36,7 +30,7 @@ def _labels(v: dict) -> 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,
             "source": "notestack" if v.voice_id in ours else "blog2video"}
 
 
@@ -45,7 +39,7 @@ def _library_out(v: dict, saved: set[str]) -> dict:
     return {"voice_id": v["voice_id"], "name": (v.get("name") or "Voice").split(" - ")[0].strip(),
             "description": v.get("description") or labels.get("description") or "", "preview_url": v.get("preview_url"),
             "gender": labels.get("gender"), "accent": labels.get("accent"), "age": labels.get("age"),
-            "premium": v.get("plan") == "paid", "saved": v["voice_id"] in saved}
+            "saved": v["voice_id"] in saved}
 
 
 def _save_builtin(ctx: Ctx, v: dict) -> UserSavedVoice:
@@ -53,37 +47,36 @@ def _save_builtin(ctx: Ctx, v: dict) -> UserSavedVoice:
     row = UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=v["voice_id"],
                          name=(v.get("name") or "Voice").split(" - ")[0].strip()[:255],
                          preview_url=v.get("preview_url"),
-                         gender=labels.get("gender"), accent=labels.get("accent"), premium=v.get("plan") == "paid")
+                         gender=labels.get("gender"), accent=labels.get("accent"))
     ctx.db.merge(row)
     return row
 
 
-def _saved(ctx: Ctx) -> list[UserSavedVoice]:
-    return list(ctx.db.scalars(select(UserSavedVoice).where(UserSavedVoice.workspace_id == ctx.workspace.id)
-                               .order_by(UserSavedVoice.created_at)))
+def _saved(ctx: Ctx, ours: set[str] = frozenset()) -> list[UserSavedVoice]:
+    """The saved voices that can still be used: free built-in voices and the workspace's Notestack voices. Voices that
+    were designed or cloned for videos, and paid built-in ones, are gone."""
+    rows = ctx.db.scalars(select(UserSavedVoice).where(UserSavedVoice.workspace_id == ctx.workspace.id)
+                          .order_by(UserSavedVoice.created_at))
+    return [v for v in rows if v.voice_id in ours or not (v.is_custom or v.premium)]
 
 
 @router.get("")
 def voices(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    """Your voices (audio overviews and videos), the built-in library (to save from) and my custom voices."""
+    """Your voices (audio overviews and videos), the free built-in library (to save from) and your Notestack voices."""
     with upstream():
-        library = b2v.prebuilt_voices()
-    saved = _saved(ctx)
+        library = [v for v in b2v.prebuilt_voices() if v.get("plan") != "paid"]
+    mine = notestack_voices(ctx.db, ctx.workspace.id)
+    ours = {v["voice_id"] for v in mine}
+    saved = _saved(ctx, ours)
     if not saved:
-        for v in [v for v in library if v.get("plan") != "paid" and v.get("voice_id")][:STARTER_VOICES]:
+        for v in [v for v in library if v.get("voice_id")][:STARTER_VOICES]:
             _save_builtin(ctx, v)
         ctx.db.commit()
-        saved = _saved(ctx)
+        saved = _saved(ctx, ours)
     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()))
-    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],
             "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]}
+            "library": [_library_out(v, ids) for v in library if v.get("voice_id")]}
 
 
 class SaveIn(BaseModel):
@@ -94,25 +87,17 @@ class SaveIn(BaseModel):
 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}))
-    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: saved on any plan, premium to use in a video. No preview link (the Voice page plays it).
+        # A Notestack voice: saved on any plan, for audio overviews. No preview link (the Voice page plays it).
         row = save_notestack_voice(ctx.db, ctx.workspace.id, mine["voice_id"], mine["name"])
         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))
-    else:
-        with upstream():
-            v = next((v for v in b2v.prebuilt_voices() if v.get("voice_id") == body.voice_id), None)
-        if not v:
-            raise HTTPException(404, "Voice not found")
-        if v.get("plan") == "paid":
-            video_limits.require_premium(ctx.db, ctx.workspace, "This voice")
-        row = _save_builtin(ctx, v)
+    with upstream():
+        v = next((v for v in b2v.prebuilt_voices() if v.get("voice_id") == body.voice_id), None)
+    if not v or v.get("plan") == "paid":
+        raise HTTPException(404, "Voice not found")
+    row = _save_builtin(ctx, v)
     ctx.db.commit()
     return _voice_out(row)
 
@@ -125,158 +110,3 @@ def unsave_voice(voice_id: str, ctx: Ctx = Depends(get_ctx)):
     ctx.db.delete(row)
     ctx.db.commit()
     return {"ok": True}
-
-
-# Design a voice ★: a description or options -> a few previews; keep one to make it a custom voice
-
-
-class DesignPromptIn(BaseModel):
-    prompt: str = Field(min_length=20, max_length=1000)
-
-
-class DesignPresetIn(BaseModel):
-    gender: str = Field("", max_length=30)
-    age: str = Field("", max_length=30)
-    persona: str = Field("", max_length=100)
-    speed: str = Field("", max_length=30)
-    accent: str = Field("", max_length=60)
-
-
-def _design(ctx: Ctx, path: str, body: dict) -> dict:
-    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Designing a voice")
-    video_limits.take(ctx.db, ctx.workspace, "voice_designs_daily", plan=plan)
-    try:
-        with upstream():
-            data = b2v.request("POST", path, json=body, timeout=90) or {}
-    except HTTPException:
-        video_limits.give_back(ctx.db, ctx.workspace.id, "voice_designs_daily")
-        raise
-    return {"previews": [{k: p.get(k) for k in ("generated_voice_id", "audio_base_64", "media_type", "duration_secs")}
-                         for p in data.get("previews") or []]}
-
-
-@router.post("/design/prompt")
-def design_from_prompt(body: DesignPromptIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    return _design(ctx, "/api/voices/design-from-prompt", body.model_dump())
-
-
-@router.post("/design/preset")
-def design_from_preset(body: DesignPresetIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    return _design(ctx, "/api/voices/design-from-preset", body.model_dump())
-
-
-class KeepIn(BaseModel):
-    generated_voice_id: str = Field(min_length=1, max_length=200)
-    source: Literal["prompt", "preset"]
-    name: str = Field(min_length=1, max_length=100)
-    prompt_text: str | None = Field(None, max_length=1000)
-    preview_url: str | None = Field(None, max_length=1000)
-
-
-def _record_custom(ctx: Ctx, made: dict, source: str) -> dict:
-    row = B2VCustomVoice(b2v_custom_voice_id=int(made["id"]), workspace_id=ctx.workspace.id,
-                         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))  # a new voice is saved
-    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}
-
-
-def _make_custom(ctx: Ctx, source: str, send) -> dict:
-    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Custom voices")
-    video_limits.take(ctx.db, ctx.workspace, "custom_voices", plan=plan)
-    try:
-        with upstream():
-            made = send()
-    except HTTPException:
-        video_limits.give_back(ctx.db, ctx.workspace.id, "custom_voices")
-        raise
-    return _record_custom(ctx, made, source)
-
-
-@router.post("/custom", status_code=201)
-def keep_designed_voice(body: KeepIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    """Keep one designed preview as a permanent custom voice."""
-    payload = {"voice_id": body.generated_voice_id, "source": "prompt" if body.source == "prompt" else "form",
-               "name": body.name, "prompt_text": body.prompt_text, "preview_url": body.preview_url}
-    return _make_custom(ctx, body.source,
-                        lambda: b2v.request("POST", "/api/voices/custom", json=payload, timeout=60))
-
-
-@router.post("/clone", status_code=201)
-async def clone_voice(name: str = Form(..., min_length=1, max_length=100), remove_background_noise: bool = Form(True),
-                      file: UploadFile = File(...), ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    """Clone a voice from one audio or video file (up to 50 MB)."""
-    data = await file.read(CLONE_MAX_BYTES + 1)
-    if not data:
-        raise HTTPException(400, "The file is empty.")
-    if len(data) > CLONE_MAX_BYTES:
-        raise HTTPException(400, "The file must be under 50 MB.")
-    form = {"name": name, "remove_background_noise": "true" if remove_background_noise else "false"}
-    files = {"file": (file.filename or "voice.mp3", data, file.content_type or "application/octet-stream")}
-    return _make_custom(ctx, "clone",
-                        lambda: b2v.request("POST", "/api/voices/clone", data=form, files=files, timeout=180))
-
-
-@router.get("/custom/{custom_id}/preview")
-def custom_preview(custom_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    row = b2v_access.owned_custom_voice(ctx, custom_id)
-    if row.preview_url:
-        return {"preview_url": row.preview_url, "ready": True}
-    with upstream():
-        result = b2v.request("GET", f"/api/voices/custom/{custom_id}/preview") or {}
-    if result.get("preview_url"):
-        row.preview_url = result["preview_url"]
-        saved = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": row.voice_id})
-        if saved:
-            saved.preview_url = row.preview_url
-        ctx.db.commit()
-    return {"preview_url": result.get("preview_url"), "ready": bool(result.get("ready"))}
-
-
-@router.delete("/custom/{custom_id}")
-def delete_custom(custom_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    row = b2v_access.owned_custom_voice(ctx, custom_id)
-    try:
-        with upstream():
-            b2v.request("DELETE", f"/api/voices/custom/{custom_id}")
-    except HTTPException as e:
-        if e.status_code != 404:
-            raise
-    saved = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": row.voice_id})
-    if saved:
-        ctx.db.delete(saved)
-    ctx.db.delete(row)
-    ctx.db.commit()
-    video_limits.give_back(ctx.db, ctx.workspace.id, "custom_voices")
-    return {"ok": True}
-
-
-# Voice sample ★: a few seconds of the chosen voice with the chosen tuning
-
-
-class SampleIn(BaseModel):
-    voice_gender: Literal["female", "male"] = "female"
-    voice_accent: str = Field("american", max_length=30)
-    custom_voice_id: str | None = Field(None, max_length=100)
-    voice_emotion: str | None = Field(None, max_length=200)
-    video_style: str | None = Field(None, max_length=40)
-
-
-@router.post("/sample")
-def voice_sample(body: SampleIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Voice samples")
-    payload = body.model_dump(exclude_none=True)
-    with upstream():  # checking the voice may need blog2video's catalog
-        b2v_access.check_refs(ctx, {k: v for k, v in payload.items() if k != "voice_emotion"}, plan)
-    video_limits.take(ctx.db, ctx.workspace, "voice_samples_daily", plan=plan)
-    try:
-        with upstream():
-            audio, ctype = b2v.request("POST", "/api/voice/preview", json=payload, timeout=60, raw=True)
-    except HTTPException:
-        video_limits.give_back(ctx.db, ctx.workspace.id, "voice_samples_daily")
-        raise
-    return Response(audio, media_type=ctype or "audio/mpeg", headers={"Cache-Control": "no-store"})

backend/app/routers/videos.py

@@ -140,7 +140,7 @@ class VideoOptions(BaseModel):
     # Step 1: Project (script review is always off: blog2video goes straight to the video)
     stock_footage_enabled: bool = True
     aspect_ratio: Literal["landscape", "portrait"] = "landscape"
-    video_length: Literal["short", "medium", "detailed", "more_detailed"] = "short"
+    video_length: Literal["short", "medium"] = "short"
     logo_upload_id: uuid.UUID | None = None  # a file uploaded through /api/storage/uploads
     logo_position: Literal["bottom_right", "bottom_left", "top_left", "top_right"] = "bottom_right"
     logo_opacity: float = Field(0.9, ge=0.1, le=1.0)
@@ -155,7 +155,6 @@ class VideoOptions(BaseModel):
     voice_gender: Literal["female", "male", "none"] = "female"
     voice_accent: str = Field("american", max_length=30)
     custom_voice_id: str | None = Field(None, max_length=100)
-    voice_emotion: str | None = Field(None, max_length=200)  # ["<expressiveness>","<speed>","<emotion>",...]
     bgm_track_id: str | None = Field(None, max_length=100)
     bgm_volume: float = Field(0.10, ge=0, le=1)
 
@@ -167,7 +166,6 @@ class VideoOptions(BaseModel):
         data["script_review_enabled"] = False
         if self.voice_gender == "none":
             data.pop("custom_voice_id", None)
-            data.pop("voice_emotion", None)
         if not self.bgm_track_id:
             data.pop("bgm_volume", None)
         return data
@@ -369,9 +367,6 @@ def _check(ctx: Ctx, options: VideoOptions) -> tuple[dict, Plan]:
         if length := b2v_access.house_length(payload.get("video_style")):
             payload["video_length"] = length
         plan = b2v_access.check_refs(ctx, payload)
-    accent = (ctx.workspace.brand_json or {}).get("accent")
-    if plan.brand_kit and accent and "accent_color" not in payload:
-        payload["accent_color"] = accent
     return payload, plan
 
 
@@ -626,10 +621,10 @@ def quota(ctx: Ctx = Depends(get_ctx)):
 
 def _with_posters(t: dict) -> dict:
     """Poster images for the template picker. Built-in templates have baked posters on blog2video's web app (a few
-    have none; the picker then shows the template's colors); designer templates carry their own image."""
+    have none; the picker then shows the template's colors)."""
     if t.get("preview_image_url") and not t.get("preview_url"):
         return {**t, "preview_url": t["preview_image_url"]}
-    if t.get("preview_url") or not t.get("id") or str(t["id"]).startswith("crafted_"):
+    if t.get("preview_url") or not t.get("id"):
         return t
     base = f"{settings.b2v_app_url.rstrip('/')}/template-posters/{t['id']}"
     return {**t, "preview_url": f"{base}.webp", "preview_portrait_url": f"{base}-portrait.webp"}
@@ -637,20 +632,15 @@ def _with_posters(t: dict) -> dict:
 
 @router.get("/catalog")
 def catalog(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
-    """What the wizard offers this workspace: built-in and designer templates, its own ready custom templates,
+    """What the wizard offers this workspace: built-in templates, its own ready custom templates,
     built-in and its own styles, music, languages. Nothing another workspace made."""
     with upstream():
         builtin = b2v.builtin_templates()
-        try:
-            crafted = b2v.crafted_templates()
-        except b2v.B2VError:
-            crafted = []
         mine = [{"id": f"custom_{t.b2v_template_id}", "name": t.name, "custom": True}
                 for t in b2v_access.my_templates(ctx, ready_only=True)]
         styles = b2v_access.visible_styles(ctx)
         music = b2v.music_tracks()
     return {"templates": [_with_posters(t) for t in builtin if isinstance(t, dict)],
-            "crafted_templates": [_with_posters(t) for t in crafted if isinstance(t, dict)],
             "my_templates": mine, "video_styles": styles,
             "music": music, "languages": [{"code": c, "name": n} for c, n in LANGUAGES]}
 
@@ -888,10 +878,6 @@ class ReviewPreviewIn(BaseModel):
     revision: int = Field(0, ge=0)
 
 
-class ReviewAiIn(ReviewPreviewIn):
-    instruction: str = Field(min_length=2, max_length=1000)
-
-
 class ReviewApproveScene(DraftScene):
     preferred_layout: str | None = Field(None, max_length=100)
     source_fingerprint: str | None = Field(None, max_length=200)
@@ -923,22 +909,6 @@ def narration_preview(artifact_id: uuid.UUID, scene_id: int, body: ReviewPreview
                                 json=body.model_dump(), timeout=60)
 
 
-@router.post("/{artifact_id}/script/scenes/{scene_id}/ai-preview")
-def ai_preview(artifact_id: uuid.UUID, scene_id: int, body: ReviewAiIn, ctx: Ctx = Depends(get_ctx),
-               _: None = Depends(b2v_ready)):
-    """★ Rewrite one scene from an instruction. Uses one AI edit."""
-    _, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
-    plan = video_limits.require_premium(ctx.db, ctx.workspace, "AI rewrites")
-    video_limits.take(ctx.db, ctx.workspace, "ai_edits", plan=plan)
-    try:
-        with upstream():
-            return b2v.project_call("POST", vid, f"script-review/scenes/{scene_id}/ai-preview",
-                                    json=body.model_dump(), timeout=60)
-    except HTTPException:
-        video_limits.give_back(ctx.db, ctx.workspace.id, "ai_edits")
-        raise
-
-
 @router.post("/{artifact_id}/script/approve")
 def approve_script(artifact_id: uuid.UUID, body: ReviewApproveIn, ctx: Ctx = Depends(get_ctx),
                    _: None = Depends(b2v_ready)):

backend/app/services/b2v_access.py

@@ -1,6 +1,6 @@
 """Who owns what on our one blog2video account.
 
-blog2video's ownership checks stop at the account: any video, custom template, custom voice or style made with our
+blog2video's ownership checks stop at the account: any video, custom template or style made with our
 key can be used, listed and edited with it. So every route that takes a blog2video id checks here first that it
 belongs to the current workspace (404 otherwise, so another workspace's ids are never confirmed), and every create or
 edit body has its references checked before it is forwarded (check_refs).
@@ -12,11 +12,9 @@ from fastapi import HTTPException
 from sqlalchemy import select
 
 from app.auth import Ctx
-from app.models import Artifact, B2VCustomVoice, B2VStyle, B2VTemplate, B2VVideo
+from app.models import Artifact, 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
 
 BUILTIN_STYLES = {"auto", "explainer", "storytelling", "promotional"}
 # Custom styles made on our blog2video account itself, offered to every workspace in place of the others when they
@@ -29,7 +27,6 @@ HOUSE_STYLES = [  # (name on blog2video, video length, what the wizard says it i
                             "scene building on the last. Best for YouTube, tutorials and full explainers. Usually 1 to "
                             "2 minutes long."),
 ]
-PREMIUM_LENGTHS = {"detailed", "more_detailed", "mdetailed"}
 
 
 def not_found(what: str = "Not found") -> HTTPException:
@@ -79,14 +76,6 @@ def owned_template(ctx: Ctx, template_id: int) -> B2VTemplate:
     return row
 
 
-def owned_custom_voice(ctx: Ctx, custom_voice_id: int) -> B2VCustomVoice:
-    row = ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.b2v_custom_voice_id == custom_voice_id,
-                                                     B2VCustomVoice.workspace_id == ctx.workspace.id))
-    if not row:
-        raise not_found("Voice not found")
-    return row
-
-
 def owned_style(ctx: Ctx, style_id: int) -> B2VStyle:
     row = ctx.db.scalar(select(B2VStyle).where(B2VStyle.b2v_style_id == style_id,
                                                B2VStyle.workspace_id == ctx.workspace.id))
@@ -100,15 +89,6 @@ def _custom_id(ref: str, prefix: str) -> int | None:
     return int(raw) if ref.startswith(prefix) and raw.isdigit() else None
 
 
-def crafted_ids() -> set[str]:
-    out = set()
-    for t in b2v.crafted_templates():
-        tid = t.get("id") if isinstance(t, dict) else t
-        if isinstance(tid, str) and tid.startswith("crafted_"):
-            out.add(tid)
-    return out
-
-
 def check_template(ctx: Ctx, template: str, plan: Plan) -> None:
     if template == "default":
         return
@@ -117,12 +97,6 @@ def check_template(ctx: Ctx, template: str, plan: Plan) -> None:
         if not row.ready:
             raise HTTPException(400, "That template is still being made.")
         return
-    if template.startswith("crafted_"):
-        # blog2video silently falls back to "default" for an unknown id, so check it exists.
-        if template not in crafted_ids():
-            raise not_found("Template not found")
-        require_premium(ctx.db, ctx.workspace, "Designer templates", plan)
-        return
     if template not in {t.get("id") for t in b2v.builtin_templates() if isinstance(t, dict)}:
         raise not_found("Template not found")
 
@@ -157,38 +131,26 @@ def check_style(ctx: Ctx, style: str) -> None:
     raise not_found("Video style not found")  # includes your_style, which learns from every workspace's edits
 
 
-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 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":
-            require_premium(ctx.db, ctx.workspace, "This voice", plan)
-        return
-    if ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.voice_id == voice_id,
-                                                  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")
+def check_voice(voice_id: str) -> None:
+    """A free built-in voice (blog2video marks the paid ones)."""
+    voice = next((v for v in b2v.prebuilt_voices() if v.get("voice_id") == voice_id), None)
+    if not voice or voice.get("plan") == "paid":
+        raise not_found("Voice not found")
 
 
 def check_refs(ctx: Ctx, body: dict, plan: Plan | None = None) -> Plan:
-    """Every id in a create or edit body must be this workspace's, and premium options need a paid plan."""
+    """Every id in a create or edit body must be this workspace's, and only the standard options are accepted."""
     plan = plan or effective_plan(ctx.db, ctx.workspace)
     if body.get("template"):
         check_template(ctx, str(body["template"]), plan)
     if body.get("video_style"):
         check_style(ctx, str(body["video_style"]))
     if body.get("custom_voice_id") and body.get("voice_gender") != "none":
-        check_voice(ctx, str(body["custom_voice_id"]), plan)
-    if str(body.get("video_length") or "") in PREMIUM_LENGTHS:
-        require_premium(ctx.db, ctx.workspace, "Longer videos", plan)
+        check_voice(str(body["custom_voice_id"]))
+    if str(body.get("video_length") or "") not in {"", "short", "medium"}:
+        raise HTTPException(400, "That video length is not available.")
     if body.get("voice_emotion"):
-        require_premium(ctx.db, ctx.workspace, "Advanced voice options", plan)
+        raise HTTPException(400, "Voice tuning is not available.")
     return plan
 
 

backend/app/services/billing.py

@@ -10,7 +10,7 @@ from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
 from app.config import settings
-from app.models import Artifact, CalendarItem, Notebook, Source, Subscription, User, VoiceProfile, Workspace
+from app.models import Artifact, CalendarItem, Document, Notebook, Source, Subscription, User, VoiceProfile, Workspace
 from app.services.plans import PLANS, Plan, effective_plan, next_plan, plan_dict
 from app.services.usage import month_usage
 from app.services.video_quota import sync_video_quota, video_usage
@@ -27,15 +27,30 @@ METERS = {
 
 def _meters(plan: Plan, used: dict, sources: int) -> list[dict]:
     rows = []
-    for key, (label, unit) in METERS.items():
+    meters = dict(METERS)
+    if plan.audio_overviews >= 0:  # a count of audio overviews (Free), not minutes
+        meters = {("audio_overviews" if k == "audio_minutes" else k): (("Audio overviews", "") if k == "audio_minutes" else v)
+                  for k, v in METERS.items()}
+    for key, (label, unit) in meters.items():
         limit = getattr(plan, key)
         rows.append({"key": key, "label": label, "unit": unit, "used": used[key], "limit": limit,
                      "pct": 0 if limit < 0 else round(min(1.0, used[key] / max(limit, 1)), 3)})
     rows.append({"key": "sources", "label": "Sources", "unit": "", "used": sources, "limit": plan.sources,
-                 "pct": round(min(1.0, sources / max(plan.sources, 1)), 3)})
+                 "pct": 0 if plan.sources < 0 else round(min(1.0, sources / max(plan.sources, 1)), 3)})
     return rows
 
 
+def _more_meters(db: Session, workspace: Workspace, plan: Plan, used: dict) -> list[dict]:
+    """The rest of the plan's limits, shown when the sidebar card is opened: indexed posts, reports and infographics."""
+    posts = db.scalar(select(func.count()).select_from(Document)
+                      .where(Document.workspace_id == workspace.id, Document.path.is_not(None))) or 0
+    rows = [("indexed_posts", "Posts indexed", posts, plan.indexed_posts),
+            ("reports", "Reports", used["reports"], plan.reports),
+            ("infographics", "Infographics", used["infographics"], plan.infographics)]
+    return [{"key": k, "label": label, "unit": "", "used": u, "limit": limit,
+             "pct": 0 if limit < 0 else round(min(1.0, u / max(limit, 1)), 3)} for k, label, u, limit in rows]
+
+
 def _count(db: Session, model, workspace_id, *where) -> int:
     return db.scalar(select(func.count()).select_from(model).where(model.workspace_id == workspace_id, *where)) or 0
 
@@ -57,23 +72,20 @@ def build_nudges(db: Session, workspace: Workspace, plan: Plan, meters: list[dic
                 continue
             label = m["label"].lower()
             amount = f"{m['limit']:g} min of {label}" if m["unit"] else f"{m['limit']:g} {label}"
+            when = "" if plan.lifetime else " this month"
             if m["pct"] >= 1:
-                out.append(_nudge(f"empty-{m['key']}-{month}", "limit", f"Out of {label} this month",
+                out.append(_nudge(f"empty-{m['key']}-{month}", "limit", f"Out of {label}{when}",
                                   f"You have used all {amount}. Upgrade to keep launching.", "Refuel now",
                                   priority=100))
             elif m["pct"] >= LOW_FUEL:
                 left = f"{m['limit'] - m['used']:g}" + (" min" if m["unit"] else "")
                 out.append(_nudge(f"low-{m['key']}-{month}", "limit", f"Running low on {label}",
-                                  f"Only {left} left this month. Upgrade before you stall mid launch.",
+                                  f"Only {left} left{when}. Upgrade before you stall mid launch.",
                                   "See plans", priority=90))
         if not plan.voice_cloning:
             out.append(_nudge("perk-voice", "upgrade", "Narrate in your own voice",
                               "Writer unlocks voice cloning, so every audio overview sounds like you.",
                               "Unlock voice", priority=40))
-        if not plan.brand_kit:
-            out.append(_nudge("perk-brand", "upgrade", "Put your brand on every render",
-                              "Your colors and logo on videos, quote cards and carousels.", "Unlock brand kit",
-                              priority=30))
 
     sources = _count(db, Source, ws)
     if sources == 0:
@@ -119,7 +131,7 @@ def build_nudges(db: Session, workspace: Workspace, plan: Plan, meters: list[dic
 
 def billing_status(db: Session, workspace: Workspace) -> dict:
     plan = effective_plan(db, workspace)
-    used = month_usage(db, workspace.id)
+    used = month_usage(db, workspace.id, plan.lifetime)
     videos = video_usage(db, workspace)
     used["videos"] = videos["used"]
     sources = _count(db, Source, workspace.id)
@@ -136,6 +148,7 @@ def billing_status(db: Session, workspace: Workspace) -> dict:
         "has_billing_account": bool(sub and sub.provider_customer_id),
         "period_end": sub.current_period_end.isoformat() if sub and sub.current_period_end else None,
         "meters": meters,
+        "more_meters": _more_meters(db, workspace, plan, used),
         "since": used["since"],
         "videos_resets_at": videos["resets_at"],
         "nudges": build_nudges(db, workspace, plan, meters, can_upgrade),

backend/app/services/notestack_voices.py

@@ -1,6 +1,5 @@
 """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."""
+from the ElevenLabs library. They speak audio overviews; video_voices lists them with the workspace's saved voices."""
 
 import uuid
 
@@ -32,8 +31,8 @@ def is_notestack_voice(db: Session, workspace_id: uuid.UUID, voice_id: str) -> b
 
 
 def save_notestack_voice(db: Session, workspace_id: uuid.UUID, voice_id: str, name: str) -> UserSavedVoice:
-    """Put a Notestack voice in the workspace's voices (the one list for audio and video), once. Saving needs no plan:
-    using it in a video is premium (b2v_access.check_voice). No preview link: it is played through /api/voice/preview.
+    """Put a Notestack voice in the workspace's voices (the one list for audio and video), once. Saving needs no plan; it speaks audio
+    overviews (a video uses the free built-in voices). No preview link: it is played through /api/voice/preview.
     The caller commits."""
     row = db.get(UserSavedVoice, {"workspace_id": workspace_id, "voice_id": voice_id})
     if row is None:

backend/app/services/plans.py

@@ -31,36 +31,32 @@ class Plan:
     indexed_posts: int
     audio_minutes: int
     videos: int  # blog2video videos per month, or in total when videos_monthly is False
-    launch_kits: int  # -1 = unlimited
+    launch_kits: int  # a month (or in total on a lifetime plan); -1 = unlimited
     voice_cloning: bool
-    brand_kit: bool
     features: tuple[str, ...]
-    # Premium (★) video options: long durations, paid and custom voices, voice tuning and samples, AI script
-    # rewrites, AI chat editing, avatars, the Remotion source download.
-    video_premium: bool = False
     # Per-workspace shares of what blog2video only limits account-wide (keys in VIDEO_LIMITS; 0 = none).
     video_limits: dict = field(default_factory=dict)
     videos_monthly: bool = True
     reports: int = 0  # reports a month; -1 = unlimited
-    infographics: int = 0  # infographics a month; -1 = unlimited
+    infographics: int = 0  # infographics a month (in total on a lifetime plan); -1 = unlimited
+    audio_overviews: int = -1  # audio overviews allowed (in total on a lifetime plan), whatever their length; -1 = no cap
+
+    @property
+    def lifetime(self) -> bool:
+        """The allowances for videos, audio overviews, Launch Kits and infographics are totals that never reset (Free)."""
+        return not self.videos_monthly
 
 
 # metric -> period it counts over (app/services/video_limits.py)
 VIDEO_LIMITS = {
-    "ai_edits": "month",  # scene regenerate/add, AI images, stock clips, AI chat, template AI edits, avatars
+    "ai_edits": "month",  # scene regenerate/add, AI images, stock clips
     "templates": "all",  # custom templates: blog2video's slots are lifetime, never given back
     "template_ai_daily": "day",  # template theme extraction from a prompt or document, code generation
-    "voice_designs_daily": "day",
-    "voice_samples_daily": "day",
-    "custom_voices": "all",  # kept voices; deleting one frees its place
 }
 
-FREE_VIDEO_LIMITS = {"ai_edits": 20, "templates": 0, "template_ai_daily": 0, "voice_designs_daily": 0,
-                     "voice_samples_daily": 0, "custom_voices": 0}
-WRITER_VIDEO_LIMITS = {"ai_edits": 300, "templates": 2, "template_ai_daily": 3, "voice_designs_daily": 5,
-                       "voice_samples_daily": 20, "custom_voices": 3}
-STUDIO_VIDEO_LIMITS = {"ai_edits": 1000, "templates": 5, "template_ai_daily": 5, "voice_designs_daily": 10,
-                       "voice_samples_daily": 40, "custom_voices": 10}
+FREE_VIDEO_LIMITS = {"ai_edits": 20, "templates": 0, "template_ai_daily": 0}
+WRITER_VIDEO_LIMITS = {"ai_edits": 300, "templates": 2, "template_ai_daily": 3}
+STUDIO_VIDEO_LIMITS = {"ai_edits": 1000, "templates": 5, "template_ai_daily": 5}
 
 
 DEFAULT_PLANS: dict[str, Plan] = {
@@ -69,23 +65,23 @@ DEFAULT_PLANS: dict[str, Plan] = {
         name="Free",
         tagline="For trying Notestack on your archive",
         price_monthly_usd=0,
-        sources=1,
+        sources=-1,
         indexed_posts=5,
-        audio_minutes=3,
+        audio_minutes=-1,
+        audio_overviews=1,
         videos=1,
         launch_kits=2,
         reports=2,
         infographics=2,
         voice_cloning=False,
-        brand_kit=False,
         features=(
-            "1 source, your latest 5 posts indexed",
+            "Up to 5 posts indexed, from any source",
             "Grounded research chat with citations",
-            "3 min of audio overviews a month",
-            "1 video to try it",
-            "2 Launch Kits a month",
+            "1 audio overview, any length",
+            "1 video",
+            "2 Launch Kits",
+            "2 infographics",
             "2 reports a month",
-            "2 infographics a month",
         ),
         video_limits=FREE_VIDEO_LIMITS,
         videos_monthly=False,
@@ -95,26 +91,23 @@ DEFAULT_PLANS: dict[str, Plan] = {
         name="Writer",
         tagline="For writers publishing every week",
         price_monthly_usd=24.99,
-        sources=3,
-        indexed_posts=500,
+        sources=-1,
+        indexed_posts=100,
         audio_minutes=60,
         videos=10,
-        launch_kits=50,
+        launch_kits=20,
         reports=30,
         infographics=30,
         voice_cloning=True,
-        brand_kit=True,
         features=(
-            "3 sources, 500 indexed posts",
-            "60 min of audio overviews a month",
+            "Up to 100 posts indexed, from any source",
+            "10x more audio overviews than Free (60 min a month)",
             "10 videos a month",
-            "50 Launch Kits a month",
+            "20 Launch Kits a month",
             "30 reports a month",
             "30 infographics a month",
             "Voice cloning with consent",
-            "Your brand colors and logo",
         ),
-        video_premium=True,
         video_limits=WRITER_VIDEO_LIMITS,
     ),
     "studio": Plan(
@@ -122,26 +115,24 @@ DEFAULT_PLANS: dict[str, Plan] = {
         name="Studio",
         tagline="For publications and power users",
         price_monthly_usd=48.99,
-        sources=10,
-        indexed_posts=5000,
+        sources=-1,
+        indexed_posts=250,
         audio_minutes=240,
         videos=20,
-        launch_kits=-1,
+        launch_kits=50,
         reports=-1,
         infographics=-1,
         voice_cloning=True,
-        brand_kit=True,
         features=(
-            "10 sources, 5,000 indexed posts",
-            "240 min of audio overviews a month",
+            "Up to 250 posts indexed, from any source",
+            "40x more audio overviews than Free (240 min a month)",
             "20 videos a month",
-            "Unlimited Launch Kits",
+            "50 Launch Kits a month",
             "Unlimited reports",
             "Unlimited infographics",
             "Launchpad calendar and resurfacing",
             "Priority rendering",
         ),
-        video_premium=True,
         video_limits=STUDIO_VIDEO_LIMITS,
     ),
 }
@@ -154,10 +145,10 @@ def _plan_from_row(row: PlanRecord) -> Plan:
     return Plan(id=row.id, name=row.name, tagline=row.tagline or "",
                 price_monthly_usd=float(row.price_monthly_usd or 0), sources=row.sources,
                 indexed_posts=row.indexed_posts, audio_minutes=row.audio_minutes,
-                videos=row.videos, launch_kits=row.launch_kits, reports=row.reports, infographics=row.infographics,
+                videos=row.videos, launch_kits=row.launch_kits, reports=row.reports, infographics=row.infographics, audio_overviews=row.audio_overviews,
                 voice_cloning=bool(row.voice_cloning),
-                brand_kit=bool(row.brand_kit), features=tuple(row.features or ()),
-                video_premium=bool(row.video_premium), videos_monthly=bool(row.videos_monthly),
+                features=tuple(row.features or ()),
+                videos_monthly=bool(row.videos_monthly),
                 video_limits={**{k: 0 for k in VIDEO_LIMITS}, **(row.video_limits or {})})
 
 
@@ -251,6 +242,22 @@ def effective_plan(db: Session, workspace: Workspace) -> Plan:
     return PLANS.get(sub.plan, PLANS["free"])
 
 
+def post_room(db: Session, workspace_id, plan: Plan, source_id=None) -> int:
+    """How many more posts the plan lets this workspace index: its limit across every source, link and upload, less the
+    posts indexed already. With `source_id`, that source's own posts are left out of the count, and a source never loses
+    posts it already has indexed (a plan that went down keeps what is stored; it only stops new ones)."""
+    from sqlalchemy import func
+
+    from app.models import Document
+
+    base = select(func.count()).select_from(Document).where(Document.workspace_id == workspace_id, Document.path.is_not(None))
+    total = db.scalar(base) or 0
+    if source_id is None:
+        return max(plan.indexed_posts - total, 0)
+    own = db.scalar(base.where(Document.source_id == source_id)) or 0
+    return max(plan.indexed_posts - (total - own), own)
+
+
 def plan_order() -> list[str]:
     return PLANS.order()
 

backend/app/services/renderer.py

@@ -57,15 +57,3 @@ def request_render(job: Job, artifact: Artifact, composition: str, props: dict |
     if resp.status_code == 400:
         raise PermanentJobError(f"Renderer rejected the props: {resp.text[:400]}")
     resp.raise_for_status()
-
-
-def brand_props(workspace, *, ttl: int = 6 * 3600) -> dict:
-    brand = workspace.brand_json or {}
-    out: dict = {}
-    if brand.get("accent"):
-        out["accent"] = brand["accent"]
-    if brand.get("name"):
-        out["name"] = brand["name"]
-    if brand.get("logo_key"):
-        out["logoUrl"] = storage.presign_get(brand["logo_key"], ttl=ttl)
-    return out

backend/app/services/usage.py

@@ -5,7 +5,7 @@ from datetime import UTC, datetime
 from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
-from app.models import Artifact, UsageEvent, Workspace
+from app.models import Artifact, Document, UsageEvent, Workspace
 from app.services.plans import Plan, effective_plan, plan_limit_error
 from app.services.video_quota import video_usage
 
@@ -15,7 +15,9 @@ def month_start(now: datetime | None = None) -> datetime:
     return now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
 
 
-def month_usage(db: Session, workspace_id) -> dict:
+def month_usage(db: Session, workspace_id, lifetime: bool = False) -> dict:
+    """What this month has used. With `lifetime` (the Free plan) Launch Kits, infographics and audio overviews are
+    counted over all time instead, not counting the ones that failed (a failed one never uses up an allowance)."""
     since = month_start()
 
     def total(kind: str, unit: str) -> float:
@@ -26,26 +28,20 @@ def month_usage(db: Session, workspace_id) -> dict:
             )
         ) or 0)
 
-    kits = db.scalar(
-        select(func.count()).select_from(Artifact).where(
-            Artifact.workspace_id == workspace_id, Artifact.type == "launch_kit", Artifact.created_at >= since
-        )
-    ) or 0
-    reports = db.scalar(
-        select(func.count()).select_from(Artifact).where(
-            Artifact.workspace_id == workspace_id, Artifact.type == "report", Artifact.created_at >= since
-        )
-    ) or 0
-    infographics = db.scalar(
-        select(func.count()).select_from(Artifact).where(
-            Artifact.workspace_id == workspace_id, Artifact.type == "infographic", Artifact.created_at >= since
-        )
-    ) or 0
+    def made(type_: str, *, always_month: bool = False) -> int:
+        q = select(func.count()).select_from(Artifact).where(Artifact.workspace_id == workspace_id, Artifact.type == type_)
+        if lifetime and not always_month:
+            q = q.where(Artifact.status != "failed")
+        else:
+            q = q.where(Artifact.created_at >= since)
+        return db.scalar(q) or 0
+
     return {
         "audio_minutes": round(total("tts", "seconds") / 60, 1),
-        "launch_kits": kits,
-        "reports": reports,
-        "infographics": infographics,
+        "audio_overviews": made("audio_overview"),
+        "launch_kits": made("launch_kit"),
+        "reports": made("report", always_month=True),  # reports stay monthly on every plan
+        "infographics": made("infographic"),
         "llm_tokens": int(total("llm", "tokens")),
         "since": since.isoformat(),
     }
@@ -53,15 +49,19 @@ def month_usage(db: Session, workspace_id) -> dict:
 
 def usage_report(db: Session, workspace: Workspace) -> dict:
     plan = effective_plan(db, workspace)
-    used = month_usage(db, workspace.id)
+    used = month_usage(db, workspace.id, plan.lifetime)
     videos = video_usage(db, workspace)
     used["videos"] = videos["used"]
+    used["indexed_posts"] = db.scalar(
+        select(func.count()).select_from(Document).where(Document.workspace_id == workspace.id, Document.path.is_not(None))
+    ) or 0
     return {
         "plan": plan.id,
         "used": used,
         "videos_resets_at": videos["resets_at"],
         "limits": {
             "audio_minutes": plan.audio_minutes,
+            "audio_overviews": plan.audio_overviews,
             "videos": videos["limit"],
             "launch_kits": plan.launch_kits,
             "reports": plan.reports,
@@ -73,12 +73,13 @@ def usage_report(db: Session, workspace: Workspace) -> dict:
 
 
 def check_limit(db: Session, workspace: Workspace, kind: str, amount: float = 1) -> Plan:
-    """Raise 402 plan_limit when this request would go over the monthly allowance."""
+    """Raise 402 plan_limit when this request would go over the allowance (monthly, or in total on Free)."""
     plan = effective_plan(db, workspace)
-    used = month_usage(db, workspace.id)
-    limit = {"audio_minutes": plan.audio_minutes, "launch_kits": plan.launch_kits, "reports": plan.reports,
-             "infographics": plan.infographics}[kind]
+    used = month_usage(db, workspace.id, plan.lifetime)
+    limit = {"audio_minutes": plan.audio_minutes, "audio_overviews": plan.audio_overviews,
+             "launch_kits": plan.launch_kits, "reports": plan.reports, "infographics": plan.infographics}[kind]
     if limit >= 0 and used[kind] + amount > limit:
         label = kind.replace("_", " ")
-        raise plan_limit_error(plan, kind, f"This would go over your {limit} {label} this month.")
+        total = plan.lifetime and kind != "reports"  # Free's allowances are totals, its reports are monthly
+        raise plan_limit_error(plan, kind, f"This would go over your {limit} {label}{' in total' if total else ' this month'}.")
     return plan

backend/app/services/video_limits.py

@@ -1,5 +1,5 @@
 """Per-workspace shares of what blog2video only limits account-wide: AI edits, custom templates, template AI
-operations, voice designs, voice samples, custom voices (plans.VIDEO_LIMITS), plus premium (★) video options.
+operations (plans.VIDEO_LIMITS).
 
 blog2video checks every limit against our own (Pro) account, so every workspace passes its checks. These counters
 stop a workspace before it uses up everyone's share. Videos themselves are counted in video_quota.py.
@@ -21,9 +21,6 @@ LABELS = {
     "ai_edits": ("AI edits", "this month"),
     "templates": ("custom templates", "in total"),
     "template_ai_daily": ("AI template steps", "today"),
-    "voice_designs_daily": ("voice designs", "today"),
-    "voice_samples_daily": ("voice samples", "today"),
-    "custom_voices": ("custom voices", "at a time"),
 }
 
 
@@ -68,7 +65,7 @@ def take(db: Session, workspace: Workspace, metric: str, n: int = 1, plan: Plan
 
 
 def give_back(db: Session, workspace_id: uuid.UUID, metric: str, n: int = 1) -> None:
-    """Undo a take whose blog2video call failed (or a custom voice that was deleted)."""
+    """Undo a take whose blog2video call failed."""
     db.execute(update(UsageCounter)
                .where(UsageCounter.workspace_id == workspace_id, UsageCounter.period == period_key(metric),
                       UsageCounter.metric == metric)
@@ -76,18 +73,10 @@ def give_back(db: Session, workspace_id: uuid.UUID, metric: str, n: int = 1) ->
     db.commit()
 
 
-def require_premium(db: Session, workspace: Workspace, what: str, plan: Plan | None = None) -> Plan:
-    plan = plan or effective_plan(db, workspace)
-    if not plan.video_premium:
-        raise plan_limit_error(plan, "video_premium", f"{what} comes with a paid plan.")
-    return plan
-
-
 def report(db: Session, workspace: Workspace) -> dict:
-    """What the wizard shows: premium or not, and each counter's used / limit."""
+    """What the wizard shows: each counter's used / limit."""
     plan = effective_plan(db, workspace)
     rows = {(r.period, r.metric): r.used for r in db.scalars(
         select(UsageCounter).where(UsageCounter.workspace_id == workspace.id))}
-    return {"premium": plan.video_premium,
-            "limits": {m: {"used": rows.get((period_key(m), m), 0), "limit": int(plan.video_limits.get(m, 0))}
+    return {"limits": {m: {"used": rows.get((period_key(m), m), 0), "limit": int(plan.video_limits.get(m, 0))}
                        for m in VIDEO_LIMITS}}

backend/app/support/corpus.py

@@ -83,7 +83,7 @@ def _plans_doc() -> Doc:
             f"{p.audio_minutes} minutes of audio a month, "
             f"{p.videos} videos {'a month' if p.videos_monthly else 'in total'}, {kits} Launch Kits a month, "
             f"{reports} reports a month, {infographics} infographics a month. "
-            f"Voice cloning: {'yes' if p.voice_cloning else 'no'}. Brand kit: {'yes' if p.brand_kit else 'no'}.",
+            f"Voice cloning: {'yes' if p.voice_cloning else 'no'}.",
             "Includes: " + "; ".join(p.features) + ".",
         ]
     lines += [

backend/app/worker.py

@@ -49,7 +49,7 @@ from app.pipeline import flashcards, generate, infographic, launchkit, media, qu
 from app.pipeline.generate import NothingToDo
 from app.pipeline.ingest import FeedNotFound, entry_from_upload, extract_article, ingest_source, store_entries
 from app.pipeline.memory import learn_from_message
-from app.services import launchpad, tts, video_quota
+from app.services import launchpad, report_suggestions, tts, video_quota
 from app.services.email import email_service
 from app.services.email_verification import purge_old_codes
 from app.services.jobs import (
@@ -62,7 +62,7 @@ from app.services.jobs import (
     update_job,
 )
 from app.services.notestack_voices import save_notestack_voice
-from app.services.plans import effective_plan
+from app.services.plans import effective_plan, post_room
 from app.services.renderer import PermanentJobError, request_render
 from app.services.social.health import social_health
 from app.services.storage import keys, storage
@@ -102,8 +102,10 @@ def handle_ingest(db: Session, job: Job):
     if not source:
         return Done({"error": "source deleted"}, "Source no longer exists")
     plan = effective_plan(db, db.get(Workspace, source.workspace_id))
+    # The plan limit is one total across every source, link and upload: this source gets what the others leave.
+    room = post_room(db, source.workspace_id, plan, source.id)
     try:
-        result = ingest_source(db, source, job, max_posts=plan.indexed_posts)
+        result = ingest_source(db, source, job, max_posts=room)
     except Exception as exc:
         db.rollback()
         source.sync_status = "error"
@@ -155,6 +157,16 @@ def handle_chat_memory_cleanup(db: Session, job: Job):
     return Done({"removed": removed}, f"Removed {removed} orphaned chats")
 
 
+def _require_room(db: Session, source: Source, url: str) -> None:
+    """Re-reading a post that is already indexed is fine; a new one needs room under the plan's post limit."""
+    known = db.scalar(select(Document.id).where(Document.source_id == source.id, Document.url == url,
+                                                 Document.path.is_not(None)))
+    plan = effective_plan(db, db.get(Workspace, source.workspace_id))
+    if not known and post_room(db, source.workspace_id, plan) <= 0:
+        raise PermanentJobError(f"Your plan indexes up to {plan.indexed_posts} posts, and they are all used. "
+                                "Remove a post or upgrade to add more.")
+
+
 def handle_import_url(db: Session, job: Job):
     source = db.get(Source, uuid.UUID(job.params["source_id"]))
     update_job(db, job, progress=0.1, message="Fetching the article")
@@ -162,6 +174,7 @@ def handle_import_url(db: Session, job: Job):
         entry = extract_article(job.params["url"])
     except FeedNotFound as exc:
         raise PermanentJobError(str(exc)) from exc
+    _require_room(db, source, entry.url)
     indexed, _, changed = store_entries(db, source, [entry])
     _after_import(db, job, source.workspace_id, [str(i) for i in changed])
     return Done({"indexed": indexed, "document_ids": [str(i) for i in changed]}, f"{entry.title[:80]} is in orbit")
@@ -174,6 +187,7 @@ def handle_import_upload(db: Session, job: Job):
     entry = entry_from_upload(upload.filename, upload.content_type, storage.get_bytes(upload.key))
     if not entry.sections and not entry.html:
         raise PermanentJobError("We could not read any text in that file.")
+    _require_room(db, source, entry.url)
     indexed, _, changed = store_entries(db, source, [entry])
     _after_import(db, job, source.workspace_id, [str(i) for i in changed])
     return Done({"indexed": indexed, "document_ids": [str(i) for i in changed]}, f"{entry.title[:80]} is in orbit")
@@ -185,9 +199,16 @@ def handle_topics(db: Session, job: Job):
 
 def handle_ideas(db: Session, job: Job):
     result = generate.extract_ideas(db, job, job.workspace_id, job.params.get("document_ids"))
+    if result["extracted"]:
+        report_suggestions.queue_warmup(db, job.workspace_id)  # their notebooks' suggested report templates are written now
     return Done(result, f"Read {result['extracted']} posts for their ideas")
 
 
+def handle_report_templates(db: Session, job: Job):
+    written = report_suggestions.warm_workspace(db, job.workspace_id)
+    return Done({"written": written}, f"Prepared report templates for {written} notebooks")
+
+
 def handle_voice_profile(db: Session, job: Job):
     try:
         result = generate.build_voice_profile(db, job, job.workspace_id, job.params.get("document_ids") or [])
@@ -282,6 +303,7 @@ HANDLERS: dict[str, Callable[[Session, Job], object]] = {
     "topics": handle_topics,
     "publish_post": handle_publish_post,
     "ideas": handle_ideas,
+    "report_templates": handle_report_templates,
     "memory_update": handle_memory,
     "chat_memory": handle_chat_memory,
     "chat_memory_rebuild": handle_chat_memory_rebuild,

backend/scripts/render_theme_thumbnails.py

@@ -1,12 +1,8 @@
-"""Draws every infographic theme with the sample content (and, with --stress, the longest text allowed) using a local
-Chrome, so the themes can be checked by eye and the picker thumbnails regenerated.
+"""Draws each infographic look with the sample content using a local Chrome, so the picker thumbnails can be regenerated.
 
-  python scripts/render_theme_thumbnails.py            # writes ../frontend/public/infographics/<theme>.png (small)
-  python scripts/render_theme_thumbnails.py --stress   # writes full-size stress renders to a temp folder
+  python scripts/render_theme_thumbnails.py     # writes ../frontend/public/infographics/<look>.png (small)
 Set CHROME to the browser binary if it is not found."""
 
-import glob
-import os
 import subprocess
 import sys
 import tempfile
@@ -14,32 +10,24 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
-from app.infographics.content import HEIGHT, SAMPLE, STRESS, WIDTH, clamp  # noqa: E402
-from app.infographics.render import thumbnail_html  # noqa: E402
-from app.infographics.themes import THEMES  # noqa: E402
+from app.infographics.design import LOOKS, SAMPLE, render_design  # noqa: E402
+from app.infographics.image import chrome  # noqa: E402
+from app.infographics.render import SIZES  # noqa: E402
 
-def chrome() -> str:
-    found = os.environ.get("CHROME") or next(iter(glob.glob(os.path.expanduser("~/.cache/puppeteer/chrome/*/chrome-mac-*/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"))), "") \
-        or "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
-    return found
 
-
-def shoot(html: str, out: Path) -> None:
+def shoot(html: str, out: Path, layout: str) -> None:
+    width, height = SIZES[layout]
     with tempfile.NamedTemporaryFile("w", suffix=".html", delete=False) as f:
-        f.write(html)
-    subprocess.run([chrome(), "--headless=new", "--disable-gpu", "--hide-scrollbars", f"--window-size={WIDTH},{HEIGHT}",
-                    "--virtual-time-budget=8000", f"--screenshot={out}", f"file://{f.name}"], check=True, capture_output=True)
-    os.unlink(f.name)
+        f.write(f'<!doctype html><meta charset="utf-8"><body style="margin:0">{html}</body>')
+    subprocess.run([chrome(), "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars", f"--window-size={width},{height}",
+                    "--force-device-scale-factor=2", "--virtual-time-budget=8000", f"--screenshot={out}", f"file://{f.name}"], check=True, capture_output=True)
 
 
 if __name__ == "__main__":
-    stress = "--stress" in sys.argv
-    folder = Path(tempfile.gettempdir()) / "ig-stress" if stress else Path(__file__).resolve().parents[2] / "frontend/public/infographics"
+    folder = Path(__file__).resolve().parents[2] / "frontend/public/infographics"
     folder.mkdir(parents=True, exist_ok=True)
-    content = clamp(STRESS if stress else SAMPLE)
-    for tid in THEMES:
-        out = folder / f"{tid}.png"
-        shoot(thumbnail_html(tid, content), out)
-        if not stress:  # picker thumbnails: a third of the size is plenty
-            subprocess.run(["sips", "--resampleWidth", "560", str(out)], check=False, capture_output=True)
+    for look in LOOKS:
+        out = folder / f"{look}.png"
+        shoot(render_design(look, SAMPLE, "landscape", fit=1.0), out, "landscape")
+        subprocess.run(["sips", "--resampleWidth", "1400", str(out)], check=False, capture_output=True)  # drawn at 2x, kept at 1400 wide: sharp when shown large
         print(out)

backend/tests/test_billing.py

@@ -3,7 +3,7 @@
 import pytest
 
 from app.config import settings
-from app.models import Artifact, Notebook, Workspace
+from app.models import Artifact, Document, Notebook, Source, Workspace
 from app.services.billing import apply_subscription
 from tests.conftest import last_code
 
@@ -38,6 +38,8 @@ def test_free_plan_nudges_and_out_of_fuel_402(client, auth, billing_on, db_sessi
     assert body["plan"]["id"] == "free" and body["can_upgrade"] and body["next_plan"] == "writer"
     kits = next(m for m in body["meters"] if m["key"] == "launch_kits")
     assert kits["used"] == 2 and kits["pct"] == 1
+    more = {m["key"]: m for m in body["more_meters"]}  # the rest of the plan, behind the sidebar card's chevron
+    assert set(more) == {"indexed_posts", "reports", "infographics"} and more["indexed_posts"]["limit"] == 5
     ids = [n["id"] for n in body["nudges"]]
     assert ids[0].startswith("empty-launch_kits") and "perk-voice" in ids
     assert "—" not in str(body)
@@ -45,10 +47,77 @@ def test_free_plan_nudges_and_out_of_fuel_402(client, auth, billing_on, db_sessi
     nb = Notebook(workspace_id=ws.id, title="Pricing")
     db_session.add(nb)
     db_session.commit()
-    r = client.post("/api/artifacts/generate", headers=auth,
-                    json={"type": "audio_overview", "notebook_id": str(nb.id), "minutes": 6})
+    # Free gets one audio overview in total, whatever its length (here 6 minutes), then it is used up for good.
+    body_in = {"type": "audio_overview", "notebook_id": str(nb.id), "minutes": 6}
+    assert client.post("/api/artifacts/generate", headers=auth, json=body_in).status_code == 200
+    r = client.post("/api/artifacts/generate", headers=auth, json=body_in)
     detail = r.json()["detail"]
-    assert r.status_code == 402 and detail["kind"] == "audio_minutes" and detail["upgrade_to"] == "writer"
+    assert r.status_code == 402 and detail["kind"] == "audio_overviews" and detail["upgrade_to"] == "writer"
+    assert "in total" in detail["message"]
+    audio = next(m for m in client.get("/api/billing/status", headers=auth).json()["meters"] if m["key"] == "audio_overviews")
+    assert audio["used"] == 1 and audio["limit"] == 1
+
+
+def _index_posts(db, ws, n, source):
+    for i in range(n):
+        db.add(Document(workspace_id=ws.id, source_id=source.id, title=f"Post {i}", url=f"https://x.test/{source.title}/{i}",
+                        path=f"sources/{source.title}/post-{i}.md"))
+    db.commit()
+
+
+def test_post_limit_is_one_total_across_sources_links_and_uploads(client, auth, billing_on, db_session):
+    from app.services.plans import PLANS, post_room
+
+    ws = db_session.query(Workspace).one()
+    feed_a = Source(workspace_id=ws.id, feed_url="https://a.test/feed", title="a")
+    feed_b = Source(workspace_id=ws.id, feed_url="https://b.test/feed", title="b")
+    db_session.add_all([feed_a, feed_b])
+    db_session.commit()
+    free = PLANS["free"]
+    assert free.indexed_posts == 5 and free.sources == -1  # any number of sources, five posts in all
+    _index_posts(db_session, ws, 3, feed_a)
+    assert post_room(db_session, ws.id, free) == 2
+    assert post_room(db_session, ws.id, free, feed_b.id) == 2  # a second source gets what the first leaves
+    _index_posts(db_session, ws, 2, feed_b)
+    assert post_room(db_session, ws.id, free) == 0
+    assert post_room(db_session, ws.id, free, feed_a.id) == 3  # a source keeps the posts it already has
+
+    # A link or a file is refused with the upgrade prompt once all five are used.
+    r = client.post("/api/sources/url", headers=auth, json={"url": "https://example.com/a-post"})
+    assert r.status_code == 402 and r.json()["detail"]["kind"] == "indexed_posts" and r.json()["detail"]["upgrade_to"] == "writer"
+    assert client.post("/api/sources/upload", headers=auth, json={"upload_id": "00000000-0000-0000-0000-000000000000"}).status_code == 404
+    assert (PLANS["writer"].indexed_posts, PLANS["studio"].indexed_posts) == (100, 250)
+
+
+def test_free_allowances_are_totals_and_paid_ones_are_monthly(client, auth, billing_on, db_session):
+    from app.services.plans import PLANS
+    from app.services.usage import check_limit, month_usage
+
+    ws = db_session.query(Workspace).one()
+    free, writer, studio = PLANS["free"], PLANS["writer"], PLANS["studio"]
+    assert (free.videos, free.audio_overviews, free.launch_kits, free.infographics) == (2, 1, 2, 2) and free.lifetime
+    assert (writer.launch_kits, writer.audio_minutes, writer.reports) == (20, 60, 30) and not writer.lifetime
+    assert (studio.launch_kits, studio.audio_minutes, studio.reports) == (50, 240, -1)
+
+    old = Artifact(workspace_id=ws.id, type="infographic", status="ready")
+    db_session.add_all([old, Artifact(workspace_id=ws.id, type="infographic", status="failed")])
+    db_session.commit()
+    # An infographic made in an earlier month still counts on Free, a failed one never does.
+    from datetime import UTC, datetime, timedelta
+
+    old.created_at = datetime.now(UTC) - timedelta(days=90)
+    db_session.commit()
+    assert month_usage(db_session, ws.id, lifetime=True)["infographics"] == 1
+    assert month_usage(db_session, ws.id, lifetime=False)["infographics"] == 1  # (the failed one is this month's)
+    db_session.add(Artifact(workspace_id=ws.id, type="infographic", status="ready"))
+    db_session.commit()
+    with pytest.raises(Exception) as err:
+        check_limit(db_session, ws, "infographics", 1)
+    assert err.value.status_code == 402 and "in total" in err.value.detail["message"]
+    # Deleting one gives its place back.
+    db_session.delete(old)
+    db_session.commit()
+    check_limit(db_session, ws, "infographics", 1)
 
 
 def test_checkout_guards(client, auth, billing_on, db_session):
@@ -100,7 +169,7 @@ def plans_table(monkeypatch):
             db.add(PlanRecord(id=p.id, sort_order=i, name=p.name, tagline=p.tagline,
                               price_monthly_usd=p.price_monthly_usd, sources=p.sources, indexed_posts=p.indexed_posts,
                               audio_minutes=p.audio_minutes, videos=p.videos, launch_kits=p.launch_kits,
-                              voice_cloning=p.voice_cloning, brand_kit=p.brand_kit, features=list(p.features)))
+                              voice_cloning=p.voice_cloning, features=list(p.features)))
         db.commit()
     PLANS.reload()
     yield session_factory

backend/tests/test_buildout.py

@@ -939,11 +939,10 @@ def test_publish_now_with_media_goes_through_a_job(client, auth, db_session, mon
 def test_settings_and_usage(client, auth):
     s = client.get("/api/settings", headers=auth).json()
     assert s["user"]["name"] == "Ada Lovelace" and s["usage"]["used"]["launch_kits"] == 0
-    r = client.patch("/api/settings", json={"name": "Ada L", "workspace_name": "Ada HQ", "brand_accent": "#FF0000",
+    r = client.patch("/api/settings", json={"name": "Ada L", "workspace_name": "Ada HQ",
                                             "training_opt_in": True}, headers=auth).json()
     assert r["user"]["name"] == "Ada L" and r["workspace"]["name"] == "Ada HQ"
-    assert r["brand"]["accent"] == "#ff0000" and r["workspace"]["training_opt_in"] is True
-    assert client.patch("/api/settings", json={"brand_accent": "red"}, headers=auth).status_code == 422
+    assert r["workspace"]["training_opt_in"] is True and "brand" not in r
 
 
 def test_active_jobs_listing(client, auth, feed):
@@ -1657,14 +1656,7 @@ def test_flashcards_drop_repeats_empties_and_invented_sources(client, auth, run_
 
 
 def _make_report(client, auth, run_jobs, llm, pricing, nb):
-    good = {"path": pricing["path"], "line_start": 1, "line_end": 3}
-    fake = {"path": "sources/fake.md", "line_start": 1, "line_end": 2}
-    llm["WriteReport"] = {"report_title": "Pricing Brief", "markdown": "## One\nFirst point [1].\n\n## Two\nSecond [2].",
-                          "citations": [{"marker": 1, **good}, {"marker": 2, **fake}]}
-    llm["SuggestEmbeds"] = {"suggestions": [
-        {"after_block_id": "b1", "kind": "flashcards", "brief": "Terms", "why": "Learn them"},
-        {"after_block_id": "nope", "kind": "quiz", "brief": "x", "why": "y"},
-        {"after_block_id": "b2", "kind": "mind_map", "brief": "Links", "why": "See them"}]}
+    llm["WriteReport"] = {"report_title": "Pricing Brief", "markdown": "## One\nFirst point [1].\n\n## Two\nSecond [2]."}
     art = client.post("/api/artifacts/generate", json={
         "type": "report", "notebook_id": nb["id"], "document_ids": [pricing["id"]], "report_format": "document",
         "template_id": "briefing", "instructions": "Write a brief."}, headers=auth).json()
@@ -1672,15 +1664,15 @@ def _make_report(client, auth, run_jobs, llm, pricing, nb):
     return client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
 
 
-def test_document_report_is_blocks_with_checked_citations_and_suggestions(client, auth, run_jobs, feed, llm):
+def test_document_report_is_blocks_without_citations_and_with_the_posts_it_was_made_from(client, auth, run_jobs, feed, llm):
     pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
     done = _make_report(client, auth, run_jobs, llm, pricing, nb)
     c = done["content"]
     assert done["status"] == "ready" and done["type_label"] == "Report" and c["format"] == "document"
     assert [b["type"] for b in c["blocks"]] == ["prose", "prose"] and c["blocks"][0]["id"] == "b1"
-    assert len(c["citations"]) == 1 and "[2]" not in c["blocks"][1]["text"]  # the invented source was dropped
-    assert [s["after_block_id"] for s in c["suggestions"]] == ["b1", "b2"]  # the unknown section was dropped
-    assert c["sources"][0]["title"] == "On Pricing"
+    assert c["citations"] == [] and not any("[" in b["text"] for b in c["blocks"])  # a report cites nothing: markers are removed
+    assert c["suggestions"] == []  # a document never offers visuals; only an interactive report does
+    assert c["sources"][0]["title"] == "On Pricing" and c["instructions"] == "Write a brief."  # what the drop-down shows
 
 
 def test_add_and_remove_a_suggested_visual(client, auth, run_jobs, feed, llm):
@@ -1688,15 +1680,22 @@ def test_add_and_remove_a_suggested_visual(client, auth, run_jobs, feed, llm):
     done = _make_report(client, auth, run_jobs, llm, pricing, nb)
     llm["GenerateFlashcards"] = {"cards": [{"front": "Term", "back": "Meaning", "sources": []}]}
     r = client.post(f"/api/reports/{done['id']}/blocks", json={
-        "kind": "flashcards", "after_block_id": "b1", "suggestion_id": "s1", "brief": "Terms"}, headers=auth)
+        "kind": "flashcards", "after_block_id": "b1", "brief": "Terms"}, headers=auth)
     assert r.status_code == 200, r.text
     run_jobs()
     c = client.get(f"/api/artifacts/{done['id']}", headers=auth).json()["content"]
     assert [b["type"] for b in c["blocks"]] == ["prose", "flashcards", "prose"]
-    assert c["blocks"][1]["after"] == "b1" and [s["id"] for s in c["suggestions"]] == ["s2"]
+    assert c["blocks"][1]["after"] == "b1" and c["suggestions"] == []
     added = c["blocks"][1]["id"]
+
+    def saved_sets():
+        items = client.get("/api/artifacts", params={"type": "flashcards", "notebook_id": nb["id"]}, headers=auth).json()
+        return [a for a in (items["items"] if isinstance(items, dict) else items) if a["status"] == "ready"]
+
+    assert len(saved_sets()) == 1  # a set made in the report is also in the notebook's Studio list
     assert client.delete(f"/api/reports/{done['id']}/blocks/b1", headers=auth).status_code == 404  # prose stays
     assert client.delete(f"/api/reports/{done['id']}/blocks/{added}", headers=auth).status_code == 200
+    assert len(saved_sets()) == 1  # still there to use again, and not saved twice
     # a kind of visual the report does not know is refused
     assert client.post(f"/api/reports/{done['id']}/blocks", json={"kind": "poem"}, headers=auth).status_code == 422
 
@@ -1743,7 +1742,7 @@ def test_interactive_report_only_suggests_visuals_until_the_reader_adds_them(cli
         {"heading": "Compare", "brief": "b",
          "embed": {"kind": "table", "title": "Options", "brief": "options", "why": "Not a kind we offer"}}]}
     monkeypatch.setattr(run, "predict_many", lambda sig, inputs, **kw: [
-        {"markdown": f"Body {i} [1].", "citations": [{"marker": 1, **good}]} for i, _ in enumerate(inputs)])
+        {"markdown": f"Body {i} [1]."} for i, _ in enumerate(inputs)])
     art = client.post("/api/artifacts/generate", json={
         "type": "report", "notebook_id": nb["id"], "document_ids": [pricing["id"]], "report_format": "interactive",
         "instructions": "Make it interactive."}, headers=auth).json()
@@ -1751,9 +1750,11 @@ def test_interactive_report_only_suggests_visuals_until_the_reader_adds_them(cli
     c = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()["content"]
     assert c["format"] == "interactive"
     assert [b["type"] for b in c["blocks"]] == ["prose", "prose", "prose"]  # nothing is built until the reader asks
-    assert [(s["after_block_id"], s["kind"]) for s in c["suggestions"]] == [("b1", "flashcards")]  # a table is not a visual we offer
+    # a table is not a visual we offer; the plan suggested no infographic, so one is offered before the last section
+    assert [(s["after_block_id"], s["kind"]) for s in c["suggestions"]] == [
+        ("b1", "flashcards"), ("b2", "infographic"), ("b2", "quiz")]  # filled up to three
     assert "GenerateFlashcards" not in llm["_calls"]
-    assert [x["marker"] for x in c["citations"]] == [1, 2, 3] and "[3]" in c["blocks"][2]["text"]  # renumbered
+    assert c["citations"] == [] and not any("[" in b["text"] for b in c["blocks"])  # nothing is cited
 
     r = client.post(f"/api/reports/{art['id']}/blocks", json={
         "kind": "table", "after_block_id": "b3", "brief": "options"}, headers=auth)
@@ -1799,11 +1800,10 @@ def test_quiz_can_be_made_from_posts_and_chats_together(client, auth, run_jobs,
     assert any(m.startswith("FILE ") for m in seen["material"]) and any(m.startswith("CHAT ") for m in seen["material"])
 
 
-def test_a_quiz_section_the_ai_wrote_becomes_a_suggestion_unless_it_was_asked_for(client, auth, run_jobs, feed, llm):
+def test_a_document_report_keeps_whatever_sections_the_ai_wrote_and_suggests_nothing(client, auth, run_jobs, feed, llm):
     pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
     llm["WriteReport"] = {"report_title": "Pricing", "citations": [], "markdown":
                           "## Why price\nText.\n\n## How to raise\nMore.\n\n## Quick quiz\n1. What is a price? (Answer: x)"}
-    llm["SuggestEmbeds"] = {"suggestions": []}
 
     def make(instructions):
         art = client.post("/api/artifacts/generate", json={
@@ -1813,21 +1813,25 @@ def test_a_quiz_section_the_ai_wrote_becomes_a_suggestion_unless_it_was_asked_fo
         return client.get(f"/api/artifacts/{art['id']}", headers=auth).json()["content"]
 
     c = make("Write a short brief.")
-    assert [b["text"].split("\n")[0] for b in c["blocks"]] == ["## Why price", "## How to raise"]  # no quiz in the text
-    assert [(s["after_block_id"], s["kind"]) for s in c["suggestions"]] == [("b2", "quiz")]  # offered, not added
-
-    c = make("Write a study guide with a quiz at the end.")  # the reader asked for it: it stays
     assert [b["text"].split("\n")[0] for b in c["blocks"]][-1] == "## Quick quiz" and c["suggestions"] == []
 
 
 # ---- infographics ----------------------------------------------------------------------------------------------
 
 def _fake_infographic(**over):
-    out = {"title": "Pricing <script>x</script> Plan", "subtitle": "How to raise prices", "items_label": "Ideas",
-           "items": [{"name": f"Idea {i}", "text": "A short plain sentence about it."} for i in range(4)],
-           "steps_label": "Steps", "steps": [{"name": f"Step {i}", "text": "Do the thing."} for i in range(5)],
+    nodes = "".join(f'<div class="node"><span class="n-no">0{i}</span><span class="n-t">Idea {i}</span>'
+                    '<span class="n-d">A short plain sentence about it.</span></div>' for i in range(4))
+    out = {"title": "Pricing <script>x</script> Plan", "subtitle": "How to raise prices", "eyebrow": "Pricing", "key_figures": [{"value": "30%", "label": "Raise carefully"}, {"value": "x" * 40, "label": "<b>Long</b> one"}],
+           "body_html": f'<section class="sec"><div class="sec-t">Ideas</div><div class="flow">{nodes}</div></section>'
+                        '<script>bad()</script><img src=x onerror=alert(1)><a href="http://evil.test">a link that stays as plain text</a>',
            "rule": "Raise slowly.", "notes": ["One.", "Two.", "Three."]}
-    return {"infographic": {**out, **over}}
+    return {"design": {**out, **over}}
+
+
+@pytest.fixture(autouse=True)
+def _no_chrome_fit(monkeypatch):
+    """The fit of an infographic is measured in Chrome when it is made; tests do not need a browser."""
+    monkeypatch.setattr("app.pipeline.infographic.measure_fit", lambda html, layout: 1.0)
 
 
 def test_every_theme_escapes_and_clamps_model_text():
@@ -1844,22 +1848,26 @@ def test_every_theme_escapes_and_clamps_model_text():
         html = build_html(tid, evil)
         assert "<script" not in html and "onerror" not in html and "Hello" in html, tid
     for tid in THEMES:
-        assert '<div class="mark">notestack.ai</div>' in build_html(tid, evil)  # every theme carries the mark
+        html = build_html(tid, evil)
+        assert 'class="mark"' in html and "<span>notestack.ai</span>" in html  # every theme carries the mark (logo and name)
 
 
 def test_infographic_is_a_page_at_once_and_can_be_shared_by_link(client, auth, run_jobs, feed, llm):
     pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
     llm["ExtractIdeas"] = {"ideas": []}
-    llm["PlanInfographic"] = _fake_infographic()
+    llm["DesignInfographic"] = _fake_infographic()
     art = client.post("/api/artifacts/generate", json={"type": "infographic", "notebook_id": nb["id"],
-                      "document_ids": [pricing["id"]], "theme": "galaxy", "instructions": "About raising prices"},
+                      "document_ids": [pricing["id"]], "theme": "paper", "ig_style": "flowchart", "instructions": "About raising prices"},
                       headers=auth).json()
     assert art["type_label"] == "Infographic"
     run_jobs()
     done = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
-    assert done["status"] == "ready" and done["content"]["theme"] == "galaxy" and not done["download_url"]
-    assert "Idea 0" in done["content"]["html"] and "<script" not in done["content"]["html"]
-    assert 'class="mark">notestack.ai' in done["content"]["html"]
+    assert done["status"] == "ready" and done["content"]["theme"] == "paper" and not done["download_url"]
+    html = done["content"]["html"]
+    assert "Idea 0" in html and "<script" not in html and "<img" not in html and "evil.test" not in html and "onerror" not in html
+    assert 'class="fig-v">30%<' in html
+    assert "notestack.ai" in html and "html_landscape" in done["content"] and "ig2 look-paper landscape" in done["content"]["html_landscape"]
+    assert done["content"]["content"]["fit"] == {"landscape": 1.0, "portrait": 1.0}
 
     share = client.post(f"/api/artifacts/{art['id']}/share", headers=auth).json()
     assert share["shared"] and "/r/" in share["url"]
@@ -1879,7 +1887,7 @@ def test_infographic_needs_a_source_and_enough_text_and_obeys_its_limit(client,
 
     pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
     llm["ExtractIdeas"] = {"ideas": []}
-    llm["PlanInfographic"] = _fake_infographic(items=[])
+    llm["DesignInfographic"] = _fake_infographic(body_html="")
     art = client.post("/api/artifacts/generate", json={"type": "infographic", "notebook_id": nb["id"],
                       "document_ids": [pricing["id"]]}, headers=auth).json()
     run_jobs()
@@ -1903,15 +1911,95 @@ def test_a_report_can_add_an_infographic_that_shows_on_the_shared_page(client, a
     pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
     done = _make_report(client, auth, run_jobs, llm, pricing, nb)
     llm["ExtractIdeas"] = {"ideas": []}
-    llm["PlanInfographic"] = _fake_infographic()
+    llm["DesignInfographic"] = _fake_infographic()
     r = client.post(f"/api/reports/{done['id']}/blocks", json={"kind": "infographic", "after_block_id": "b1",
-                    "brief": "The steps to raise prices", "theme": "moonbase"}, headers=auth)
+                    "brief": "The steps to raise prices", "theme": "paper"}, headers=auth)
     assert r.status_code == 200, r.text
     run_jobs()  # adds the block, and writes the infographic it points at
     block = next(b for b in client.get(f"/api/artifacts/{done['id']}", headers=auth).json()["content"]["blocks"]
                  if b["type"] == "infographic")
-    assert block["theme"] == "moonbase" and block["status"] == "ready" and "Idea 0" in block["html"]
+    assert block["theme"] == "paper" and block["status"] == "ready" and "Idea 0" in block["html"]
     token = client.post(f"/api/artifacts/{done['id']}/share", headers=auth).json()["url"].rsplit("/", 1)[1]
     public = client.get(f"/api/public/reports/{token}").json()
     shared = next(b for b in public["blocks"] if b["type"] == "infographic")
     assert "Idea 0" in shared["html"] and "artifact_id" not in shared and "theme" not in shared
+
+
+def test_a_composed_infographic_keeps_only_allowed_markup_and_draws_in_every_look():
+    from app.infographics.design import LOOKS, SAMPLE, build_content, render_design, sanitize_body
+    from app.infographics.render import SIZES
+
+    dirty = ('<div class="node evil" style="x:y" onclick="a()" id="k"><span class="n-t">A node title long enough to count</span>'
+             '<script>bad()</script><iframe src="http://x"></iframe><svg><circle/></svg><a href="http://e.test">words that stay</a>'
+             '<span class="n-d">Another line of readable text here — with a dash</span></div>')
+    clean = sanitize_body(dirty)
+    assert clean and 'class="node"' in clean
+    for bad in ("style", "onclick", "id=", "<script", "<iframe", "<svg", "<a ", "href", "evil.test", "—"):
+        assert bad not in clean
+    assert "words that stay" in clean
+    assert sanitize_body("") is None and sanitize_body("<div></div>") is None and sanitize_body("<script>x()</script>") is None
+    assert sanitize_body('<div class="node">' + "word " * 5000 + "</div>") is None  # more than a poster holds
+    figs = build_content({**SAMPLE, "title": "<b>Hi</b> there", "key_figures": [{"value": "9" * 40, "label": "<i>Up</i> a lot"}, {"value": "", "label": "none"}]})["key_figures"]
+    assert figs == [{"value": "9" * 13 + "…", "label": "Up a lot"}]
+    assert build_content({**SAMPLE, "body_html": "<p></p>"}) is None
+    for look in LOOKS:
+        for layout in SIZES:
+            html = render_design(look, SAMPLE, layout)
+            assert f"look-{look} {layout}" in html and "notestack.ai" in html and "<script" not in html
+    assert "--fit:0.7" in render_design("mono", {**SAMPLE, "fit": {"portrait": 0.7}}, "portrait")
+
+
+def test_artifacts_can_be_rated_with_a_thumb_and_reasons(client, auth, run_jobs, feed, llm):
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    llm["ExtractIdeas"] = {"ideas": []}
+    llm["DesignInfographic"] = _fake_infographic()
+    art = client.post("/api/artifacts/generate", json={"type": "infographic", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]]}, headers=auth).json()
+    # Not finished yet: nothing to rate
+    assert client.put(f"/api/artifacts/{art['id']}/feedback", json={"rating": "up"}, headers=auth).status_code == 400
+    run_jobs()
+    url = f"/api/artifacts/{art['id']}/feedback"
+    assert client.get(f"/api/artifacts/{art['id']}", headers=auth).json()["feedback"] is None
+
+    up = client.put(url, json={"rating": "up"}, headers=auth).json()["feedback"]
+    assert up == {"rating": "up", "reasons": [], "comment": None}
+    listed = client.get(f"/api/notebooks/{nb['id']}/artifacts", headers=auth).json()
+    assert next(a for a in listed if a["id"] == art["id"])["feedback"]["rating"] == "up"
+
+    # Rating again replaces it; unknown reasons are dropped, known ones for this kind kept; a thumbs up carries none
+    down = client.put(url, json={"rating": "down", "reasons": ["messy_layout", "nonsense", "wrong_answers"],
+                                 "comment": "  Boxes overlap  "}, headers=auth).json()["feedback"]
+    assert down == {"rating": "down", "reasons": ["messy_layout"], "comment": "Boxes overlap"}
+    assert client.get("/api/artifacts?type=infographic", headers=auth).json()["items"][0]["feedback"]["rating"] == "down"
+    rows = client.get("/api/artifacts/feedback/export?rating=down", headers=auth).json()
+    assert len(rows) == 1 and rows[0]["type"] == "infographic" and rows[0]["snapshot"]["layout"] == "composed"
+    assert client.get("/api/artifacts/feedback/export?rating=up", headers=auth).json() == []
+
+    assert client.put(url, json={"rating": None}, headers=auth).json() == {"feedback": None}
+    assert client.get(f"/api/artifacts/{art['id']}", headers=auth).json()["feedback"] is None
+
+    # Only reports, quizzes, flashcards and infographics are rated
+    summary = client.post("/api/artifacts/generate", json={"type": "summary", "notebook_id": nb["id"]}, headers=auth).json()
+    assert "feedback" not in summary
+    assert client.put(f"/api/artifacts/{summary['id']}/feedback", json={"rating": "up"}, headers=auth).status_code == 400
+
+
+def test_rating_an_artifact_is_logged_without_the_comment_text(client, auth, run_jobs, feed, llm, caplog):
+    import logging
+
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    llm["ExtractIdeas"] = {"ideas": []}
+    llm["DesignInfographic"] = _fake_infographic()
+    art = client.post("/api/artifacts/generate", json={"type": "infographic", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]]}, headers=auth).json()
+    url = f"/api/artifacts/{art['id']}/feedback"
+    with caplog.at_level(logging.INFO, logger="app.routers.artifacts"):
+        client.put(url, json={"rating": "up"}, headers=auth)  # not finished: refused, and said so
+        run_jobs()
+        client.put(url, json={"rating": "down", "reasons": ["messy_layout"], "comment": "private words here"}, headers=auth)
+        client.get("/api/artifacts/feedback/export", headers=auth)
+        client.put(url, json={"rating": None}, headers=auth)
+    text = "\n".join(r.getMessage() for r in caplog.records)
+    assert "feedback refused" in text and "feedback saved" in text and "feedback exported" in text and "feedback removed" in text
+    assert art["id"] in text and "rating=down" in text and "messy_layout" in text and "comment_chars=18" in text
+    assert "private words here" not in text

backend/tests/test_support.py

@@ -232,7 +232,7 @@ def test_create_panel_buttons_in_the_docs_exist_in_the_app():
     """The docs name the Create panel's buttons; each must still be a real button in NotebookView."""
     view = (FRONTEND / "pages" / "NotebookView.tsx").read_text(encoding="utf-8")
     docs = " ".join(d.body for d in get_corpus())
-    for label in ("Report", "Summary", "Infographic", "Quiz", "Flashcards", "Mind Constellation", "Video"):
+    for label in ("Report", "Infographic", "Quiz", "Flashcards", "Mind Constellation", "Video"):
         assert re.search(rf">\s*{label}\s*<", view) or re.search(rf"\n\s*{label}\n", view), f"{label} button is gone"
         assert f"**{label}**" in docs, f"{label} is not documented"
 
@@ -272,7 +272,6 @@ def test_plan_doc_matches_the_plan_table():
     ("why did I get an email reminder instead of an auto post", "launchpad"),
     ("how does voice cloning work", "voice-profile"),
     ("what is the topic map", "topic-map-and-resurfacing"),
-    ("how do I add my logo and brand colors", "settings-and-account"),
     ("how do I delete my account", "settings-and-account"),
     ("how much does the writer plan cost", "plans-and-billing"),
     ("what is in the free plan", "plans-and-billing"),

backend/tests/test_videos.py

@@ -237,7 +237,7 @@ def test_link_create_forwards_every_wizard_field(client, b2v, owner, db_session)
             "video_length": "medium", "logo_position": "top_left", "logo_opacity": 0.5, "template": "geometric",
             "video_style": "storytelling", "accent_color": "#FF5A1F", "bg_color": "#0B0B0F", "text_color": "#FFFFFF",
             "content_language": "es", "voice_gender": "female", "voice_accent": "british",
-            "custom_voice_id": SARAH, "voice_emotion": '["0.5","1.0","calm","0","1"]',
+            "custom_voice_id": SARAH,
             "bgm_track_id": "corporate_upbeat", "bgm_volume": 0.2}
     art = make_video(client, headers, **body)
     call = creates(b2v)[0]
@@ -508,12 +508,9 @@ def test_foreign_references_are_refused_before_calling_out(client, b2v, owner, t
 def test_own_references_pass(client, b2v, owner, db_session):
     headers, ws = owner
     db_session.add_all([B2VTemplate(b2v_template_id=58, workspace_id=ws.id, name="Mine", ready=True),
-                        B2VStyle(b2v_style_id=7, workspace_id=ws.id, name="Mine"),
-                        B2VCustomVoice(b2v_custom_voice_id=31, workspace_id=ws.id, voice_id="vc_mine", name="M",
-                                       source="prompt")])
+                        B2VStyle(b2v_style_id=7, workspace_id=ws.id, name="Mine")])
     db_session.commit()
-    make_video(client, headers, template="custom_58", video_style="custom:7", custom_voice_id="vc_mine")
-    make_video(client, headers, template="crafted_neon")
+    make_video(client, headers, template="custom_58", video_style="custom:7", custom_voice_id=SARAH)
 
 
 def test_template_still_generating_is_refused(client, b2v, owner, db_session):
@@ -566,7 +563,7 @@ def test_catalog_offers_only_the_house_styles(client, b2v, owner, house, db_sess
 
 @pytest.mark.parametrize("style,length", [("custom:20", "short"), ("custom:21", "medium")])
 def test_house_style_sets_the_length(client, b2v, owner, house, free_plan, style, length):
-    make_video(client, owner[0], video_style=style, video_length="detailed")
+    make_video(client, owner[0], video_style=style, video_length="short" if style == "custom:21" else "medium")
     sent = creates(b2v)[-1]["json"]
     assert sent["video_style"] == style and sent["video_length"] == length
 
@@ -910,17 +907,15 @@ def test_chat_with_a_focus_keeps_the_chat_context_first(client, b2v, owner, hous
     assert content.startswith(CHAT_CONTEXT) and content.index('"Annual raises"') < content.index("User:")
 
 
-# Premium (★) and per-workspace counters
+# The standard options only, and per-workspace counters
 
 
 @pytest.mark.parametrize("body", [{"video_length": "detailed"}, {"video_length": "more_detailed"},
-                                  {"custom_voice_id": BELLA}, {"voice_emotion": '["0.5","1.0","calm","0","1"]'},
-                                  {"template": "crafted_neon"}])
-def test_premium_options_refused_on_free(client, b2v, owner, free_plan, db_session, body):
+                                  {"custom_voice_id": BELLA}, {"template": "crafted_neon"}])
+def test_options_that_are_not_offered_are_refused_on_every_plan(client, b2v, owner, body):
     headers, ws = owner
     r = client.post("/api/videos", json={"url": "https://a.test/x", **body}, headers=headers)
-    assert r.status_code == 402 and r.json()["detail"]["kind"] == "video_premium" and not creates(b2v)
-    assert r.json()["detail"]["upgrade_to"] == "writer"
+    assert r.status_code in (400, 404, 422) and not creates(b2v)
 
 
 def test_free_plan_can_make_a_plain_video(client, b2v, owner, free_plan):
@@ -944,18 +939,10 @@ def test_ai_edits_stop_at_the_workspace_limit(client, b2v, owner, db_session):
                                 used=1000))
     db_session.commit()
     b2v.calls.clear()
-    r = client.post(f"/api/videos/{art['id']}/p/chat", json={"message": "shorter"}, headers=headers)
+    r = client.post(f"/api/videos/{art['id']}/p/scenes/1/regenerate", json={"description": "shorter"}, headers=headers)
     assert r.status_code == 402 and r.json()["detail"]["kind"] == "video_limits.ai_edits" and b2v.calls == []
 
 
-def test_avatar_batch_charges_ten_per_scene(client, b2v, owner, db_session):
-    headers, ws = owner
-    art = make_video(client, headers)
-    r = client.post(f"/api/videos/{art['id']}/p/avatar-batch/authorize", json={"scene_ids": [1, 2, 3]},
-                    headers=headers)
-    assert r.status_code == 200 and video_limits.used(db_session, ws.id, "ai_edits") == 30
-
-
 def test_template_switch_uses_a_video_and_checks_the_template(client, b2v, owner, theirs, db_session):
     headers, ws = owner
     art = make_video(client, headers)
@@ -1019,12 +1006,14 @@ def test_editor_passes_downloads_through(client, b2v, owner):
     assert r.status_code == 200 and r.content == b"ID3audio" and r.headers["content-type"] == "audio/mpeg"
 
 
-def test_editor_premium_features_refused_on_free(client, b2v, owner, free_plan):
+def test_removed_editor_features_are_not_proxied(client, b2v, owner):
     headers, _ = owner
     art = make_video(client, headers)
-    for method, path in [("POST", "chat"), ("GET", "download-studio"), ("POST", "avatar-portrait")]:
-        r = client.request(method, f"/api/videos/{art['id']}/p/{path}", json={}, headers=headers)
-        assert r.status_code == 402, path
+    b2v.calls.clear()
+    for method, path in [("POST", "chat"), ("GET", "chat/history"), ("GET", "download-studio"),
+                         ("POST", "avatar-portrait"), ("POST", "avatar-batch/authorize")]:
+        assert client.request(method, f"/api/videos/{art['id']}/p/{path}", json={}, headers=headers).status_code == 404
+    assert b2v.calls == []
 
 
 # Script review
@@ -1036,9 +1025,9 @@ def test_script_review_flow(client, b2v, owner, db_session):
     scenes = client.get(f"/api/videos/{art['id']}/script", headers=headers).json()["scenes"]
     assert [s["id"] for s in scenes] == [1, 2]
     draft = {"title": "A", "display_text": "Text", "narration_text": "", "draft_scenes": [], "revision": 1}
-    client.post(f"/api/videos/{art['id']}/script/scenes/1/ai-preview", json={**draft, "instruction": "punchier"},
-                headers=headers)
-    assert video_limits.used(db_session, ws.id, "ai_edits") == 1
+    r = client.post(f"/api/videos/{art['id']}/script/scenes/1/ai-preview", json={**draft, "instruction": "punchier"},
+                    headers=headers)
+    assert r.status_code in (404, 405)  # rewriting a scene with AI is not offered
     r = client.post(f"/api/videos/{art['id']}/script/approve",
                     json={"scenes": [{"id": 1, "title": "A", "narration_text": "Hi"}]}, headers=headers)
     assert r.status_code == 200 and "/api/projects/812/script-review/approve" in b2v.paths("POST")
@@ -1136,12 +1125,14 @@ def test_capacity_alert(b2v, caplog):
 def test_new_workspace_gets_starter_voices_and_library(client, b2v, owner):
     got = client.get("/api/video-voices", headers=owner[0]).json()
     assert [v["voice_id"] for v in got["saved"]] == [SARAH]  # free voices only
-    assert {v["voice_id"]: v["premium"] for v in got["library"]} == {SARAH: False, BELLA: True}
+    assert [v["voice_id"] for v in got["library"]] == [SARAH]  # the paid voice is not offered
+    assert "custom" not in got and all("premium" not in v for v in got["saved"] + got["library"])
 
 
-def test_saving_a_paid_voice_needs_premium(client, b2v, owner, free_plan):
-    r = client.post("/api/video-voices/saved", json={"voice_id": BELLA}, headers=owner[0])
-    assert r.status_code == 402
+def test_a_paid_voice_cannot_be_saved_or_used_on_any_plan(client, b2v, owner):
+    assert client.post("/api/video-voices/saved", json={"voice_id": BELLA}, headers=owner[0]).status_code == 404
+    r = client.post("/api/videos", json={"url": "https://a.test/x", "custom_voice_id": BELLA}, headers=owner[0])
+    assert r.status_code == 404 and not creates(b2v)
 
 
 def test_saved_voices_never_touch_blog2video_saved_list(client, b2v, owner, db_session):
@@ -1163,36 +1154,22 @@ def test_any_number_of_voices_can_be_saved(client, b2v, owner, db_session):
     for i in range(7):
         db_session.add(UserSavedVoice(workspace_id=ws.id, voice_id=f"v{i}", name=f"V{i}"))
     db_session.commit()
-    assert client.post("/api/video-voices/saved", json={"voice_id": BELLA}, headers=headers).status_code == 201
+    assert client.post("/api/video-voices/saved", json={"voice_id": SARAH}, headers=headers).status_code in (200, 201)
     got = client.get("/api/video-voices", headers=headers).json()
-    assert len(got["saved"]) == 9 and "max_saved" not in got
+    assert len(got["saved"]) == 8 and "max_saved" not in got
 
 
-def test_notestack_voices_can_be_saved_and_used_in_a_video(client, b2v, owner, other, db_session):
+def test_notestack_voices_are_saved_for_audio_but_not_used_in_videos(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"]
+    assert r.status_code == 201 and r.json()["source"] == "notestack"
     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_are_saved_on_any_plan_but_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 == 201  # in the list, for audio overviews
+    assert [v["source"] for v in saved if v["voice_id"] == "nv_narrator"] == ["notestack"]  # kept, for audio overviews
     r = client.post("/api/videos", json={"url": "https://a.test/x", "custom_voice_id": "nv_narrator"}, headers=headers)
-    assert r.status_code == 402 and not creates(b2v)
+    assert r.status_code == 404 and not creates(b2v)  # a video uses the free built-in voices
 
 
 def test_revoking_the_clone_drops_it_from_video_voices(client, b2v, owner, db_session, monkeypatch):
@@ -1207,37 +1184,11 @@ def test_revoking_the_clone_drops_it_from_video_voices(client, b2v, owner, db_se
     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"},
-                           headers=headers).json()["previews"]
-    kept = client.post("/api/video-voices/custom", json={"generated_voice_id": previews[0]["generated_voice_id"],
-                                                         "source": "prompt", "name": "Narrator"}, headers=headers)
-    assert kept.status_code == 201
-    assert db_session.get(UserSavedVoice, {"workspace_id": ws.id, "voice_id": "vc_designed"}).is_custom
-    assert video_limits.used(db_session, ws.id, "voice_designs_daily") == 1
-    assert video_limits.used(db_session, ws.id, "custom_voices") == 1
-    # Another workspace can not play or delete it, nor use it on a video.
-    assert client.get("/api/video-voices/custom/31/preview", headers=other[0]).status_code == 404
-    assert client.delete("/api/video-voices/custom/31", headers=other[0]).status_code == 404
-    r = client.post("/api/videos", json={"url": "https://a.test/x", "custom_voice_id": "vc_designed"},
-                    headers=other[0])
-    assert r.status_code == 404
-    assert client.delete("/api/video-voices/custom/31", headers=headers).status_code == 200
-    assert video_limits.used(db_session, ws.id, "custom_voices") == 0
-
-
-def test_clone_voice(client, b2v, owner):
-    r = client.post("/api/video-voices/clone", data={"name": "Me"}, files={"file": ("me.mp3", b"ID3", "audio/mpeg")},
-                    headers=owner[0])
-    assert r.status_code == 201 and r.json()["voice_id"] == "vc_clone"
-
-
-def test_voice_sample_returns_audio_and_counts(client, b2v, owner, db_session):
-    headers, ws = owner
-    r = client.post("/api/video-voices/sample", json={"custom_voice_id": SARAH}, headers=headers)
-    assert r.status_code == 200 and r.content == b"ID3audio"
-    assert video_limits.used(db_session, ws.id, "voice_samples_daily") == 1
+def test_designing_cloning_and_sampling_voices_for_videos_are_gone(client, b2v, owner):
+    headers, _ = owner
+    for method, path in [("POST", "design/prompt"), ("POST", "design/preset"), ("POST", "custom"), ("POST", "clone"),
+                         ("POST", "sample"), ("GET", "custom/31/preview"), ("DELETE", "custom/31")]:
+        assert client.request(method, f"/api/video-voices/{path}", json={}, headers=headers).status_code in (404, 405), path
 
 
 # Styles
@@ -1324,7 +1275,7 @@ def test_sync_follows_effective_plan(client, owner, db_session, monkeypatch):
     sub.status = "canceled"
     db_session.commit()
     sub = video_quota.sync_video_quota(db_session, ws)
-    assert (sub.video_plan, sub.video_limit) == ("free", 1)
+    assert (sub.video_plan, sub.video_limit) == ("free", 2)
 
 
 def test_monthly_fallback_reset(client, owner, db_session, session_factory):
@@ -1405,15 +1356,16 @@ def test_plan_video_limits(client, owner, db_session, monkeypatch):
     _, ws = owner
     monkeypatch.setattr(settings, "billing_enabled", True)
     video_quota.sync_video_quota(db_session, ws)
-    for plan, limit in (("free", 1), ("writer", 10), ("studio", 20)):
+    for plan, limit in (("free", 2), ("writer", 10), ("studio", 20)):
         _on_plan(db_session, ws, plan)
         assert video_quota.sync_video_quota(db_session, ws).video_limit == limit
 
 
-def test_free_is_one_video_in_total(client, b2v, owner, free_plan, db_session, session_factory):
+def test_free_is_two_videos_in_total(client, b2v, owner, free_plan, db_session, session_factory):
     headers, ws = owner
     make_video(client, headers)
-    r = client.post("/api/videos", json={"url": "https://a.test/2"}, headers=headers)
+    make_video(client, headers, url="https://a.test/2")
+    r = client.post("/api/videos", json={"url": "https://a.test/3"}, headers=headers)
     assert r.status_code == 402
     usage = client.get("/api/videos/quota", headers=headers).json()
     assert usage["resets_at"] is None
@@ -1424,7 +1376,7 @@ def test_free_is_one_video_in_total(client, b2v, owner, free_plan, db_session, s
     # Deleting the video does not give it back.
     art_id = db_session.scalar(select(B2VVideo)).artifact_id
     client.delete(f"/api/videos/{art_id}", headers=headers)
-    assert client.post("/api/videos", json={"url": "https://a.test/3"}, headers=headers).status_code == 402
+    assert client.post("/api/videos", json={"url": "https://a.test/4"}, headers=headers).status_code == 402
 
 
 def test_free_video_that_failed_is_given_back(client, b2v, owner, free_plan, db_session):
@@ -1443,7 +1395,7 @@ def test_dropping_to_free_counts_what_was_made(client, b2v, owner, db_session, m
         make_video(client, headers, url=f"https://a.test/{i}")
     _on_plan(db_session, ws, "free")
     usage = client.get("/api/videos/quota", headers=headers).json()
-    assert (usage["used"], usage["limit"]) == (3, 1)
+    assert (usage["used"], usage["limit"]) == (3, 2)
     assert client.post("/api/videos", json={"url": "https://a.test/x"}, headers=headers).status_code == 402
 
 

docs/BLOG2VIDEO.md

@@ -29,7 +29,7 @@ log an `ALERT` line and users see "temporarily unavailable".
 
 ## Ownership
 
-Everything made with the key (videos, custom templates, custom voices, styles) belongs to one blog2video account,
+Everything made with the key (videos, custom templates, styles) belongs to one blog2video account,
 and blog2video's ownership checks stop at the account. Notestack is the only place each workspace's things are kept
 apart (`backend/app/services/b2v_access.py`):
 
@@ -64,20 +64,19 @@ built-in style overrides, style pin/selection, "Your Style", script preferences)
 
 The live preview link comes from `POST /api/embed/token/{id}` and is safe for the browser.
 
-## Premium and per-workspace limits
+## Per-workspace limits
 
 blog2video checks every limit against our Pro account, so every workspace passes its checks. Notestack divides them:
-each plan row has `video_premium` (★: detailed lengths, paid and custom voices, advanced voice tuning, voice samples,
-AI script rewrites, AI chat, avatars, designer templates, the source download) and `video_limits`:
+each plan row has `video_limits`. There are no premium (★) video options: videos use the standard lengths (short,
+medium), the built-in templates and styles, and the free built-in voices. Notestack does not proxy AI chat editing,
+avatars, AI script or scene rewrites, AI template editing, designer templates, paid or custom voices, voice tuning,
+voice design or cloning for videos, or the source download.
 
 | Metric | Period | Free / Writer / Studio | Counts |
 |---|---|---|---|
-| `ai_edits` | month | 20 / 300 / 1000 | scene regenerate/add, AI image, stock clip, AI chat, AI rewrites, template AI edits, avatars (10 per scene) |
+| `ai_edits` | month | 20 / 300 / 1000 | scene regenerate/add, AI image, stock clip |
 | `templates` | lifetime | 0 / 2 / 5 | custom templates made (blog2video slots are never given back) |
 | `template_ai_daily` | day | 0 / 3 / 5 | theme from a document or prompt, code generation |
-| `voice_designs_daily` | day | 0 / 5 / 10 | voice designs |
-| `voice_samples_daily` | day | 0 / 20 / 40 | voice samples |
-| `custom_voices` | total | 0 / 3 / 10 | kept or cloned voices (a delete frees one) |
 
 Edit a plan row to change them. A counter is given back when blog2video refuses the call. A template switch also
 uses a video.

frontend/src/api/endpoints.ts

@@ -1,6 +1,7 @@
 import { api, apiBlob, del, patch, post, postForm, put, qs, uploadFile } from "./client";
 import type {
   AnswerFeedback,
+  QuizAttempt,
   Artifact,
   ArtifactType,
   BillingStatus,
@@ -50,8 +51,6 @@ import type {
   VideoCreateBody,
   VideoFocusSource,
   VideoFocusTopic,
-  VideoCustomVoice,
-  VideoDesignedVoice,
   VideoJobState,
   VideoListItem,
   VideoOptions,
@@ -141,8 +140,9 @@ export type GenerateBody = {
   report_format?: "document" | "interactive";
   template_id?: string;
   instructions?: string;
-  /** infographic: one of the premade themes (see components/Infographic.tsx); slide_deck: dark-space or light-space. */
+  /** infographic: one of the looks, and the kind of layout to lean towards (see components/Infographic.tsx); slide_deck: dark-space or light-space. */
   theme?: string;
+  ig_style?: string;
   /** slide_deck: read on its own ("detailed") or shown behind a speaker ("presenter"), and how many slides. */
   deck_format?: "detailed" | "presenter";
   deck_length?: "short" | "default" | "long";
@@ -158,6 +158,12 @@ export const artifactsApi = {
   remove: (id: string) => del(`/api/artifacts/${id}`),
   /** An infographic drawn as a PNG. */
   image: (id: string, layout: "landscape" | "portrait" = "landscape") => apiBlob(`/api/artifacts/${id}/image${qs({ layout })}`),
+  /** Thumbs up or down (null takes it back) on a finished report, quiz, flashcard set or infographic. */
+  rate: (id: string, body: { rating: "up" | "down" | null; reasons?: string[]; comment?: string }) =>
+    put<{ feedback: AnswerFeedback | null }>(`/api/artifacts/${id}/feedback`, body),
+  /** A quiz's finished run, kept so the result shows when it is opened again. */
+  saveAttempt: (id: string, body: { answers: QuizAttempt["answers"]; score: number }) =>
+    put<{ attempt: QuizAttempt }>(`/api/artifacts/${id}/attempt`, body),
   retry: (id: string) => post<Artifact>(`/api/artifacts/${id}/retry`),
   /** A slide deck as a PDF (exactly as shown) or an editable PowerPoint. */
   slidesFile: (id: string, ext: "pdf" | "pptx") => apiBlob(`/api/artifacts/${id}/slides.${ext}`),
@@ -285,9 +291,6 @@ export const resurfaceApi = {
 export type SettingsPatch = {
   name?: string;
   workspace_name?: string;
-  brand_name?: string;
-  brand_accent?: string;
-  logo_upload_id?: string;
   training_opt_in?: boolean;
   allow_public_links?: boolean;
   email_unsubscribed?: boolean;
@@ -297,6 +300,8 @@ export const settingsApi = {
   get: () => api<Settings>("/api/settings"),
   update: (body: SettingsPatch) => patch<Settings>("/api/settings", body),
   usage: () => api<Usage>("/api/settings/usage"),
+  /** How many posts a generated thing can read (set by the server's ARTIFACT_MAX_POSTS settings). */
+  limits: () => api<{ posts: number; selectable_posts: number }>("/api/settings/limits"),
 };
 
 export const memoryApi = {
@@ -374,8 +379,6 @@ export const videosApi = {
   script: (id: string) => api<{ status: string; scenes: ScriptScene[] }>(`/api/videos/${id}/script`),
   narrationPreview: (id: string, sceneId: number, body: ScriptDraft) =>
     post<ScriptPreview>(`/api/videos/${id}/script/scenes/${sceneId}/narration-preview`, body),
-  aiPreview: (id: string, sceneId: number, body: ScriptDraft & { instruction: string }) =>
-    post<ScriptPreview>(`/api/videos/${id}/script/scenes/${sceneId}/ai-preview`, body),
   approveScript: (id: string, scenes: (ScriptScene & { source_fingerprint?: string; accepted_ai_instructions?: string[] })[]) =>
     post<unknown>(`/api/videos/${id}/script/approve`, { scenes }),
 };
@@ -448,8 +451,7 @@ export const videoEditApi = {
   uploadVoiceover: (id: string, sceneId: number, audio: File) =>
     postForm<VideoScene>(P(id, `scenes/${sceneId}/voiceover`), form({ audio })),
   deleteVoiceover: (id: string) => post<unknown>(P(id, "delete-voiceover")),
-  changeVoice: (id: string, body: { voice_gender?: string; voice_accent?: string; custom_voice_id?: string | null;
-    voice_emotion?: string | null }) => post<VideoJobState>(P(id, "change-voice"), body),
+  changeVoice: (id: string, body: { voice_gender?: string; voice_accent?: string; custom_voice_id?: string | null }) => post<VideoJobState>(P(id, "change-voice"), body),
   voiceStatus: (id: string) => api<VideoJobState>(P(id, "voice-change-status")),
   changeLanguage: (id: string, content_language: string) => post<VideoJobState>(P(id, "change-language"), { content_language }),
   languageStatus: (id: string) => api<VideoJobState>(P(id, "language-change-status")),
@@ -463,21 +465,6 @@ export const videoEditApi = {
   refreshVerify: (id: string) => post<unknown>(P(id, "regenerate-script/verify")),
   refreshRetry: (id: string, user_instruction?: string) =>
     post<VideoJobState>(P(id, "regenerate-script/regenerate"), { user_instruction }),
-  // AI chat editing ★
-  chat: (id: string, message: string, conversation_id?: number) =>
-    post<{ reply?: string; message?: string; conversation_id?: number; [k: string]: unknown }>(P(id, "chat"), { message, conversation_id }),
-  chatHistory: (id: string) => api<unknown>(P(id, "chat/history")),
-  // Avatars ★
-  authorizeAvatars: (id: string, scene_ids: number[], avatar_preset?: string, avatar_motion_style?: string) =>
-    post<unknown>(P(id, "avatar-batch/authorize"), { scene_ids, avatar_preset, avatar_motion_style }),
-  makeAvatar: (id: string, sceneId: number, avatar_preset?: string) =>
-    postForm<unknown>(P(id, `scenes/${sceneId}/avatar`), form({ avatar_preset })),
-  avatarProgress: (id: string) => api<Record<string, unknown>>(P(id, "avatar-progress")),
-  deleteAvatar: (id: string, sceneId: number) => del<unknown>(P(id, `scenes/${sceneId}/avatar`)),
-  uploadPortrait: (id: string, file: File) => postForm<unknown>(P(id, "avatar-portrait"), form({ file })),
-  deletePortrait: (id: string) => del<unknown>(P(id, "avatar-portrait")),
-  avatarAppearance: (id: string, sceneId: number, body: { avatar_shape?: string; avatar_size?: number;
-    avatar_position?: string; avatar_opacity?: number }) => patch<unknown>(P(id, `scenes/${sceneId}/avatar-appearance`), body),
   // Render, download, frames
   /** force renders again even when an MP4 is already on R2 (blog2video otherwise just returns the old one). */
   render: (id: string, { force = false, resolution = "1080p" }: { force?: boolean; resolution?: string } = {}) =>
@@ -485,7 +472,6 @@ export const videoEditApi = {
   renderStatus: (id: string) => api<VideoJobState>(P(id, "render-status")),
   cancelRender: (id: string) => post<unknown>(P(id, "cancel-render")),
   downloadUrl: (id: string) => api<{ url: string }>(P(id, "download-url")),
-  downloadStudio: (id: string) => apiBlob(P(id, "download-studio")),
   still: (id: string, frame: number) => apiBlob(P(id, `render-still${qs({ frame })}`)),
 };
 
@@ -493,19 +479,6 @@ export const videoVoicesApi = {
   list: () => api<VideoVoicesResponse>("/api/video-voices"),
   save: (voice_id: string) => post<VideoSavedVoice>("/api/video-voices/saved", { voice_id }),
   unsave: (voice_id: string) => del(`/api/video-voices/saved/${encodeURIComponent(voice_id)}`),
-  designFromPrompt: (prompt: string) => post<{ previews: VideoDesignedVoice[] }>("/api/video-voices/design/prompt", { prompt }),
-  designFromPreset: (body: { gender: string; age: string; persona: string; speed: string; accent: string }) =>
-    post<{ previews: VideoDesignedVoice[] }>("/api/video-voices/design/preset", body),
-  keep: (body: { generated_voice_id: string; source: "prompt" | "preset"; name: string; prompt_text?: string }) =>
-    post<VideoCustomVoice>("/api/video-voices/custom", body),
-  clone: (name: string, file: File, remove_background_noise = true) =>
-    postForm<VideoCustomVoice>("/api/video-voices/clone", form({ name, file, remove_background_noise })),
-  customPreview: (customId: number) =>
-    api<{ preview_url: string | null; ready: boolean }>(`/api/video-voices/custom/${customId}/preview`),
-  removeCustom: (customId: number) => del(`/api/video-voices/custom/${customId}`),
-  /** ★ A few seconds of the voice with the chosen tuning (audio/mpeg). */
-  sample: (body: { voice_gender: string; voice_accent: string; custom_voice_id?: string; voice_emotion?: string;
-                   video_style?: string }) => apiBlob("/api/video-voices/sample", { method: "POST", body: JSON.stringify(body) }),
 };
 
 export const videoStylesApi = {
@@ -535,8 +508,6 @@ export const videoTemplatesApi = {
   get: (id: number) => api<Record<string, unknown>>(T(id, "")),
   update: (id: number, body: { name?: string; theme?: Record<string, unknown> }) => put<Record<string, unknown>>(T(id, ""), body),
   uploadLogo: (id: number, file: File) => postForm<unknown>(T(id, "upload-logo"), form({ file })),
-  aiEdit: (id: number, sceneKey: string, prompt: string) => post<unknown>(T(id, `scenes/${sceneKey}/ai-edit`), { prompt }),
-  aiEditStatus: (id: number, sceneKey: string) => api<VideoJobState>(T(id, `scenes/${sceneKey}/ai-edit/status`)),
   drafts: (id: number) => api<unknown>(T(id, "scene-drafts")),
   applyDraft: (id: number, sceneKey: string) => post<unknown>(T(id, `scenes/${sceneKey}/draft/apply`)),
   discardDraft: (id: number, sceneKey: string) => post<unknown>(T(id, `scenes/${sceneKey}/draft/discard`)),

frontend/src/api/types.ts

@@ -188,8 +188,14 @@ export type Artifact = {
   job: Job | null;
   /** "blog2video" for videos made in the Videos editor. */
   provider?: string | null;
+  /** This person's thumbs up or down on a finished report, quiz, flashcard set or infographic. */
+  feedback?: AnswerFeedback | null;
+  /** A quiz: this person's last finished run (what they answered, the score), shown again when it is reopened. */
+  attempt?: QuizAttempt | null;
 };
 
+export type QuizAttempt = { score: number; total: number; answers: { choice: number[]; text: string; correct: boolean | null }[] };
+
 export type TopicStatus = "rising" | "steady" | "dormant";
 
 export type TopicNode = {
@@ -411,20 +417,20 @@ export type Plan = {
   reports: number;
   infographics: number;
   voice_cloning: boolean;
-  brand_kit: boolean;
+  /** Audio overviews allowed (in total on Free), whatever their length; -1 = no cap. */
+  audio_overviews: number;
 };
 
 export type Usage = {
   plan: string;
-  used: { audio_minutes: number; videos: number; launch_kits: number; reports: number; infographics: number; llm_tokens: number; since: string };
-  limits: { audio_minutes: number; videos: number; launch_kits: number; reports: number; infographics: number; sources: number; indexed_posts: number };
+  used: { audio_minutes: number; audio_overviews: number; videos: number; launch_kits: number; reports: number; infographics: number; indexed_posts: number; llm_tokens: number; since: string };
+  limits: { audio_minutes: number; audio_overviews: number; videos: number; launch_kits: number; reports: number; infographics: number; sources: number; indexed_posts: number };
   videos_resets_at: string | null;
 };
 
 export type Settings = {
   user: { name: string | null; email: string; auth_provider: string; email_unsubscribed: boolean };
   workspace: { id: string; name: string; training_opt_in: boolean; allow_public_links: boolean };
-  brand: { name: string | null; accent: string; logo_url: string | null };
   plan: Plan;
   billing_enabled: boolean;
   usage: Usage;
@@ -467,6 +473,8 @@ export type BillingStatus = {
   has_billing_account: boolean;
   period_end: string | null;
   meters: Meter[];
+  /** Posts indexed, reports and infographics: shown when the sidebar plan card is opened. */
+  more_meters: Meter[];
   since: string;
   /** Videos reset on renewal (or monthly without one), not on the 1st like the other meters. */
   videos_resets_at: string | null;
@@ -483,13 +491,10 @@ export type MindNode = {
 
 // Videos (blog2video). Everything goes through our API; ids are our artifact ids unless named b2v/custom.
 
-export type VideoLimitMetric =
-  | "ai_edits" | "templates" | "template_ai_daily" | "voice_designs_daily" | "voice_samples_daily" | "custom_voices";
+export type VideoLimitMetric = "ai_edits" | "templates" | "template_ai_daily";
 
 export type VideoConfig = {
   configured: boolean;
-  /** Premium (★) video options are included in this workspace's plan. */
-  premium: boolean;
   limits: Record<VideoLimitMetric, { used: number; limit: number }>;
 };
 
@@ -535,7 +540,6 @@ export type MusicTrack = { track_id: string; display_name: string; mood?: string
 
 export type VideoCatalog = {
   templates: VideoTemplate[];
-  crafted_templates: VideoTemplate[];
   my_templates: VideoTemplate[];
   video_styles: VideoStyleItem[];
   music: MusicTrack[];
@@ -549,8 +553,6 @@ export type VideoSavedVoice = {
   preview_url: string | null;
   gender: string | null;
   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";
 };
@@ -563,16 +565,6 @@ export type VideoLibraryVoice = {
   gender: string | null;
   accent: string | null;
   age?: string | null;
-  premium: boolean;
-  saved: boolean;
-};
-
-export type VideoCustomVoice = {
-  id: number;
-  voice_id: string;
-  name: string;
-  source: "prompt" | "preset" | "clone";
-  preview_url: string | null;
   saved: boolean;
 };
 
@@ -582,18 +574,10 @@ export type VideoNotestackVoice = { voice_id: string; name: string; kind: "clone
 export type VideoVoicesResponse = {
   saved: VideoSavedVoice[];
   library: VideoLibraryVoice[];
-  custom: VideoCustomVoice[];
   notestack: VideoNotestackVoice[];
 };
 
-export type VideoDesignedVoice = {
-  generated_voice_id: string;
-  audio_base_64: string;
-  media_type: string;
-  duration_secs: number;
-};
-
-export type VideoLength = "short" | "medium" | "detailed" | "more_detailed";
+export type VideoLength = "short" | "medium";
 export type LogoPosition = "bottom_right" | "bottom_left" | "top_left" | "top_right";
 
 /** Every field of the 3-step wizard, named as blog2video names them. */
@@ -616,7 +600,6 @@ export type VideoOptions = {
   voice_gender: "female" | "male" | "none";
   voice_accent: string;
   custom_voice_id?: string;
-  voice_emotion?: string;
   bgm_track_id?: string;
   bgm_volume: number;
 };

frontend/src/components/AnswerFeedback.tsx

@@ -11,7 +11,7 @@ const REASONS: { id: string; label: string }[] = [
   { id: "other", label: "Something else" },
 ];
 
-const Thumb = ({ down }: { down?: boolean }) => (
+export const Thumb = ({ down }: { down?: boolean }) => (
   <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true" style={down ? { transform: "rotate(180deg)" } : undefined}>
     <path d="M7 11v9H4a1 1 0 0 1-1-1v-7a1 1 0 0 1 1-1h3Zm0 0 4-8a2 2 0 0 1 2 2v4h5.2a2 2 0 0 1 2 2.3l-1 6A2 2 0 0 1 17.2 20H7" />
   </svg>

frontend/src/components/AppShell.tsx

@@ -63,7 +63,7 @@ export default function AppShell() {
               </button>
             ) : (
               <NavLink to="/" className="sidebar-brand">
-                <Logo size={28} withWordmark={false} />
+                <Logo size={28} />
               </NavLink>
             )}
             <button

frontend/src/components/Flashcards.tsx

@@ -2,15 +2,10 @@ import { useCallback, useEffect, useMemo, useState } from "react";
 import type { GenerateBody } from "../api/endpoints";
 import type { Artifact, ChatSummary, FlashcardData } from "../api/types";
 import { Pills, SourceFocusFields, sourceSummary, type SourceSelection } from "./SourceFocusFields";
+import { ArtifactFeedback } from "./ArtifactFeedback";
 import { StudyOverlay } from "./StudyOverlay";
 import { Modal } from "./ui";
 
-const COUNTS = [
-  { id: "fewer", label: "Fewer" },
-  { id: "standard", label: "Standard (Default)" },
-  { id: "more", label: "More" },
-] as const;
-
 const LEVELS = [
   { id: "easy", label: "Easy" },
   { id: "medium", label: "Medium (Default)" },
@@ -31,31 +26,25 @@ export function FlashcardsDialog({ notebookId, notebookTitle, chats, currentChat
   onCreate: (body: FlashcardsRequest) => void;
 }) {
   const [sel, setSel] = useState<SourceSelection | null>(null);
-  const [count, setCount] = useState<(typeof COUNTS)[number]["id"]>("standard");
   const [level, setLevel] = useState<(typeof LEVELS)[number]["id"]>("medium");
 
   return (
     <Modal title="Flashcards" onClose={onClose} wide>
       <div className="stack vw-in-modal">
-        <section className="stack vw">
-          <SourceFocusFields notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId} what="flashcard set" columns onChange={setSel}
-            below={(
-              <>
-                <div className="field">
-                  <span className="vw-label">Number of cards</span>
-                  <Pills label="Number of cards" value={count} options={COUNTS} onChange={setCount} />
-                </div>
-                <div className="field">
-                  <span className="vw-label">Level of difficulty</span>
-                  <Pills label="Level of difficulty" value={level} options={LEVELS} onChange={setLevel} />
-                </div>
-              </>
-            )} />
-          {!sel?.ready && <p className="muted small">Select at least one post or chat to generate flashcards.</p>}
-          {error && <p className="error-text">{error}</p>}
-          <div className="vw-nav">
+        <section className="stack vw qz-setup">
+          <div className="field">
+            <span className="vw-label">Level of difficulty</span>
+            <Pills label="Level of difficulty" value={level} options={LEVELS} onChange={setLevel} />
+          </div>
+          <SourceFocusFields notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId}
+                             preselectChat what="flashcard set" largeSelection onChange={setSel} />
+          <div className="qz-foot">
+            <div>
+              {!sel?.ready && <p className="muted small">Select at least one post or chat to generate flashcards.</p>}
+              {error && <p className="error-text">{error}</p>}
+            </div>
             <button type="button" className="btn btn-primary vw-next" disabled={busy || !sel?.ready || sel.loading}
-                    onClick={() => sel && onCreate({ ...sel.request, count, difficulty: level })}>
+                    onClick={() => sel && onCreate({ ...sel.request, difficulty: level })}>
               {busy ? "Starting..." : "Generate Flashcards"}
             </button>
           </div>
@@ -141,6 +130,7 @@ export function FlashcardsPlayer({ artifact, onClose }: { artifact: Artifact; on
   return (
     <StudyOverlay title={artifact.title} onClose={onClose}>
       <FlashcardDeck cards={(artifact.content.cards ?? []) as FlashcardData[]} />
+      <ArtifactFeedback artifact={artifact} label="How are these cards?" />
     </StudyOverlay>
   );
 }