Refactor code structure for improved readability and maintainability; removed redundant code blocks and optimized function calls.

Dockerfile

@@ -11,6 +11,10 @@ ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 \
     CORPUS_CACHE_DIR=/app/.corpus-cache \
     LOCAL_STORAGE_DIR=/app/.storage
 
+# Chromium draws an infographic's PNG for its Download button (and the fonts the pages use)
+RUN apt-get update && apt-get install -y --no-install-recommends chromium fonts-liberation \
+    && rm -rf /var/lib/apt/lists/*
+
 COPY backend/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 COPY --chown=user backend/ .

backend/0

@@ -0,0 +1 @@
+key set: 49

backend/Dockerfile

@@ -1,6 +1,9 @@
 FROM python:3.12-slim
 WORKDIR /app
 ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
+# Chromium draws an infographic's PNG for its Download button
+RUN apt-get update && apt-get install -y --no-install-recommends chromium fonts-liberation \
+    && rm -rf /var/lib/apt/lists/*
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 COPY . .

backend/alembic/versions/0017_reports_limit.py

@@ -0,0 +1,26 @@
+"""reports_limit: a monthly report allowance on each plan
+
+Revision ID: 0017_reports_limit
+Revises: 0016_support_chat
+Create Date: 2026-10-07
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0017_reports_limit"
+down_revision = "0016_support_chat"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the column.
+    columns = {c["name"] for c in sa.inspect(op.get_bind()).get_columns("plans")}
+    if "reports" not in columns:
+        op.add_column("plans", sa.Column("reports", sa.Integer(), nullable=False, server_default="0"))
+    op.execute("UPDATE plans SET reports = CASE id WHEN 'studio' THEN -1 WHEN 'writer' THEN 30 ELSE 2 END")
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("plans") as batch:
+        batch.drop_column("reports")

backend/alembic/versions/0018_report_sharing.py

@@ -0,0 +1,41 @@
+"""report_sharing: public links to reports, and a workspace switch that turns them off
+
+Revision ID: 0018_report_sharing
+Revises: 0017_reports_limit
+Create Date: 2026-10-07
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0018_report_sharing"
+down_revision = "0017_reports_limit"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have these.
+    inspector = sa.inspect(op.get_bind())
+    if "artifact_shares" not in inspector.get_table_names():
+        op.create_table(
+            "artifact_shares",
+            sa.Column("id", sa.Uuid(), primary_key=True),
+            sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+            sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+            sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False),
+            sa.Column("artifact_id", sa.Uuid(), sa.ForeignKey("artifacts.id", ondelete="CASCADE"), nullable=False,
+                      unique=True),
+            sa.Column("token", sa.String(64), nullable=False),
+            sa.Column("show_sources", sa.Boolean(), nullable=False, server_default=sa.true()),
+        )
+        op.create_index("ix_artifact_shares_workspace_id", "artifact_shares", ["workspace_id"])
+        op.create_index("ix_artifact_shares_token", "artifact_shares", ["token"], unique=True)
+    if "allow_public_links" not in {c["name"] for c in inspector.get_columns("workspaces")}:
+        op.add_column("workspaces", sa.Column("allow_public_links", sa.Boolean(), nullable=False,
+                                              server_default=sa.true()))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("workspaces") as batch:
+        batch.drop_column("allow_public_links")
+    op.drop_table("artifact_shares")

backend/alembic/versions/0019_infographics_limit.py

@@ -0,0 +1,26 @@
+"""infographics_limit: a monthly infographic allowance on each plan
+
+Revision ID: 0019_infographics_limit
+Revises: 0018_report_sharing
+Create Date: 2026-10-08
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0019_infographics_limit"
+down_revision = "0018_report_sharing"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the column.
+    columns = {c["name"] for c in sa.inspect(op.get_bind()).get_columns("plans")}
+    if "infographics" not in columns:
+        op.add_column("plans", sa.Column("infographics", sa.Integer(), nullable=False, server_default="0"))
+    op.execute("UPDATE plans SET infographics = CASE id WHEN 'studio' THEN -1 WHEN 'writer' THEN 30 ELSE 2 END")
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("plans") as batch:
+        batch.drop_column("infographics")

backend/app/config.py

@@ -67,6 +67,7 @@ class Settings(BaseSettings):
     # 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"
+    llm_report_model: str = ""  # optional: writes report prose (default: the fast model, with a bigger output cap)
     # Chat triage (small talk, off topic, follow up rewriting). Empty = LLM_FAST_MODEL.
     llm_triage_model: str = ""
     # TypeSafe Jev classifier for chat triage. When set, triage uses Jev instead of an LLM call.

backend/app/infographics/content.py

@@ -0,0 +1,108 @@
+"""What an infographic says: a short, length-limited block of text the premade themes pour into their layout.
+Model output is never trusted for layout, so every field is stripped of markup and clamped here."""
+
+import re
+
+from pydantic import BaseModel
+
+WIDTH, HEIGHT = 1600, 2260
+
+# Characters per field: the themes are drawn so the longest allowed text still fits its box.
+LIMITS = {"title": 60, "subtitle": 110, "label": 34, "item_name": 22, "item_text": 120, "step_name": 14,
+          "step_text": 78, "rule": 80, "note": 90}
+ITEMS = (3, 5)
+STEPS = (4, 8)
+NOTES = 3
+
+
+class Entry(BaseModel):
+    name: str
+    text: str
+
+
+class InfographicContent(BaseModel):
+    title: str
+    subtitle: str
+    items_label: str
+    items: list[Entry]
+    steps_label: str
+    steps: list[Entry]
+    rule: str
+    notes: list[str]
+
+
+_TAGS = re.compile(r"<[^>]*>")
+_SPACE = re.compile(r"\s+")
+
+
+def _clip(text: object, limit: int) -> str:
+    """Plain text of at most `limit` characters, cut at a word with an ellipsis when it was longer."""
+    s = _SPACE.sub(" ", _TAGS.sub(" ", str(text or ""))).replace("—", ",").replace("–", "-").strip()
+    if len(s) <= limit:
+        return s
+    cut = s[: limit - 1].rsplit(" ", 1)[0].rstrip(" ,;:.-") or s[: limit - 1]
+    return cut + "…"
+
+
+def _entries(raw: object, name_limit: int, text_limit: int, count: tuple[int, int]) -> list[dict]:
+    out = []
+    for e in (raw if isinstance(raw, list) else []):
+        e = e if isinstance(e, dict) else getattr(e, "__dict__", {})
+        name, text = _clip(e.get("name"), name_limit), _clip(e.get("text"), text_limit)
+        if name and text:
+            out.append({"name": name, "text": text})
+    return out[: count[1]] if len(out) >= count[0] else []
+
+
+def clamp(raw: dict) -> dict | None:
+    """The content in the shape the themes draw, or None when there is too little to draw (too few items or steps)."""
+    if hasattr(raw, "model_dump"):
+        raw = raw.model_dump()
+    items = _entries(raw.get("items"), LIMITS["item_name"], LIMITS["item_text"], ITEMS)
+    steps = _entries(raw.get("steps"), LIMITS["step_name"], LIMITS["step_text"], STEPS)
+    title = _clip(raw.get("title"), LIMITS["title"])
+    if not items or not steps or not title:
+        return None
+    notes = [n for n in (_clip(n, LIMITS["note"]) for n in raw.get("notes") or []) if n][:NOTES]
+    return {"title": title, "subtitle": _clip(raw.get("subtitle"), LIMITS["subtitle"]),
+            "items_label": _clip(raw.get("items_label"), LIMITS["label"]) or "Key ideas",
+            "items": items,
+            "steps_label": _clip(raw.get("steps_label"), LIMITS["label"]) or "How it works",
+            "steps": steps, "rule": _clip(raw.get("rule"), LIMITS["rule"]), "notes": notes}
+
+
+SAMPLE = {
+    "title": "From Prompt to Production Agent",
+    "subtitle": "Five engineering layers plus an eight step production request flow",
+    "items_label": "The five layers",
+    "items": [
+        {"name": "Prompt", "text": "Optimizes wording, examples, and format in a single request."},
+        {"name": "Context", "text": "Curates docs, history, tools, and memory before each model call."},
+        {"name": "Harness", "text": "Scaffolding around the model: tools, verification, and guardrails."},
+        {"name": "Loop", "text": "Runs reason, act and observe cycles until a stop condition is met."},
+        {"name": "Graph", "text": "Maps multi-agent systems as explicit nodes and edges."},
+    ],
+    "steps_label": "Every request goes through",
+    "steps": [
+        {"name": "Auth", "text": "Middleware checks identity, rate limits, and input guards."},
+        {"name": "Cache", "text": "Semantic cache returns answers for equivalent questions."},
+        {"name": "Safety", "text": "Scrub PII and detect prompt injection attacks."},
+        {"name": "Memory", "text": "Load session history with summarized context."},
+        {"name": "Retrieve", "text": "Fetch relevant docs and split complex queries."},
+        {"name": "Answer", "text": "Execute sub-queries in parallel with branching models."},
+        {"name": "Validate", "text": "Check output quality metrics before responding."},
+        {"name": "Save", "text": "Store results and log one full trace."},
+    ],
+    "rule": "Most tasks only need the bottom layers; avoid complex graphs without cause.",
+    "notes": ["Each layer builds on the one below it.", "Cache and middleware run outside the graph.",
+              "Every request should produce a single end-to-end trace."],
+}
+
+# The longest text each field allows, with the most items and steps: what every theme must fit.
+STRESS = {
+    "title": "W" * 4 + " Quarterly Review of Everything We Learned Here", "subtitle": "Long words here " * 7,
+    "items_label": "The five very long layers", "steps_label": "Every request goes through",
+    "items": [{"name": "Wide Name Here Now", "text": "Words that go on and on " * 6}] * 5,
+    "steps": [{"name": "Validators", "text": "Words that go on and on " * 5}] * 8,
+    "rule": "A very long rule that keeps going and going " * 3, "notes": ["A long note that keeps on going " * 4] * 3,
+}

backend/app/infographics/image.py

@@ -0,0 +1,68 @@
+"""An infographic's PNG: its stored HTML page drawn by a headless Chrome at the page's own size. No Remotion, no
+browser library: one `chrome --headless --screenshot` run per download (the result is kept for the next one)."""
+
+import glob
+import hashlib
+import os
+import shutil
+import subprocess
+import tempfile
+from collections import OrderedDict
+from pathlib import Path
+from threading import Lock
+
+from app.infographics.render import SIZES
+
+TIMEOUT = 60  # seconds for one drawing
+KEEP = 8  # drawings kept in memory
+
+_cache: OrderedDict[str, bytes] = OrderedDict()
+_lock = Lock()
+
+
+class ImageUnavailable(Exception):
+    """No Chrome to draw with, or it failed."""
+
+
+def chrome() -> str | None:
+    """CHROME, or a Chrome / Chromium found on the machine."""
+    if env := os.environ.get("CHROME"):
+        return env if Path(env).exists() else None
+    for name in ("chromium", "chromium-browser", "google-chrome", "google-chrome-stable", "chrome"):
+        if found := shutil.which(name):
+            return found
+    patterns = ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+                os.path.expanduser("~/.cache/puppeteer/chrome/*/chrome-mac-*/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing")]
+    return next((p for pat in patterns for p in glob.glob(pat)), 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)."""
+    width, height = SIZES.get(layout, SIZES["portrait"])
+    key = hashlib.sha256(f"{width}x{height}{html}".encode()).hexdigest()
+    with _lock:
+        if key in _cache:
+            _cache.move_to_end(key)
+            return _cache[key]
+    binary = chrome()
+    if not binary:
+        raise ImageUnavailable("No Chrome is installed here to draw the image.")
+    page = f'<!doctype html><meta charset="utf-8"><body style="margin:0">{html}</body>'
+    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",
+               f"--user-data-dir={tmp}/profile", f"--window-size={width},{height}", "--virtual-time-budget=8000",
+               f"--screenshot={out}", f"file://{src}"]
+        try:
+            subprocess.run(cmd, check=True, capture_output=True, timeout=TIMEOUT)
+        except (subprocess.SubprocessError, OSError) as exc:
+            raise ImageUnavailable("The image could not be drawn.") from exc
+        if not out.exists():
+            raise ImageUnavailable("The image could not be drawn.")
+        data = out.read_bytes()
+    with _lock:
+        _cache[key] = data
+        while len(_cache) > KEEP:
+            _cache.popitem(last=False)
+    return data

backend/app/infographics/render.py

@@ -0,0 +1,53 @@
+"""Pours an infographic's content into a theme's premade HTML page. Autoescape is on and nothing is marked safe, so text
+from the model can never add markup or scripts to the page."""
+
+import hashlib
+import random
+from pathlib import Path
+
+from markupsafe import Markup
+from jinja2 import Environment, FileSystemLoader, StrictUndefined, select_autoescape
+
+from app.infographics.content import HEIGHT, WIDTH
+from app.infographics.themes import DEFAULT_THEME, THEMES, theme_id
+
+_ENV = Environment(loader=FileSystemLoader(Path(__file__).parent / "templates"), autoescape=select_autoescape(["j2"], default=True),
+                   undefined=StrictUndefined, trim_blocks=True, lstrip_blocks=True)
+
+# name -> (heading, body, mono, heading weight, heading case, label case)
+_FONT = {"jost": "Jost", "outfit": "Outfit", "playfair": "Playfair Display", "cormorant": "Cormorant Garamond",
+         "mono": "Space Mono"}
+
+
+# The Notestack mark (the same icon as frontend/public/logo.svg), drawn beside the name on every page. Our own constant, never
+# model text, so it is the one thing marked safe.
+LOGO_SVG = ('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#fff"/>'
+            '<circle cx="26" cy="36" r="13" fill="#000"/><ellipse cx="26" cy="36" rx="21" ry="5" fill="none" stroke="#000" '
+            'stroke-width="3" transform="rotate(-18 26 36)"/><path d="M46 10l2.2 5.8 5.8 2.2-5.8 2.2-2.2 5.8-2.2-5.8-5.8-2.2 '
+            '5.8-2.2z" fill="#000"/></svg>')
+
+SIZES = {"portrait": (WIDTH, HEIGHT), "landscape": (HEIGHT, WIDTH)}  # the page is drawn at either shape
+
+
+def _stars(seed: str, w: int, h: int, n: int = 70) -> list[tuple[int, int, float, float]]:
+    rnd = random.Random(int(hashlib.sha1(seed.encode()).hexdigest()[:8], 16))
+    return [(rnd.randint(0, w), rnd.randint(0, h), round(rnd.choice((1.5, 2, 2, 3, 4)), 1), round(rnd.uniform(.15, .6), 2))
+            for _ in range(n)]
+
+
+def build_html(theme: str, content: dict, layout: str = "portrait") -> str:
+    """The page for `content` (as returned by content.clamp) in the theme (the default when unknown), tall (portrait)
+    or wide (landscape: the same words, the title and takeaway in a column beside the theme's drawing)."""
+    tid = theme_id(theme)
+    layout = layout if layout in SIZES else "portrait"
+    w, h = SIZES[layout]
+    tpl = _ENV.get_template(f"{tid}.html.j2")
+    return tpl.render(c=content, width=w, height=h, layout=layout, logo=Markup(LOGO_SVG), stars=_stars(content["title"] + tid, w, h))
+
+
+def thumbnail_html(theme: str, content: dict, layout: str = "portrait") -> str:
+    """The page as a standalone document, for rendering a preview outside the app."""
+    return f'<!doctype html><meta charset="utf-8"><body style="margin:0">{build_html(theme, content, layout)}</body>'
+
+
+__all__ = ["build_html", "LOGO_SVG", "thumbnail_html", "SIZES", "THEMES", "DEFAULT_THEME"]

backend/app/infographics/templates/base.html.j2

@@ -0,0 +1,65 @@
+{#- Shared layout of every infographic theme. A theme extends this and fills the style, the background, the hero drawing and a few
+    words. All text is autoescaped; nothing from the model is ever marked safe. The notestack.ai mark is added by the renderer. -#}
+<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family={{ fonts.h|replace(' ', '+') }}:wght@400;500;600;700&family={{ fonts.b|replace(' ', '+') }}:wght@300;400;500;600&family={{ fonts.m|replace(' ', '+') }}:wght@400;700&display=swap">
+<style>
+.ig,.ig *{box-sizing:border-box;margin:0;padding:0}
+.ig{position:relative;width:{{ width }}px;height:{{ height }}px;overflow:hidden;color:var(--ink);font-family:var(--fb);
+  background:radial-gradient(1300px 800px at 62% 14%,var(--bg2),var(--bg1) 72%)}
+.ig .bg{position:absolute;inset:0;pointer-events:none}
+.ig .main{position:absolute;left:110px;right:110px;top:84px;bottom:116px;display:flex;flex-direction:column}
+.ig .head{display:flex;justify-content:space-between;align-items:flex-start;gap:30px;height:var(--hh,400px);flex:none}
+.ig .head .txt{width:900px}
+.ig .eyebrow{font-family:var(--fm);font-size:21px;letter-spacing:.24em;text-transform:uppercase;color:var(--a);margin-bottom:18px}
+.ig h1{font-family:var(--fh);font-weight:var(--hw,700);font-size:72px;line-height:1.05;letter-spacing:var(--hl,0);text-transform:var(--ht,none);margin-bottom:20px}
+.ig .sub{font-size:31px;line-height:1.35;color:var(--mute)}
+.ig .hero{flex:none;width:480px;height:400px}
+.ig .lab{font-family:var(--fm);font-size:21px;letter-spacing:.22em;text-transform:uppercase;color:var(--a);margin:12px 0 16px;flex:none;display:flex;align-items:center;gap:18px}
+.ig .lab.gap{margin-top:12px}
+.ig .lab:after{content:"";flex:1;height:2px;background:var(--line)}
+.ig .fill{flex:1;min-height:0;display:flex;flex-direction:column;justify-content:space-evenly}
+.ig .band{margin-top:0;display:grid;grid-template-columns:1.05fr 1fr;gap:48px;align-items:center;padding:34px 50px;border-radius:var(--r);background:var(--paper);color:var(--paperink);flex:none}
+.ig .band .q{font-family:var(--fh);font-weight:700;font-size:40px;line-height:1.14;text-transform:var(--ht,none)}
+.ig .band ul{list-style:none;font-size:24px;line-height:1.35}
+.ig .band li{position:relative;padding-left:26px;margin:7px 0}
+.ig .band li:before{content:"";position:absolute;left:0;top:11px;width:12px;height:12px;border-radius:50%;background:var(--b)}
+.ig .mark{position:absolute;right:44px;bottom:34px;display:flex;align-items:center;gap:16px;font-family:'Space Mono',monospace;font-size:30px;font-weight:700;letter-spacing:.06em;color:#fff;padding:8px 26px 8px 10px;border-radius:999px;background:rgba(10,14,20,.7);border:1px solid rgba(255,255,255,.3)}
+.ig .mark svg{width:52px;height:52px;display:block}
+.ig .left{display:contents}
+.ig .head{order:1}.ig .fill{order:2}.ig .band{order:3}
+.ig.landscape .main{top:70px;bottom:90px;flex-direction:row;gap:60px}
+.ig.landscape .left{display:flex;flex-direction:column;justify-content:space-between;gap:28px;width:600px;flex:none;min-height:0}
+.ig.landscape .head{display:block;height:auto}
+.ig.landscape .head .txt{width:100%}
+.ig.landscape h1{font-size:60px}
+.ig.landscape .sub{font-size:28px}
+.ig.landscape .hero{display:block;width:360px;height:300px;margin:22px 0 0 auto}
+.ig.landscape .fill{order:0;width:1380px;flex:none}
+.ig.landscape .band{grid-template-columns:1fr;gap:18px;padding:30px 34px}
+.ig.landscape .band .q{font-size:36px}
+.ig.landscape .band ul{font-size:22px}
+{% block css %}{% endblock %}
+</style>
+<div class="ig {{ layout }}" style="--bg1:{{ pal.bg1 }};--bg2:{{ pal.bg2 }};--ink:{{ pal.ink }};--mute:{{ pal.mute }};--a:{{ pal.a }};--b:{{ pal.b }};--card:{{ pal.card }};--line:{{ pal.line }};--paper:{{ pal.paper }};--paperink:{{ pal.paperink }};--r:{{ pal.r }}px;--fh:'{{ fonts.h }}',serif;--fb:'{{ fonts.b }}',sans-serif;--fm:'{{ fonts.m }}',monospace;--hw:{{ fonts.hw }};--ht:{{ fonts.ht }};--bt:{{ fonts.bt }}">
+  <svg class="bg" width="{{ width }}" height="{{ height }}" viewBox="0 0 {{ width }} {{ height }}">
+    {% for s in stars %}<circle cx="{{ s[0] }}" cy="{{ s[1] }}" r="{{ s[2] }}" fill="{{ pal.ink }}" opacity="{{ s[3] }}"/>{% endfor %}
+    <g{% if layout == "landscape" %} transform="translate(660 0)"{% endif %}>{% block bg %}{% endblock %}</g>
+  </svg>
+  <div class="main">
+    <div class="left">
+      <div class="head">
+        <div class="txt">
+          <div class="eyebrow">{{ eyebrow }}</div>
+          <h1>{{ c.title }}</h1>
+          <p class="sub">{{ c.subtitle }}</p>
+        </div>
+        <svg class="hero" viewBox="0 0 480 400">{% block hero %}{% endblock %}</svg>
+      </div>
+      <div class="band">
+        <div class="q">{{ c.rule }}</div>
+        <ul>{% for n in c.notes %}<li>{{ n }}</li>{% endfor %}</ul>
+      </div>
+    </div>
+    <div class="fill">{% block body %}{% endblock %}</div>
+  </div>
+  <div class="mark">{{ logo }}<span>notestack.ai</span></div>
+</div>

backend/app/infographics/templates/galaxy.html.j2

@@ -0,0 +1,46 @@
+{% extends "base.html.j2" %}
+{% set eyebrow = "Field notes from the galaxy" %}
+{% set pal = {"bg1":"#1c1830","bg2":"#3a2f57","ink":"#ece7f3","mute":"#c1b9d0","a":"#b79ad6","b":"#7fa3b8","card":"rgba(236,231,243,.06)","line":"rgba(183,154,214,.28)","paper":"#e9e2f2","paperink":"#241f33","r":26} %}
+{% set fonts = {"h":"Cormorant Garamond","b":"Outfit","m":"Space Mono","hw":700,"ht":"none","bt":"none"} %}
+{% set cycle = ["#b79ad6","#7fa3b8","#d9a7b8","#8fb8a8","#c9b27a"] %}
+{% block bg %}
+<defs><radialGradient id="neb" cx=".5" cy=".5"><stop offset="0" stop-color="#b79ad6" stop-opacity=".45"/><stop offset="1" stop-color="#b79ad6" stop-opacity="0"/></radialGradient>
+<radialGradient id="neb2" cx=".5" cy=".5"><stop offset="0" stop-color="#7fa3b8" stop-opacity=".35"/><stop offset="1" stop-color="#7fa3b8" stop-opacity="0"/></radialGradient></defs>
+<circle cx="1300" cy="300" r="520" fill="url(#neb)"/><circle cx="250" cy="1800" r="560" fill="url(#neb2)"/>
+<g fill="none" stroke="#b79ad6" stroke-opacity=".22" stroke-width="2"><ellipse cx="1360" cy="1250" rx="620" ry="190" transform="rotate(-24 1360 1250)"/><ellipse cx="1360" cy="1250" rx="440" ry="130" transform="rotate(-24 1360 1250)"/><ellipse cx="200" cy="2020" rx="540" ry="150" transform="rotate(18 200 2020)"/></g>
+{% endblock %}
+{% block hero %}
+<defs><radialGradient id="core" cx=".5" cy=".5"><stop offset="0" stop-color="#f4ecff"/><stop offset=".25" stop-color="#b79ad6"/><stop offset="1" stop-color="#b79ad6" stop-opacity="0"/></radialGradient></defs>
+<g transform="translate(240 200)" fill="none" stroke-linecap="round">
+<ellipse rx="210" ry="70" transform="rotate(-20)" stroke="#b79ad6" stroke-width="3" opacity=".9"/><ellipse rx="160" ry="52" transform="rotate(-20)" stroke="#7fa3b8" stroke-width="3"/>
+<ellipse rx="110" ry="36" transform="rotate(-20)" stroke="#d9a7b8" stroke-width="3"/><ellipse rx="60" ry="20" transform="rotate(-20)" stroke="#c9b27a" stroke-width="3"/>
+<path d="M-200 60C-120 -150 120 -190 210 -40" stroke="#b79ad6" stroke-width="2" stroke-dasharray="2 10" opacity=".8"/>
+<circle r="86" fill="url(#core)" stroke="none"/>
+<g fill="#ece7f3" stroke="none"><circle cx="-190" cy="64" r="9" fill="#7fa3b8"/><circle cx="150" cy="-70" r="7" fill="#d9a7b8"/><circle cx="196" cy="42" r="10" fill="#c9b27a"/><circle cx="-60" cy="-110" r="5"/><circle cx="90" cy="120" r="6"/></g>
+</g>
+{% endblock %}
+{% block css %}
+.ig h1{font-size:84px;line-height:1}
+.gi{display:grid;grid-template-columns:76px 300px 1fr;gap:24px;align-items:center;width:1090px;min-height:104px;padding:14px 30px 14px 22px;border-radius:60px;background:var(--card);border:1px solid var(--line);margin-bottom:14px;position:relative}
+.gi:before{content:"";position:absolute;left:-40px;top:50%;width:40px;height:2px;background:linear-gradient(90deg,transparent,var(--c))}
+.gi .mk{width:64px;height:64px;border-radius:50%;display:grid;place-items:center;font-family:var(--fh);font-weight:700;font-size:32px;color:var(--bg1);background:radial-gradient(circle at 35% 30%,#fff8,var(--c) 60%);box-shadow:0 0 0 7px rgba(183,154,214,.16),0 0 30px var(--c)}
+.gi b{font-family:var(--fh);font-weight:700;font-size:36px;line-height:1.05}
+.gi p{font-size:24px;line-height:1.3;color:var(--mute)}
+.gc{display:grid;grid-template-columns:repeat(4,1fr);gap:0 28px;row-gap:20px;flex:none}
+.gs{position:relative;padding-top:34px}
+.gs:before{content:"";position:absolute;left:0;right:-28px;top:9px;height:1px;background:var(--line)}
+.gs:nth-child(4n):before{right:0}
+.gs:after{content:"";position:absolute;left:0;top:2px;width:15px;height:15px;border-radius:50%;background:var(--c);box-shadow:0 0 0 5px rgba(183,154,214,.15),0 0 18px var(--c)}
+.gs small{display:block;font-family:var(--fm);font-size:19px;letter-spacing:.14em;color:var(--c);margin-bottom:4px}
+.gs b{display:block;font-family:var(--fh);font-weight:700;font-size:34px;margin-bottom:6px}
+.gs p{font-size:22px;line-height:1.32;color:var(--mute)}
+{% endblock %}
+{% block body %}<section><div class="lab">{{ c.items_label }}</div>
+<div class="gitems" style="flex:none">
+  {% for e in c["items"] %}<div class="gi" style="--c:{{ cycle[loop.index0 % cycle|length] }};margin-left:{{ loop.index0 * 56 + 30 }}px"><div class="mk">{{ loop.index }}</div><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+<section><div class="lab">{{ c.steps_label }}</div>
+<div class="gc">
+  {% for e in c.steps %}<div class="gs" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><small>{{ '%02d'|format(loop.index) }}</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+{% endblock %}

backend/app/infographics/templates/launch.html.j2

@@ -0,0 +1,58 @@
+{% extends "base.html.j2" %}
+{% set eyebrow = "Mission briefing" %}
+{% set pal = {"bg1":"#1d2a34","bg2":"#34495a","ink":"#efe7d8","mute":"#c3ccd1","a":"#cfa24d","b":"#c8745f","card":"rgba(239,231,216,.07)","line":"rgba(239,231,216,.18)","paper":"#efe7d8","paperink":"#1d2a34","r":18} %}
+{% set fonts = {"h":"Jost","b":"Outfit","m":"Space Mono","hw":700,"ht":"uppercase","bt":"uppercase"} %}
+{% set cycle = ["#cfa24d","#c8745f","#8fb0a0","#8fa6c4","#cfa24d"] %}
+{% block bg %}
+<circle cx="1440" cy="150" r="88" fill="#e9dfc6" opacity=".9"/><circle cx="1408" cy="122" r="15" fill="#b9ad90" opacity=".7"/><circle cx="1470" cy="178" r="21" fill="#b9ad90" opacity=".7"/>
+<g fill="#efe7d8" opacity=".07"><circle cx="300" cy="2200" r="150"/><circle cx="520" cy="2230" r="120"/><circle cx="1200" cy="2210" r="170"/></g>
+{% endblock %}
+{% block hero %}
+<g fill="none" stroke="#cfa24d" stroke-width="3" stroke-dasharray="3 10" stroke-linecap="round"><ellipse cx="250" cy="215" rx="205" ry="92" transform="rotate(-16 250 215)"/><ellipse cx="250" cy="215" rx="140" ry="58" transform="rotate(-16 250 215)"/></g>
+<circle cx="250" cy="215" r="64" fill="#e9dfc6"/><circle cx="228" cy="195" r="12" fill="#b9ad90" opacity=".7"/><circle cx="276" cy="238" r="16" fill="#b9ad90" opacity=".7"/><circle cx="262" cy="180" r="7" fill="#b9ad90" opacity=".7"/>
+<g transform="translate(404 122) rotate(-16)"><rect x="-17" y="-13" width="34" height="26" rx="5" fill="#cfa24d"/><rect x="-66" y="-9" width="42" height="18" fill="#8fa6c4"/><rect x="24" y="-9" width="42" height="18" fill="#8fa6c4"/><path d="M-66 -9V9M-52 -9V9M-38 -9V9M38 -9V9M52 -9V9" stroke="#1d2a34" stroke-width="2"/></g>
+<g fill="#efe7d8"><path d="M70 90l5 -14 5 14 14 5 -14 5 -5 14 -5 -14 -14 -5z" opacity=".8"/><path d="M60 320l4 -10 4 10 10 4 -10 4 -4 10 -4 -10 -10 -4z" opacity=".6"/></g>
+{% endblock %}
+{% block css %}
+.ig{--hh:380px}.ig h1{font-size:68px}
+.lr{position:relative;flex:none}.lr svg{position:absolute;left:0;top:0}
+.lr .co{position:absolute;width:470px;padding:16px 22px 18px;border-radius:18px;background:rgba(239,231,216,.07);border:1px solid rgba(239,231,216,.2)}
+.lr .co b{display:flex;align-items:center;gap:12px;font-family:var(--fh);font-size:29px;letter-spacing:.04em;text-transform:uppercase;margin-bottom:6px}
+.lr .co b i{font-style:normal;flex:none;width:38px;height:38px;border-radius:50%;display:grid;place-items:center;font-size:21px;color:#1d2a34;background:var(--c)}
+.lr .co p{font-size:23px;line-height:1.34;color:var(--mute)}
+.cd{display:grid;grid-template-columns:repeat(4,1fr);gap:16px;flex:none}
+.cd .t{position:relative;padding:16px 20px 18px;border-radius:16px;background:var(--card);border-top:6px solid var(--c)}
+.cd .t:after{content:"";position:absolute;right:18px;top:18px;width:13px;height:13px;border-radius:50%;background:var(--c);box-shadow:0 0 0 4px rgba(239,231,216,.1),0 0 14px var(--c)}
+.cd small{display:block;font-family:var(--fm);font-size:19px;letter-spacing:.1em;color:var(--c)}
+.cd b{display:block;font-family:var(--fh);font-size:30px;text-transform:uppercase;letter-spacing:.04em;margin:2px 0 6px}
+.cd p{font-size:21px;line-height:1.32;color:var(--mute)}
+{% endblock %}
+{% block body %}
+{% set S = 110 %}{% set n = c["items"]|length %}{% set H = 120 + n * S + 90 %}
+<section><div class="lab">{{ c.items_label }}</div>
+<div class="lr" style="height:{{ H }}px">
+  <svg width="1380" height="{{ H }}" viewBox="0 0 1380 {{ H }}">
+    <defs><linearGradient id="gr" x1="0" x2="1"><stop offset="0" stop-color="#e8dfcf"/><stop offset="1" stop-color="#b9b3a6"/></linearGradient></defs>
+    <path d="M690 0C738 36 760 76 760 120H620C620 76 642 36 690 0Z" fill="#c8745f"/>
+    {% for e in c["items"] %}{% set y = 120 + loop.index0 * S %}{% set cc = cycle[loop.index0 % cycle|length] %}
+    <rect x="620" y="{{ y }}" width="140" height="{{ S }}" fill="url(#gr)" stroke="#1d2a34" stroke-width="3"/>
+    <circle cx="690" cy="{{ y + S // 2 }}" r="30" fill="{{ cc }}" stroke="#1d2a34" stroke-width="3"/>
+    <text x="690" y="{{ y + S // 2 + 11 }}" text-anchor="middle" font-family="Jost" font-weight="700" font-size="32" fill="#1d2a34">{{ loop.index }}</text>
+    {% if loop.index0 % 2 == 0 %}<path d="M620 {{ y + S // 2 }}H480" stroke="{{ cc }}" stroke-width="3" stroke-dasharray="2 9" stroke-linecap="round"/>
+    {% else %}<path d="M760 {{ y + S // 2 }}H900" stroke="{{ cc }}" stroke-width="3" stroke-dasharray="2 9" stroke-linecap="round"/>{% endif %}
+    {% endfor %}
+    {% set yb = 120 + n * S %}
+    <path d="M620 {{ yb - S }}L552 {{ yb }}H620ZM760 {{ yb - S }}L828 {{ yb }}H760Z" fill="#c8745f"/>
+    <path d="M644 {{ yb }}h92l-10 26h-72Z" fill="#8a8578"/>
+    <path d="M656 {{ yb + 26 }}C664 {{ yb + 56 }} 690 {{ yb + 84 }} 690 {{ yb + 84 }}C690 {{ yb + 84 }} 716 {{ yb + 56 }} 724 {{ yb + 26 }}Z" fill="#cfa24d"/>
+    <path d="M672 {{ yb + 26 }}C678 {{ yb + 46 }} 690 {{ yb + 62 }} 690 {{ yb + 62 }}C690 {{ yb + 62 }} 702 {{ yb + 46 }} 708 {{ yb + 26 }}Z" fill="#f4ead3"/>
+  </svg>
+  {% for e in c["items"] %}{% set cc = cycle[loop.index0 % cycle|length] %}
+  <div class="co" style="--c:{{ cc }};top:{{ 120 + loop.index0 * S + S // 2 - 46 }}px;{{ 'left:0' if loop.index0 % 2 == 0 else 'right:0' }}"><b><i>{{ loop.index }}</i>{{ e.name }}</b><p>{{ e.text }}</p></div>
+  {% endfor %}
+</div></section>
+<section><div class="lab">{{ c.steps_label }}</div>
+<div class="cd">
+  {% for e in c.steps %}<div class="t" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><small>T-{{ c.steps|length - loop.index0 }}</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+{% endblock %}

backend/app/infographics/templates/moonbase.html.j2

@@ -0,0 +1,51 @@
+{% extends "base.html.j2" %}
+{% set eyebrow = "Lunar surface log" %}
+{% set pal = {"bg1":"#222226","bg2":"#3b3b42","ink":"#efeae0","mute":"#c7c3b9","a":"#d8d2c4","b":"#c8745f","card":"rgba(239,234,224,.07)","line":"rgba(239,234,224,.2)","paper":"#d8d2c4","paperink":"#222226","r":20} %}
+{% set fonts = {"h":"Outfit","b":"Outfit","m":"Space Mono","hw":600,"ht":"none","bt":"none"} %}
+{% set cycle = ["#d8d2c4","#c8745f","#9fb4a4","#8fa6c4","#d6b66a"] %}
+{% block bg %}
+<circle cx="1360" cy="190" r="110" fill="#5c7ea6" opacity=".55"/><circle cx="1360" cy="190" r="110" fill="none" stroke="#8fb0c9" stroke-opacity=".5" stroke-width="3"/>
+<path d="M0 2210Q300 2150 600 2190T1200 2180T1600 2170V2260H0Z" fill="#d8d2c4" opacity=".1"/>
+<g fill="#d8d2c4" opacity=".08"><ellipse cx="260" cy="2225" rx="120" ry="22"/><ellipse cx="900" cy="2235" rx="170" ry="24"/><ellipse cx="1400" cy="2220" rx="90" ry="18"/></g>
+{% endblock %}
+{% block hero %}
+<path d="M0 392Q120 340 240 372T480 350V400H0Z" fill="#d8d2c4" opacity=".85"/>
+<ellipse cx="90" cy="372" rx="46" ry="10" fill="#9b968a"/><ellipse cx="420" cy="380" rx="34" ry="8" fill="#9b968a"/>
+<path d="M130 365C130 270 190 220 250 220S370 270 370 360Z" fill="#8fa6c4" fill-opacity=".35" stroke="#d8d2c4" stroke-width="4"/>
+<path d="M190 366V318H310V366" fill="#c7c3b9" stroke="#222226" stroke-width="3"/><rect x="236" y="330" width="28" height="36" fill="#222226"/>
+<path d="M250 220V130" stroke="#d8d2c4" stroke-width="4"/><path d="M250 130H310L292 148L310 166H250Z" fill="#c8745f"/>
+<circle cx="70" cy="90" r="6" fill="#efeae0"/><circle cx="410" cy="60" r="8" fill="#efeae0" opacity=".7"/>
+{% endblock %}
+{% block css %}
+.ig h1{font-size:74px;letter-spacing:-.01em}
+.mc{display:flex;flex-direction:column;gap:14px;flex:none}
+.mc .cap{display:grid;grid-template-columns:84px 270px 1fr;gap:22px;align-items:center;width:1210px;min-height:104px;padding:12px 34px 12px 14px;border-radius:70px;background:var(--card);border:1px solid var(--line)}
+.mc .cap:nth-child(even){margin-left:auto}
+.mc .mk{width:76px;height:76px;border-radius:50%;display:grid;place-items:center;font-family:var(--fh);font-weight:600;font-size:36px;color:#222226;background:var(--c);border:6px solid rgba(34,34,38,.55);outline:3px solid var(--c)}
+.mc b{font-family:var(--fh);font-weight:600;font-size:31px;line-height:1.08}
+.mc p{font-size:23px;line-height:1.32;color:var(--mute)}
+.mt{display:grid;grid-template-columns:1fr 1fr;gap:0 56px;flex:none}
+.mt .col{position:relative;padding-left:46px}
+.mt .col:before{content:"";position:absolute;left:11px;top:8px;bottom:8px;width:3px;background:repeating-linear-gradient(180deg,var(--a) 0 10px,transparent 10px 18px);opacity:.55}
+.mt .ev{position:relative;padding:4px 0 18px}
+.mt .ev:before{content:"";position:absolute;left:-46px;top:8px;width:26px;height:26px;border-radius:7px;background:var(--c);box-shadow:0 0 0 6px rgba(216,210,196,.12)}
+.mt small{font-family:var(--fm);font-size:19px;letter-spacing:.14em;color:var(--c)}
+.mt b{display:block;font-family:var(--fh);font-weight:600;font-size:30px;margin:2px 0 3px}
+.mt p{font-size:22px;line-height:1.32;color:var(--mute)}
+.ig .band{border-top:10px solid transparent;border-image:repeating-linear-gradient(135deg,#c8745f 0 18px,#222226 18px 36px) 10}
+{% endblock %}
+{% block body %}{% set half = (c.steps|length + 1) // 2 %}
+<section><div class="lab">{{ c.items_label }}</div>
+<div class="mc">
+  {% for e in c["items"] %}<div class="cap" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><div class="mk">{{ loop.index }}</div><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+<section><div class="lab">{{ c.steps_label }}</div>
+<div class="mt">
+  <div class="col">
+    {% for e in c.steps[:half] %}<div class="ev" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><small>SOL {{ loop.index }}</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+  </div>
+  <div class="col">
+    {% for e in c.steps[half:] %}<div class="ev" style="--c:{{ cycle[(loop.index0 + half) % cycle|length] }}"><small>SOL {{ loop.index + half }}</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+  </div>
+</div></section>
+{% endblock %}

backend/app/infographics/templates/observatory.html.j2

@@ -0,0 +1,45 @@
+{% extends "base.html.j2" %}
+{% set eyebrow = "Observation log" %}
+{% set pal = {"bg1":"#102427","bg2":"#1d4144","ink":"#ece8da","mute":"#b9c9c4","a":"#8fc2b4","b":"#d6b66a","card":"rgba(236,232,218,.06)","line":"rgba(143,194,180,.3)","paper":"#ece8da","paperink":"#102427","r":14} %}
+{% set fonts = {"h":"Playfair Display","b":"Outfit","m":"Space Mono","hw":700,"ht":"none","bt":"none"} %}
+{% set cycle = ["#8fc2b4","#d6b66a","#a9b9d6","#d68f7a","#8fc2b4"] %}
+{% block bg %}
+<g fill="none" stroke="#8fc2b4" stroke-opacity=".14" stroke-width="2"><circle cx="1500" cy="300" r="260"/><circle cx="1500" cy="300" r="380"/><circle cx="1500" cy="300" r="500"/><path d="M1500 -200V800M1000 300H2000"/></g>
+<g stroke="#d6b66a" stroke-opacity=".35" stroke-width="2" fill="#d6b66a"><path d="M1090 190L1180 260L1260 220L1330 330" fill="none"/><circle cx="1090" cy="190" r="6"/><circle cx="1180" cy="260" r="8"/><circle cx="1260" cy="220" r="6"/><circle cx="1330" cy="330" r="7"/></g>
+{% endblock %}
+{% block hero %}
+<g transform="translate(240 240) rotate(-32)"><rect x="-130" y="-34" width="250" height="68" rx="8" fill="#d6b66a"/><rect x="-170" y="-26" width="46" height="52" rx="6" fill="#8fc2b4"/><rect x="100" y="-46" width="40" height="92" rx="6" fill="#ece8da"/><path d="M-60 -34V34M0 -34V34M60 -34V34" stroke="#102427" stroke-width="3"/></g>
+<path d="M240 250L170 390M240 250L320 390M240 250V392" stroke="#ece8da" stroke-width="7" stroke-linecap="round"/>
+<circle cx="380" cy="70" r="30" fill="#ece8da" opacity=".9"/><circle cx="392" cy="62" r="26" fill="#102427"/>
+<g fill="#d6b66a"><path d="M70 90l6 -16 6 16 16 6 -16 6 -6 16 -6 -16 -16 -6z"/><path d="M430 200l4 -11 4 11 11 4 -11 4 -4 11 -4 -11 -11 -4z"/></g>
+{% endblock %}
+{% block css %}
+.ig h1{font-size:68px}
+.ob{display:grid;grid-template-columns:1fr 1fr;gap:14px;flex:none}
+.ob .pl{position:relative;padding:20px 26px 22px;border-radius:var(--r);background:var(--card);border:1px solid var(--line)}
+.ob .pl:last-child:nth-child(even){grid-column:span 2}
+.ob .pl small{font-family:var(--fm);font-size:18px;letter-spacing:.2em;color:var(--c);text-transform:uppercase}
+.ob .pl b{display:block;font-family:var(--fh);font-weight:700;font-style:italic;font-size:32px;margin:4px 0 6px}
+.ob .pl p{font-size:23px;line-height:1.34;color:var(--mute)}
+.ob .feat{grid-column:span 2;display:grid;grid-template-columns:130px 1fr;gap:6px 28px;align-items:center;padding:26px 34px;background:linear-gradient(100deg,rgba(143,194,180,.18),rgba(143,194,180,.04));border-color:var(--c)}
+.ob .feat .big{grid-row:span 3;font-family:var(--fh);font-weight:700;font-size:118px;line-height:1;color:var(--c);opacity:.9}
+.ob .feat b{font-size:42px;margin:0}.ob .feat p{font-size:26px}
+.ed{display:grid;grid-template-columns:1fr 1fr;gap:0 56px;flex:none}
+.ed .li{display:grid;grid-template-columns:80px 1fr;gap:0 16px;padding:12px 0 14px;border-bottom:1px solid var(--line)}
+.ed .li .n{grid-row:span 2;font-family:var(--fh);font-weight:700;font-size:58px;line-height:.95;color:var(--c)}
+.ed .li b{font-family:var(--fh);font-weight:700;font-size:29px}
+.ed .li p{font-size:22px;line-height:1.3;color:var(--mute)}
+{% endblock %}
+{% block body %}<section><div class="lab">{{ c.items_label }}</div>
+<div class="ob">
+  {% for e in c["items"] %}{% if loop.first %}
+  <div class="pl feat" style="--c:{{ cycle[0] }}"><div class="big">1</div><small>The main idea</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>
+  {% else %}
+  <div class="pl" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><small>Plate {{ loop.index }}</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>
+  {% endif %}{% endfor %}
+</div></section>
+<section><div class="lab">{{ c.steps_label }}</div>
+<div class="ed">
+  {% for e in c.steps %}<div class="li" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><div class="n">{{ loop.index }}</div><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+{% endblock %}

backend/app/infographics/templates/solar.html.j2

@@ -0,0 +1,47 @@
+{% extends "base.html.j2" %}
+{% set eyebrow = "A tour of the solar system" %}
+{% set pal = {"bg1":"#1a2230","bg2":"#2e3d52","ink":"#f0ead9","mute":"#c2c9cf","a":"#d9a441","b":"#7fa3b8","card":"rgba(240,234,217,.07)","line":"rgba(240,234,217,.2)","paper":"#f0ead9","paperink":"#1a2230","r":16} %}
+{% set fonts = {"h":"Playfair Display","b":"Outfit","m":"Space Mono","hw":700,"ht":"none","bt":"none"} %}
+{% set cycle = ["#d9a441","#c8745f","#7fa3b8","#8fb0a0","#b79ad6"] %}
+{% block bg %}
+<g fill="none" stroke="#f0ead9" stroke-opacity=".12" stroke-width="2"><circle cx="-120" cy="1100" r="620"/><circle cx="-120" cy="1100" r="900"/><circle cx="-120" cy="1100" r="1180"/><circle cx="-120" cy="1100" r="1460"/></g>
+<circle cx="-120" cy="1100" r="190" fill="#d9a441" opacity=".13"/>
+<circle cx="1556" cy="860" r="18" fill="#c8745f" opacity=".6"/><circle cx="1560" cy="1500" r="26" fill="#7fa3b8" opacity=".5"/>
+{% endblock %}
+{% block hero %}
+<circle cx="-40" cy="200" r="120" fill="#d9a441"/><circle cx="-40" cy="200" r="150" fill="#d9a441" opacity=".25"/>
+<path d="M0 340Q240 360 480 300" stroke="#f0ead9" stroke-opacity=".5" stroke-width="2" stroke-dasharray="3 9" fill="none"/>
+<circle cx="150" cy="120" r="22" fill="#b9ad90"/><circle cx="220" cy="270" r="34" fill="#c8745f"/><circle cx="300" cy="150" r="42" fill="#7fa3b8"/><circle cx="305" cy="145" r="42" fill="none" stroke="#f0ead9" stroke-opacity=".0"/>
+<g transform="translate(400 250)"><ellipse rx="70" ry="18" fill="none" stroke="#e6d3a1" stroke-width="7" transform="rotate(-18)"/><circle r="40" fill="#d9a441"/><path d="M-72 10Q0 34 72 -6" stroke="#e6d3a1" stroke-width="7" fill="none" transform="rotate(-18)"/></g>
+<circle cx="420" cy="80" r="26" fill="#8fb0a0"/>
+{% endblock %}
+{% block css %}
+.ig h1{font-size:70px}
+.sp{display:flex;gap:18px;flex:none;align-items:stretch}
+.sp .pl{flex:1;display:flex;flex-direction:column;align-items:center;text-align:center;padding:0 6px}
+.sp .og{height:140px;display:flex;align-items:flex-end;margin-bottom:-34px;z-index:1}
+.sp .orb{position:relative;display:grid;place-items:center;border-radius:50%;font-family:var(--fh);font-weight:700;font-size:42px;color:#1a2230;background:radial-gradient(circle at 32% 28%,#fff9,var(--c) 62%);box-shadow:inset -14px -12px 0 rgba(0,0,0,.2)}
+.sp .card{width:100%;padding:48px 18px 20px;border-radius:var(--r);background:var(--card);border:1px solid var(--line);flex:1}
+.sp b{display:block;font-family:var(--fh);font-weight:700;font-size:31px;margin-bottom:8px;line-height:1.1}
+.sp p{font-size:22px;line-height:1.34;color:var(--mute)}
+.sm{display:grid;grid-template-columns:repeat(4,1fr);gap:0 24px;row-gap:22px;flex:none}
+.sm .stop{position:relative;padding-top:44px}
+.sm .stop:before{content:"";position:absolute;left:0;right:-24px;top:14px;height:8px;border-radius:4px;background:var(--c);opacity:.85}
+.sm .stop:nth-child(4n):before{right:0}
+.sm .stop:after{content:"";position:absolute;left:6px;top:7px;width:22px;height:22px;border-radius:50%;background:#f0ead9;border:6px solid var(--c);box-sizing:border-box;width:22px;height:22px}
+.sm small{display:block;font-family:var(--fm);font-size:19px;letter-spacing:.1em;color:var(--c);margin-bottom:3px}
+.sm b{display:block;font-family:var(--fh);font-weight:700;font-size:31px;margin-bottom:5px}
+.sm p{font-size:22px;line-height:1.32;color:var(--mute)}
+{% endblock %}
+{% block body %}{% set n = c["items"]|length %}{% set sizes = [124, 100, 138, 92, 116] %}
+<section><div class="lab">{{ c.items_label }}</div>
+<div class="sp">
+  {% for e in c["items"] %}{% set d = sizes[loop.index0] %}
+  <div class="pl" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><div class="og"><div class="orb" style="width:{{ d }}px;height:{{ d }}px">{{ loop.index }}</div></div><div class="card"><b>{{ e.name }}</b><p>{{ e.text }}</p></div></div>
+  {% endfor %}
+</div></section>
+<section><div class="lab">{{ c.steps_label }}</div>
+<div class="sm">
+  {% for e in c.steps %}<div class="stop" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><small>Stop {{ loop.index }}</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+{% endblock %}

backend/app/infographics/templates/station.html.j2

@@ -0,0 +1,47 @@
+{% extends "base.html.j2" %}
+{% set eyebrow = "Station blueprint" %}
+{% set pal = {"bg1":"#13263a","bg2":"#1f3d57","ink":"#e6eef2","mute":"#b3c5d0","a":"#8fb8c9","b":"#d9a441","card":"rgba(143,184,201,.08)","line":"rgba(143,184,201,.35)","paper":"#e6eef2","paperink":"#13263a","r":4} %}
+{% set fonts = {"h":"Jost","b":"Outfit","m":"Space Mono","hw":700,"ht":"uppercase","bt":"uppercase"} %}
+{% set cycle = ["#8fb8c9","#d9a441","#9cc4a6","#d68f7a","#8fb8c9"] %}
+{% block bg %}
+<g stroke="#8fb8c9" stroke-opacity=".1" stroke-width="1">{% for x in range(0, 1601, 80) %}<line x1="{{ x }}" y1="0" x2="{{ x }}" y2="2260"/>{% endfor %}{% for y in range(0, 2261, 80) %}<line x1="0" y1="{{ y }}" x2="1600" y2="{{ y }}"/>{% endfor %}</g>
+<rect x="60" y="60" width="1480" height="2140" fill="none" stroke="#8fb8c9" stroke-opacity=".5" stroke-width="2"/>
+{% endblock %}
+{% block hero %}
+<g fill="none" stroke="#8fb8c9" stroke-width="3">
+<rect x="190" y="130" width="100" height="140" rx="10" fill="#1f3d57"/><rect x="215" y="60" width="50" height="70"/><rect x="215" y="270" width="50" height="70"/>
+<circle cx="240" cy="200" r="30" stroke="#d9a441"/>
+<rect x="20" y="170" width="150" height="60" fill="#1f3d57"/><rect x="310" y="170" width="150" height="60" fill="#1f3d57"/>
+<path d="M60 170V230M100 170V230M140 170V230M350 170V230M390 170V230M430 170V230" stroke-width="2"/>
+<path d="M170 200H190M290 200H310" stroke="#d9a441"/>
+<path d="M10 360H470M10 350V370M470 350V370" stroke-dasharray="6 6" stroke-width="2"/>
+</g>
+{% endblock %}
+{% block css %}
+.ig h1{font-size:66px}
+.sg{display:grid;grid-template-columns:1fr 1fr;gap:16px;flex:none}
+.sg .mod{position:relative;padding:44px 26px 22px;background:var(--card);border:1px dashed var(--line)}
+.sg .mod:last-child:nth-child(odd){grid-column:span 2}
+.sg .mod:before,.sg .mod:after{content:"";position:absolute;width:26px;height:26px;border:3px solid var(--c)}
+.sg .mod:before{left:-2px;top:-2px;border-right:0;border-bottom:0}
+.sg .mod:after{right:-2px;bottom:-2px;border-left:0;border-top:0}
+.sg .tag{position:absolute;left:26px;top:12px;font-family:var(--fm);font-size:18px;letter-spacing:.2em;color:var(--c);text-transform:uppercase}
+.sg .tag em{font-style:normal;color:var(--mute)}
+.sg b{display:block;font-family:var(--fh);font-weight:700;font-size:32px;letter-spacing:.03em;text-transform:uppercase;margin-bottom:6px}
+.sg p{font-size:24px;line-height:1.34;color:var(--mute)}
+.lg{display:grid;grid-template-columns:1fr 1fr;gap:0 40px;flex:none;border-top:2px solid var(--line)}
+.lg .row{display:grid;grid-template-columns:96px 1fr;grid-template-rows:auto 1fr;align-content:start;gap:6px 18px;padding:12px 0;border-bottom:1px dashed var(--line)}
+.lg .row small{grid-row:span 2;font-family:var(--fm);font-size:20px;color:var(--c);letter-spacing:.08em;padding-top:5px}
+.lg .row b{font-family:var(--fh);font-weight:700;font-size:28px;letter-spacing:.04em;text-transform:uppercase}
+.lg .row p{font-size:22px;line-height:1.3;color:var(--mute)}
+.ig .band{border:3px double var(--a)}
+{% endblock %}
+{% block body %}<section><div class="lab">{{ c.items_label }}</div>
+<div class="sg">
+  {% for e in c["items"] %}<div class="mod" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><span class="tag">Module <em>{{ 'ABCDE'[loop.index0] }}-{{ '%02d'|format(loop.index) }}</em></span><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+<section><div class="lab">{{ c.steps_label }}</div>
+<div class="lg">
+  {% for e in c.steps %}<div class="row" style="--c:{{ cycle[loop.index0 % cycle|length] }}"><small>SEQ {{ '%02d'|format(loop.index) }}</small><b>{{ e.name }}</b><p>{{ e.text }}</p></div>{% endfor %}
+</div></section>
+{% endblock %}

backend/app/infographics/themes.py

@@ -0,0 +1,26 @@
+"""The premade themes: one HTML template each (templates/<id>.html.j2), all space themed with muted palettes."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Theme:
+    id: str
+    name: str
+    blurb: str
+    swatch: tuple[str, str, str]  # background, accent, second accent: for the picker card
+
+
+THEMES: dict[str, Theme] = {t.id: t for t in (
+    Theme("launch", "Launch", "A rocket, stage by stage, with a countdown", ("#1d2a34", "#cfa24d", "#c8745f")),
+    Theme("galaxy", "Galaxy", "Spiral arms and glowing orbit rings", ("#241f33", "#b79ad6", "#7fa3b8")),
+    Theme("solar", "Solar System", "Planets in a row and a route between them", ("#1b2433", "#d9a441", "#7fa3b8")),
+    Theme("station", "Space Station", "A blueprint of modules and solar wings", ("#16283a", "#8fb8c9", "#d9a441")),
+    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"
+
+
+def theme_id(value: object) -> str:
+    return value if isinstance(value, str) and value in THEMES else DEFAULT_THEME

backend/app/llm/provider.py

@@ -52,6 +52,16 @@ def fast_lm() -> dspy.LM:
     return _build(settings.llm_fast_model, effort="low", temperature=None, max_tokens=8000)
 
 
+REPORT_MAX_TOKENS = 16000  # a few pages of prose plus GLM's low-effort reasoning
+
+
+@lru_cache
+def report_lm() -> dspy.LM:
+    """Writes reports: the fast model unless LLM_REPORT_MODEL names another, with room for a long answer."""
+    return _build(settings.llm_report_model or settings.llm_fast_model, effort="low", temperature=None,
+                  max_tokens=REPORT_MAX_TOKENS)
+
+
 @lru_cache
 def triage_lm() -> dspy.LM:
     """Cheap model that decides whether a chat message needs research at all."""

backend/app/llm/signatures.py

@@ -353,6 +353,208 @@ class ArrangeMindMap(dspy.Signature):
     branches: list[MindArrangedBranch] = dspy.OutputField(desc="3 to 10 branches")
 
 
+class QuizQuestion(BaseModel):
+    type: Literal["multiple_choice", "multiple_select", "fill_blank", "short_answer"]
+    question: str = Field(description="The question. A fill_blank question has exactly one ____ where the answer goes")
+    options: list[str] = Field(default_factory=list, description="3 to 5 choices for multiple_choice and "
+                                                                 "multiple_select, otherwise empty")
+    correct: list[int] = Field(default_factory=list, description="Zero based indexes into options: one for "
+                                                                 "multiple_choice, two or more for multiple_select")
+    answer: str = Field(default="", description="fill_blank: the word or phrase for the blank. short_answer: a model "
+                                                "answer in one or two sentences. Empty for the choice types")
+    accepted: list[str] = Field(default_factory=list, description="fill_blank only: other wordings that are also right")
+    explanation: str = Field(description="One or two sentences on why the answer is right")
+    sources: list[SourceRef] = Field(default_factory=list, description="Lines the answer comes from, when the "
+                                                                       "material has numbered lines")
+
+
+class GenerateQuiz(dspy.Signature):
+    """Write a quiz that tests whether the reader understood the material. Ask only about what the material says;
+    never use outside facts. Every question has one clear answer the material supports. Use only the question types
+    allowed, mixing them when several are allowed, and write exactly the number of questions asked for. Wrong
+    options must be plausible, not silly, and options must not give the answer away by length or wording. When a
+    topic is given, ask only about it, as far as the material covers it. Match the difficulty: easy asks for recall
+    of stated facts, medium asks for understanding, hard asks for applying ideas or telling similar ideas apart.
+    Write in the language requested. Never use em dashes."""
+
+    title: str = dspy.InputField()
+    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
+    topic: str = dspy.InputField(desc="What the quiz should be about, or (none)")
+    difficulty: str = dspy.InputField(desc="easy, medium or hard")
+    question_types: list[str] = dspy.InputField(desc="The only question types allowed")
+    count: int = dspy.InputField(desc="How many questions to write")
+    language: str = dspy.InputField(desc="The language to write in")
+    questions: list[QuizQuestion] = dspy.OutputField()
+
+
+class Flashcard(BaseModel):
+    front: str = Field(description="A term, a question or a prompt, short")
+    back: str = Field(description="The answer or definition in one to three plain sentences")
+    sources: list[SourceRef] = Field(default_factory=list, description="Lines the card comes from, when the material "
+                                                                       "has numbered lines")
+
+
+class GenerateFlashcards(dspy.Signature):
+    """Write flashcards for studying the material: each card has a short front (a term, a question or a prompt) and a
+    back that answers it from the material. Cover the main ideas, not trivia, and do not repeat a card. Never use
+    outside facts. When a topic is given, make cards only about it, as far as the material covers it. Match the
+    difficulty: easy cards test recall of stated terms and facts, medium cards test understanding, hard cards ask the
+    reader to apply an idea or tell similar ideas apart. Write in the language requested. Never use em dashes."""
+
+    title: str = dspy.InputField()
+    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
+    topic: str = dspy.InputField(desc="What the cards should be about, or (none)")
+    difficulty: str = dspy.InputField(desc="easy, medium or hard")
+    count: int = dspy.InputField(desc="How many cards to write")
+    language: str = dspy.InputField(desc="The language to write in")
+    cards: list[Flashcard] = dspy.OutputField()
+
+
+class InfographicEntry(BaseModel):
+    name: str = Field(description="1 to 3 words")
+    text: str = Field(description="One short plain sentence")
+
+
+class InfographicOut(BaseModel):
+    title: str = Field(description="At most 8 words")
+    subtitle: str = Field(description="One line, at most 16 words")
+    items_label: str = Field(description="A 2 to 4 word heading for the items, e.g. The five layers")
+    items: list[InfographicEntry] = Field(description="3 to 5 main ideas, text at most 18 words each")
+    steps_label: str = Field(description="A 2 to 5 word heading for the steps, e.g. How a request flows")
+    steps: list[InfographicEntry] = Field(description="4 to 8 steps in order, name 1 or 2 words, text at most 12 words")
+    rule: str = Field(description="The one takeaway, at most 12 words")
+    notes: list[str] = Field(description="Exactly 3 supporting notes, at most 14 words each")
+
+
+class PlanInfographic(dspy.Signature):
+    """Turn the material into the text of a one page infographic: a title, the main ideas, the ordered steps or stages
+    that connect them, one takeaway and three notes. Use only what the material says. When a focus is given, make the
+    infographic about it, as far as the material covers it. The material is a list of ideas from posts, or chat
+    transcripts (then summarise what was discussed and concluded). Keep every line short and plain: it is printed on a
+    poster, so no markdown, no quotes around names, no lists inside a line. Write in the language of the material.
+    Never use em dashes."""
+
+    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)")
+    infographic: InfographicOut = 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
+    first "## " heading (the title goes in report_title, not in the text). Structure it like a well organised
+    article: open with a "## Introduction" that says what the report covers (and, for a study or how-to report, what the
+    reader will be able to do by the end), then 3 to 7 sections, then close with a "## Summary" of the key takeaways,
+    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 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 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."""
+
+    title: str = dspy.InputField(desc="The notebook, post or chat the material comes from")
+    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
+    request: str = dspy.InputField(desc="What the reader wants the report to be")
+    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):
+    kind: Literal["mind_map", "flashcards", "quiz", "infographic"]
+    title: str = Field(description="A short heading for the visual, 2 to 6 words")
+    brief: str = Field(description="What the visual covers, one sentence, drawn from this section")
+    why: str = Field(description="Why it helps the reader at this point, one short sentence")
+
+
+class PlannedSection(BaseModel):
+    heading: str = Field(description="2 to 8 words")
+    brief: str = Field(description="What this section says and which part of the material it draws on, 1 to 2 sentences")
+    embed: PlannedEmbed | None = Field(None, description="A visual to suggest right after this section, only where it "
+                                                         "really helps")
+
+
+class PlanInteractiveReport(dspy.Signature):
+    """Plan an interactive report the reader describes, from the material given. Every section is written text: never plan a
+    section that is itself a quiz, flashcards, practice questions or a mind map, because those are visuals, and are
+    suggested through a section's visual instead. Choose 4 to 8 sections in a sensible
+    order, starting with an Introduction and ending with a Summary unless the reader asks for something else. Each
+    heading is specific and descriptive of what the section covers, never generic like "Details" or "Section 2". Then decide, section by section, where a visual would help the reader and which one. These are only
+    suggestions: nothing is built until the reader clicks Add, so suggest the spots where each really fits: a mind_map to show how
+    many linked ideas fit together (at most one, usually near the start or the end), flashcards to learn a set of
+    terms or facts, a quiz to check understanding after a dense section, an infographic for a one page picture of the
+    main ideas. Use at most four visuals in all, each kind
+    at most once, and none where plain prose reads better. Only the kinds allowed may be used. Use only what the
+    material covers. Never use em dashes."""
+
+    title: str = dspy.InputField()
+    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
+    request: str = dspy.InputField(desc="What the reader wants the report to be")
+    allowed_kinds: list[str] = dspy.InputField(desc="The visuals that may be used")
+    language: str = dspy.InputField()
+    report_title: str = dspy.OutputField(desc="A specific title, 3 to 10 words")
+    sections: list[PlannedSection] = dspy.OutputField(desc="4 to 8 sections")
+
+
+class WriteReportSection(dspy.Signature):
+    """Write one section of a report, using only the material given. 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. 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, 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."""
+
+    title: str = dspy.InputField()
+    report_title: str = dspy.InputField()
+    heading: str = dspy.InputField()
+    brief: str = dspy.InputField(desc="What this section should say")
+    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()
+    markdown: str = dspy.OutputField(desc="The section body in Markdown, without its heading")
+    citations: list[FileCitation] = dspy.OutputField()
+
+
+class ReportTemplateIdea(BaseModel):
+    name: str = Field(description="2 to 4 words, a kind of report, like a field guide or a decision memo")
+    description: str = Field(description="One short sentence on what the reader gets")
+    prompt: str = Field(description="The instructions for the writer, two to four sentences, specific to this material: "
+                                    "what the report covers, how it is organised, and its tone")
+
+
+class SuggestReportTemplates(dspy.Signature):
+    """Suggest four different kinds of report a reader could make from this material. Each is specific to what the
+    material is actually about, not a generic format, and the four are clearly different from each other (for example
+    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")
+    topic: str = dspy.InputField(desc="What the reader wants the report to be about, or (none)")
+    templates: list[ReportTemplateIdea] = dspy.OutputField(desc="Exactly 4")
+
+
+class EmbedIdea(BaseModel):
+    after_block_id: str = Field(description="Id of the section the visual goes right after, exactly as listed")
+    kind: Literal["mind_map", "flashcards", "quiz", "infographic"]
+    brief: str = Field(description="What the visual should cover, one sentence, about that section")
+    why: str = Field(description="Why it helps the reader at that point, one short sentence")
+
+
+class SuggestEmbeds(dspy.Signature):
+    """Look at a finished report's sections and suggest up to four places where a visual would help the reader:
+    a mind_map to show how many linked ideas fit together, flashcards to learn a set of terms or facts, a quiz to
+    check understanding after a dense section. Pick the sections where each really fits, use only the kinds allowed,
+    and do not suggest the same kind twice in a row. Never use em dashes."""
+
+    sections: list[str] = dspy.InputField(desc="One per line: id | heading: the start of the section")
+    allowed_kinds: list[str] = dspy.InputField()
+    suggestions: list[EmbedIdea] = dspy.OutputField(desc="0 to 4")
+
+
 class ExtractTopics(dspy.Signature):
     """Name the topics this post is about, the way a reader would search for them."""
 

backend/app/main.py

@@ -17,7 +17,9 @@ from app.routers import (
     launchpad,
     memory,
     notebooks,
+    reports,
     resurface,
+    share,
     sources,
     storage,
     support,
@@ -94,7 +96,7 @@ def health():
 
 # video_templates (custom templates) is switched off: users pick only from the built-in templates.
 for r in (auth, billing, storage, sources, notebooks, artifacts, jobs, unsubscribe, topics, voice, resurface,
-          launchpad, videos, video_edit, video_voices, video_styles, settings_router, memory, support):
+          launchpad, videos, video_edit, video_voices, video_styles, settings_router, memory, support, reports, share):
     app.include_router(r.router)
 app.include_router(sources.documents_router)
 app.include_router(launchpad.links_router)

backend/app/models/__init__.py

@@ -1,5 +1,6 @@
 from app.models.content import (
     Artifact,
+    ArtifactShare,
     B2VCustomVoice,
     B2VStyle,
     B2VTemplate,
@@ -36,6 +37,7 @@ __all__ = [
     "SupportConversation",
     "SupportMessage",
     "Artifact",
+    "ArtifactShare",
     "AuthProvider",
     "B2VCustomVoice",
     "B2VStyle",

backend/app/models/content.py

@@ -15,6 +15,7 @@ from sqlalchemy import (
     UniqueConstraint,
     Uuid,
     text,
+    true,
 )
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -195,6 +196,18 @@ class Artifact(IdMixin, TimestampMixin, Base):
     storage_key: Mapped[str | None] = mapped_column(String(500))
 
 
+class ArtifactShare(IdMixin, TimestampMixin, Base):
+    """A public link to one artifact (a report): anyone holding the token can read the shared view, nothing else.
+    Revoking deletes the row, so a new link is a new token."""
+
+    __tablename__ = "artifact_shares"
+
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    artifact_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("artifacts.id", ondelete="CASCADE"), unique=True)
+    token: Mapped[str] = mapped_column(String(64), unique=True, index=True)
+    show_sources: Mapped[bool] = mapped_column(Boolean, default=True, server_default=true())
+
+
 class B2VVideo(IdMixin, TimestampMixin, Base):
     """One blog2video video we asked for: the only place its blog2video id lives. Every read, edit and delete on
     blog2video goes through this row (b2v_video_id, and created_via for the right endpoints). Also records who made it

backend/app/models/user.py

@@ -54,6 +54,8 @@ class Workspace(IdMixin, TimestampMixin, Base):
     name: Mapped[str] = mapped_column(String(200))
     owner_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"))
     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")
@@ -108,6 +110,8 @@ class PlanRecord(TimestampMixin, Base):
     audio_minutes: Mapped[int] = mapped_column(Integer, default=0)
     videos: Mapped[int] = mapped_column(Integer, default=0)
     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
     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

backend/app/pipeline/flashcards.py

@@ -0,0 +1,54 @@
+"""Flashcards: front and back cards written from a notebook's posts or from notebook chats, flipped in the browser."""
+
+import uuid
+
+from sqlalchemy.orm import Session
+
+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.generate import NothingToDo
+from app.pipeline.material import Material, load_material
+from app.services.jobs import update_job
+
+SAME_LANGUAGE = "the same language as the sources"  # no language picked: write as the material is written
+CARD_COUNTS = {"fewer": 8, "standard": 16, "more": 24}
+
+
+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())
+    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:
+            continue
+        seen.add(key)
+        cards.append({"front": front[:300], "back": back[:800], "sources": material.refs(c.get("sources"))})
+    return cards[:count]
+
+
+def build_flashcards(db: Session, job: Job, artifact: Artifact) -> dict:
+    params = job.params
+    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")
+    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)
+    if not cards:
+        raise NothingToDo("The material did not give enough to make cards from. Try other posts or another topic.")
+    artifact.content_json = {
+        "title": f"Flashcards: {topic[:60] or material.title}", "topic": topic, "difficulty": difficulty,
+        "language": params.get("language") or SAME_LANGUAGE, "source": material.source, "cards": cards,
+        "card_count": len(cards),
+    }
+    artifact.status = "ready"
+    db.commit()
+    return {"artifact_id": str(artifact.id)}

backend/app/pipeline/generate.py

@@ -152,9 +152,6 @@ def extract_ideas(db: Session, job: Job | None, workspace_id: uuid.UUID, doc_ids
 
 
 def build_mind_map(db: Session, job: Job, artifact: Artifact) -> dict:
-    """A tree (centre, branches, sub-themes, points) over the picked posts, arranged from the ideas already stored
-    on each post. A focus decides how they are grouped and weighted, never which posts are on the map: every idea
-    the model leaves out is filed next to a sibling from the same post, or under a catch-all branch."""
     nb = db.get(Notebook, artifact.notebook_id)
     docs = notebook_docs(db, nb.id)
     picked = {str(i) for i in job.params.get("document_ids") or []}
@@ -162,12 +159,25 @@ def build_mind_map(db: Session, job: Job, artifact: Artifact) -> dict:
         docs = [d for d in docs if str(d.id) in picked]
     if not docs:
         raise NothingToDo("Pick at least one post for the Mind Constellation.")
-    focus = (job.params.get("focus") or "").strip()
-    corpus = Corpus(nb.workspace_id)
+    artifact.content_json = mind_map_content(db, job, nb.workspace_id, nb.title, docs,
+                                             (job.params.get("focus") or "").strip())
+    artifact.status = "ready"
+    db.commit()
+    return {"artifact_id": str(artifact.id)}
+
+
+def mind_map_content(db: Session, job: Job | None, workspace_id: uuid.UUID, title: str, docs: list[Document],
+                     focus: str = "") -> dict:
+    """A tree (centre, branches, sub-themes, points) over the given posts, arranged from the ideas already stored
+    on each post. A focus decides how they are grouped and weighted, never which posts are on the map: every idea
+    the model leaves out is filed next to a sibling from the same post, or under a catch-all branch. Used for a
+    Mind Constellation artifact and for the map inside a report."""
+    corpus = Corpus(workspace_id)
     stale = [d for d in docs if not ideas_fresh(d)]
     if stale:  # background extraction has not reached these yet, so do it now
-        update_job(db, job, progress=0.1, message=f"Reading {len(stale)} posts")
-        extract_ideas(db, None, nb.workspace_id, [str(d.id) for d in stale])
+        if job:
+            update_job(db, job, progress=0.1, message=f"Reading {len(stale)} posts")
+        extract_ideas(db, None, workspace_id, [str(d.id) for d in stale])
     tools = tools_for(corpus, docs)
 
     def refs(items) -> list[dict]:
@@ -196,9 +206,10 @@ def build_mind_map(db: Session, job: Job, artifact: Artifact) -> dict:
     # A very large notebook lists labels only, and the leftover rule below files whatever is not listed.
     brief = len(pool) > BRIEF_ABOVE
     listing = [f"{i} | {n['label']}" if brief else f"{i} | {n['label']}: {n['note'][:140]}" for i, n in pool.items()]
-    update_job(db, job, progress=0.4, message="Charting the constellation")
-    out = run.predict(ArrangeMindMap, db=db, workspace_id=nb.workspace_id, job=job,
-                      title=nb.title, focus=focus or "(none)", ideas=listing)
+    if job:
+        update_job(db, job, progress=0.4, message="Charting the constellation")
+    out = run.predict(ArrangeMindMap, db=db, workspace_id=workspace_id, job=job,
+                      title=title, focus=focus or "(none)", ideas=listing)
 
     placed: set[str] = set()
     branches: list[dict] = []
@@ -228,21 +239,18 @@ def build_mind_map(db: Session, job: Job, artifact: Artifact) -> dict:
 
     for i, b in enumerate(branches):
         _number(b, str(i))
-    centre = (out.get("centre") or focus or nb.title).strip()[:80]
+    centre = (out.get("centre") or focus or title).strip()[:80]
     root = {"id": "root", "label": centre, "note": (out.get("overview") or "").strip()[:500], "sources": [],
             "children": branches}
 
     def count(n: dict) -> int:
         return 1 + sum(count(c) for c in n["children"])
 
-    artifact.content_json = {
-        "title": f"Mind Constellation: {focus[:60] or nb.title}", "focus": focus, "root": root,
+    return {
+        "title": f"Mind Constellation: {focus[:60] or title}", "focus": focus, "root": root,
         "node_count": count(root), "document_ids": [str(d.id) for d in docs], "post_count": len(docs),
         "covered_count": len(_cited(branches) & {str(d.id) for d in docs}),
     }
-    artifact.status = "ready"
-    db.commit()
-    return {"artifact_id": str(artifact.id)}
 
 
 # Topic map

backend/app/pipeline/infographic.py

@@ -0,0 +1,116 @@
+"""Infographics: a short block of text written from posts' stored ideas and/or chats (and the user's own prompt),
+poured into a premade space theme. The model writes content only (a few hundred tokens), never the page, which is
+what keeps it to seconds and keeps every word spelled as written. The page is shown as HTML; the PNG is drawn by the
+Remotion service only when someone downloads it."""
+
+import uuid
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.corpus import Corpus
+from app.infographics.content import clamp
+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.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.passages import notebook_docs, passages_for, workspace_docs
+from app.services.jobs import update_job
+
+IDEAS_BUDGET = 7_000  # characters of stored ideas the model reads
+CHAT_BUDGET = 9_000  # characters of chat transcript the model reads
+
+
+def _ideas_text(db: Session, workspace_id: uuid.UUID, docs: list[Document], job: Job | None) -> list[str]:
+    """One block per post from the ideas already stored on it (extracted now for a post that has none)."""
+    stale = [str(d.id) for d in docs if not ideas_fresh(d)]
+    if stale:
+        extract_ideas(db, job, workspace_id, stale)
+        for d in docs:
+            db.refresh(d)
+    share = IDEAS_BUDGET // max(len(docs), 1)
+    corpus = Corpus(workspace_id)
+    out = []
+    for d in docs:
+        ideas = (d.metadata_json or {}).get("ideas") if ideas_fresh(d) else None
+        if ideas:
+            lines = []
+            for i in ideas:
+                points = "; ".join(str(p) for p in (i.get("details") or [])[:3] if isinstance(p, str))
+                lines.append(f"- {i.get('label', '')}: {i.get('note', '')}" + (f" ({points})" if points else ""))
+            body = "\n".join(lines)
+        else:  # extraction failed for this post: its opening lines
+            body = "\n".join(passages_for(corpus, [d], budget_chars=share))
+        out.append(f"POST {d.title}\n{body}"[:share])
+    return out
+
+
+def _chat_text(db: Session, workspace_id: uuid.UUID, chat_ids: list[uuid.UUID]) -> tuple[list[Chat], list[str]]:
+    chats = list(db.scalars(select(Chat).where(Chat.id.in_(chat_ids), Chat.workspace_id == workspace_id)
+                            .order_by(Chat.created_at)))
+    share = CHAT_BUDGET // max(len(chats), 1)
+    return chats, [t[-share:] for t in chat_material(db, chats)]
+
+
+def write_content(db: Session, job: Job, artifact: Artifact, params: dict) -> tuple[dict, dict, str]:
+    """The clamped content, the source it came from and a title. Raises NothingToDo when there is nothing to draw."""
+    ws = artifact.workspace_id
+    chat_ids = [uuid.UUID(str(i)) for i in params.get("chat_ids") or []]
+    picked = [uuid.UUID(str(i)) for i in params.get("document_ids") or []]
+    nb = db.get(Notebook, artifact.notebook_id) if artifact.notebook_id else None
+    docs: list[Document] = []
+    if picked:
+        docs = workspace_docs(db, ws, picked)
+    elif not chat_ids and nb:
+        docs = notebook_docs(db, nb.id)
+    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.")
+
+    update_job(db, job, progress=0.1, message="Reading the key ideas")
+    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")
+    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 {})
+        if content:
+            break
+    if not content:
+        raise NothingToDo("The material did not give enough to draw. Try other posts or add a prompt.")
+    source: dict = {"kind": "mixed" if docs and chat_blocks else "posts" if docs else "chats"}
+    if docs:
+        source["document_ids"] = [str(d.id) for d in docs]
+    if chat_blocks:
+        source["chat_ids"] = [str(c.id) for c in chats]
+    source["count"] = len(docs) + len(chats if chat_blocks else [])
+    return content, source, title
+
+
+def build_infographic(db: Session, job: Job, artifact: Artifact) -> dict:
+    """Write the text and keep it with the theme. The page is built from them whenever it is shown (so it is ready at
+    once) and shared by link."""
+    params = job.params
+    theme = theme_id(params.get("theme"))
+    content, source, _title = write_content(db, job, artifact, params)
+    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}
+    artifact.storage_key = None
+    artifact.status = "ready"
+    db.commit()
+    return {"artifact_id": str(artifact.id)}
+
+
+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)."""
+    text = content.get("content")
+    return build_html(theme_id(content.get("theme")), text, layout) if text else None

backend/app/pipeline/ingest.py

@@ -681,6 +681,34 @@ def ingest_source(db: Session, source: Source, job: Job, max_posts: int) -> dict
             "changed": [str(i) for i in changed]}
 
 
+_VTT_TIME = re.compile(r"^(\d+:)?\d{1,2}:\d{2}[.,]\d{3}\s+-->\s+")
+
+
+def vtt_to_text(text: str) -> str:
+    """The spoken words of a WebVTT transcript: the header, notes, cue ids, timestamps and markup dropped, a line
+    repeated from the cue before (rolling captions) kept once, the rest joined into paragraphs."""
+    lines: list[str] = []
+    in_cue = False
+    skipping = False  # inside a NOTE / STYLE / REGION block, until the blank line
+    for raw in text.lstrip("\ufeff").splitlines():
+        line = raw.strip()
+        if not line:
+            in_cue = skipping = False
+            continue
+        if skipping or line.startswith(("WEBVTT", "NOTE", "STYLE", "REGION")) and not in_cue:
+            skipping = True
+            continue
+        if _VTT_TIME.match(line):
+            in_cue = True
+            continue
+        if not in_cue:
+            continue  # a cue id
+        line = re.sub(r"<[^>]+>", "", line).strip()
+        if line and (not lines or lines[-1] != line):
+            lines.append(line)
+    return "\n\n".join(" ".join(lines[i:i + 8]) for i in range(0, len(lines), 8))
+
+
 def entry_from_upload(filename: str, content_type: str, data: bytes) -> FeedEntry:
     name = filename.rsplit("/", 1)[-1]
     stem = re.sub(r"\.[A-Za-z0-9]+$", "", name).replace("-", " ").replace("_", " ").strip() or "Untitled"
@@ -693,6 +721,8 @@ def entry_from_upload(filename: str, content_type: str, data: bytes) -> FeedEntr
         soup = BeautifulSoup(text, "html.parser")
         title = soup.title.get_text(strip=True) if soup.title else stem
         return FeedEntry(title=title, url=url, published_at=None, html=text)
+    if lower.endswith(".vtt") or text.lstrip("\ufeff").startswith("WEBVTT"):
+        text = vtt_to_text(text)
     sections = markdown_to_sections(text)
     first_heading = re.search(r"^#\s+(.+)$", text, re.M)
     title = first_heading.group(1).strip() if first_heading else stem

backend/app/pipeline/material.py

@@ -0,0 +1,113 @@
+"""What a generated quiz, flashcard set or report reads: a notebook's posts (with numbered lines to cite) or the
+transcripts of notebook chats. One loader for all of them, so every artifact picks its source the same way."""
+
+import re
+import uuid
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.corpus import Corpus
+from app.models import Chat, Document, Job, Message, Notebook
+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
+
+MAX_POSTS = 20  # posts one artifact reads; the passage budget is shared between them
+CHAT_BUDGET = 60_000  # characters of chat transcripts
+
+
+@dataclass
+class Material:
+    title: str  # the notebook, the post, or the first chat's title
+    text: list[str]  # passages (posts) or transcripts (chats), ready for a prompt
+    source: dict  # {"kind": "posts"|"chats"|"mixed", "document_ids"?, "chat_ids"?, "count": n}
+    docs: list[Document] = field(default_factory=list)  # empty for chats only
+    # 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)
+
+    @property
+    def is_chat(self) -> bool:
+        """Chats only: there are no posts to draw a mind map from or to cite lines of."""
+        return not self.docs
+
+
+def chat_material(db: Session, chats: list[Chat]) -> list[str]:
+    """One transcript per chat, citation markers removed. A chat over its share loses its oldest turns first."""
+    share = CHAT_BUDGET // max(len(chats), 1)
+    out = []
+    for chat in chats:
+        msgs = db.scalars(select(Message).where(Message.chat_id == chat.id).order_by(Message.created_at)).all()
+        turns = [f"{'User' if m.role == 'user' else 'Assistant'}: {t}" for m in msgs
+                 if (t := re.sub(r"\s*\[\d+\]", "", m.content).strip())]
+        size = sum(len(t) + 2 for t in turns)
+        while len(turns) > 1 and size > share:
+            size -= len(turns.pop(0)) + 2
+        if any(m.role == "assistant" for m in msgs):
+            out.append(f"CHAT {chat.title or 'Untitled chat'}\n" + "\n\n".join(turns))
+    return out
+
+
+def load_material(db: Session, workspace_id: uuid.UUID, notebook_id: uuid.UUID | None, params: dict, *,
+                  job: Job | None = None, what: str = "quiz") -> 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."""
+    chat_ids = [uuid.UUID(str(i)) for i in params.get("chat_ids") or []]
+    picked = [uuid.UUID(str(i)) for i in params.get("document_ids") or []]
+    nb = db.get(Notebook, notebook_id) if notebook_id else None
+
+    docs: list[Document] = []
+    if picked:
+        docs = workspace_docs(db, workspace_id, picked)
+    elif not chat_ids and nb:
+        docs = notebook_docs(db, nb.id)
+    docs = docs[:MAX_POSTS]
+
+    chats: list[Chat] = []
+    chat_text: list[str] = []
+    if chat_ids:
+        chats = list(db.scalars(select(Chat).where(Chat.id.in_(chat_ids), Chat.workspace_id == workspace_id)
+                                .order_by(Chat.created_at)))
+        chat_text = chat_material(db, chats)
+        if not chat_text and not docs:
+            raise NothingToDo(f"These chats have no answers to make a {what} from yet.")
+    if not docs and not chat_text:
+        raise NothingToDo(f"Pick at least one post or chat for the {what}.")
+
+    text: list[str] = []
+    refs: Callable[[list | None], list[dict]] = lambda _items: []  # noqa: E731  (chats have no lines to point at)
+    tools: ScopedTools | None = None
+    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)
+        tools = tools_for(corpus, docs)
+        by_path = {d.path: d for d in docs}
+
+        def refs(items) -> list[dict]:  # noqa: F811
+            return [{"document_id": str(by_path[r["path"]].id), "path": r["path"], "title": r["title"],
+                     "line_start": r["line_start"], "line_end": r["line_end"], "quote": r["quote"]}
+                    for r in verify_refs(tools, items or []) if r["path"] in by_path]
+
+    if docs and nb and not picked:
+        title = nb.title
+    elif docs:
+        title = docs[0].title + (f" + {len(docs) - 1} more" if len(docs) > 1 else "")
+    else:
+        first = chats[0].title or "Chat"
+        title = first if len(chats) == 1 else f"{first} + {len(chats) - 1} more"
+    if docs and chat_text:
+        title += f" + {len(chats)} chat{'s' if len(chats) != 1 else ''}"
+
+    source: dict = {"kind": "mixed" if docs and chat_text else "posts" if docs else "chats"}
+    if docs:
+        source["document_ids"] = [str(d.id) for d in docs]
+    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)

backend/app/pipeline/quiz.py

@@ -0,0 +1,82 @@
+"""Quizzes: questions written from a notebook's posts or from notebook chats, graded in the browser."""
+
+import uuid
+
+from sqlalchemy.orm import Session
+
+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.generate import NothingToDo
+from app.pipeline.material import Material, load_material
+from app.services.jobs import update_job
+
+SAME_LANGUAGE = "the same language as the sources"  # no language picked: write as the material is written
+QUESTION_COUNTS = {"fewer": 5, "standard": 10, "more": 15}
+DIFFICULTIES = ("easy", "medium", "hard")
+QUESTION_TYPES = ("multiple_choice", "multiple_select", "fill_blank", "short_answer")
+
+
+def _clean(q: dict, refs) -> dict | None:
+    """One generated question in the shape the page plays, or None when it cannot be played."""
+    kind, text = q.get("type"), (q.get("question") or "").strip()
+    if kind not in QUESTION_TYPES or not text:
+        return None
+    base = {"type": kind, "question": text, "explanation": (q.get("explanation") or "").strip(),
+            "sources": refs(q.get("sources"))}
+    if kind in ("multiple_choice", "multiple_select"):
+        options = [str(o).strip() for o in q.get("options") or [] if str(o).strip()]
+        correct = sorted({i for i in q.get("correct") or [] if isinstance(i, int) and 0 <= i < len(options)})
+        if len(options) < 2 or not correct:
+            return None
+        if kind == "multiple_choice":
+            correct = correct[:1]
+        elif len(correct) < 2:
+            kind = base["type"] = "multiple_choice"
+        return {**base, "options": options, "correct": correct}
+    answer = (q.get("answer") or "").strip()
+    if not answer:
+        return None
+    if kind == "fill_blank":
+        accepted = [a.strip() for a in q.get("accepted") or [] if a and a.strip()]
+        if "____" not in text:
+            base["question"] = f"{text} ____"
+        return {**base, "answer": answer, "accepted": accepted}
+    return {**base, "answer": answer}
+
+
+def make_questions(db: Session, workspace_id: uuid.UUID, material: Material, *, topic: str = "",
+                   difficulty: str = "medium", types: list[str] | None = None, count: int = 10,
+                   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())
+    return [c for c in cleaned if c["type"] in allowed][:count]
+
+
+def build_quiz(db: Session, job: Job, artifact: Artifact) -> dict:
+    params = job.params
+    types = [t for t in params.get("question_types") or [] if t in QUESTION_TYPES] or list(QUESTION_TYPES[:2])
+    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")
+    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)
+    if not questions:
+        raise NothingToDo("The material did not give enough to ask about. Try other posts or another topic.")
+    artifact.content_json = {
+        "title": f"Quiz: {(topic[:60] or material.title)}", "topic": topic, "difficulty": difficulty,
+        "language": params.get("language") or SAME_LANGUAGE, "question_types": types, "source": material.source,
+        "questions": questions, "question_count": len(questions),
+    }
+    artifact.status = "ready"
+    db.commit()
+    return {"artifact_id": str(artifact.id)}

backend/app/pipeline/report.py

@@ -0,0 +1,395 @@
+"""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`."""
+
+import logging
+import re
+import uuid
+
+from sqlalchemy.orm import Session
+
+from app.llm import run
+from app.llm.provider import fast_lm, report_lm
+from app.llm.signatures import (
+    PlanInteractiveReport,
+    SuggestEmbeds,
+    WriteReport,
+    WriteReportSection,
+)
+from app.models import Artifact, Job
+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.quiz import make_questions
+from app.pipeline.passages import as_citations
+from app.pipeline.research import verify_citations
+from app.infographics.themes import theme_id
+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
+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__)
+
+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:
+    """The visual a section heading really is ("Quick quiz" is a quiz), or None for an ordinary section."""
+    if QUIZ_HEADING.search(heading):
+        return "quiz"
+    if FLASHCARD_HEADING.search(heading):
+        return "flashcards"
+    return None
+
+
+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(), []
+    for g in groups:
+        for s in g:
+            key = (s["after_block_id"], s["kind"])
+            if key not in seen:
+                seen.add(key)
+                out.append({**s, "id": f"s{len(out) + 1}"})
+    return out[:MAX_PLANNED_VISUALS + 2]
+
+
+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())
+    blocks = []
+    for part in parts:
+        if part.strip():
+            blocks.append({"type": "prose", "text": part.strip()})
+    return blocks
+
+
+def number_blocks(blocks: list[dict]) -> list[dict]:
+    for i, b in enumerate(blocks, start=1):
+        b["id"] = f"b{i}"
+    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]:
+    """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 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."""
+    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
+
+
+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
+    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]
+    update_job(db, job, progress=0.25, message="Planning the report")
+    try:
+        plan = run.predict(PlanInteractiveReport, db=db, workspace_id=workspace_id, job=job, lm=report_lm(),
+                           title=material.title, material=material.text, request=instructions,
+                           allowed_kinds=kinds, language=language)
+    except Exception:
+        log.warning("report plan failed", exc_info=True)
+        return None
+    sections = [x for x in plan.get("sections") or [] if (x.get("heading") or "").strip()][:MAX_SECTIONS]
+    if len(sections) < 2:
+        return None
+    report_title = (plan.get("report_title") or material.title).strip()
+
+    # A planned section that is really a quiz or flashcards is not written as text: it becomes a suggestion.
+    kept_secs: list[dict] = []
+    moved: list[tuple[int, str, dict]] = []
+    for x in sections:
+        kind = visual_kind(x["heading"])
+        if kind and kind in kinds and kept_secs:
+            moved.append((len(kept_secs) - 1, kind, x))
+        else:
+            kept_secs.append(x)
+    sections = kept_secs
+
+    update_job(db, job, progress=0.4, message=f"Writing {len(sections)} sections")
+    written = run.predict_many(
+        WriteReportSection,
+        [{"title": material.title, "report_title": report_title, "heading": x["heading"].strip(),
+          "brief": (x.get("brief") or "").strip(), "request": instructions, "material": material.text,
+          "language": language} for x in sections],
+        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()
+        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)
+        anchor[n] = blocks[-1]["id"]
+        embed = sec.get("embed")
+        if embed and len(suggestions) < MAX_PLANNED_VISUALS and embed.get("kind") in 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]})
+    if not any(b["type"] == "prose" for b in blocks):
+        return None
+    for idx, kind, sec in moved:
+        after = anchor.get(idx) or blocks[0]["id"]
+        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)
+
+
+def build_report(db: Session, job: Job, artifact: Artifact) -> dict:
+    params = job.params
+    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")
+    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
+    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))
+    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),
+    }
+    artifact.status = "ready"
+    db.commit()
+    return {"artifact_id": str(artifact.id)}
+
+
+# Adding a visual to a finished report
+
+
+def _source_params(source: dict) -> dict:
+    """The job params that load a report's own source again."""
+    return {"chat_ids": source.get("chat_ids") or [], "document_ids": source.get("document_ids") or []}
+
+
+def copy_block(kind: str, existing: Artifact) -> dict:
+    """A visual's content taken from an artifact the user already made (a Mind Constellation, a quiz or flashcards)."""
+    c = existing.content_json or {}
+    if kind == "mind_map" and c.get("root"):
+        return {"title": c.get("title"), "root": c["root"], "node_count": c.get("node_count"),
+                "post_count": c.get("post_count")}
+    if kind == "quiz" and c.get("questions"):
+        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
+        return {"title": c.get("title"), "artifact_id": str(existing.id), "theme": c.get("theme")}
+    raise NothingToDo("That one has nothing to add.")
+
+
+def make_block(db: Session, job: Job, report: Artifact, kind: str, brief: str, theme: str | None = None) -> dict:
+    """A new visual about `brief`, built from the report's own sources."""
+    source = (report.content_json or {})["source"]
+    if kind == "infographic":
+        # A picture is drawn by the renderer, so it is its own infographic (listed in the Library, counted in the
+        # plan) that the block points at; the report page shows it once it is ready.
+        child, _ = start_artifact(db, report.workspace_id, "infographic", title=f"Infographic: {brief[:60] or report.content_json.get('title', '')}",
+                                  notebook_id=report.notebook_id,
+                                  params={**_source_params(source), "theme": theme_id(theme), "instructions": brief[:600]})
+        return {"title": f"Infographic: {brief[:60]}", "artifact_id": str(child.id), "theme": theme_id(theme)}
+    material = load_material(db, report.workspace_id, report.notebook_id, _source_params(source), job=job, what="report")
+    language = (report.content_json or {}).get("language") or SAME_LANGUAGE
+    update_job(db, job, progress=0.4, message="Building it")
+    if kind == "mind_map":
+        if material.is_chat:
+            raise NothingToDo("A Mind Constellation needs posts, not chats.")
+        c = mind_map_content(db, job, report.workspace_id, material.title, material.docs, brief)
+        return {"title": c["title"], "root": c["root"], "node_count": c["node_count"], "post_count": c["post_count"]}
+    if kind == "flashcards":
+        cards = make_cards(db, report.workspace_id, material, topic=brief, count=BLOCK_CARDS, language=language, job=job)
+        if not cards:
+            raise NothingToDo("The sources did not give enough to make cards from.")
+        return {"title": f"Flashcards: {brief[:60]}", "cards": cards}
+    questions = make_questions(db, report.workspace_id, material, topic=brief, difficulty="medium",
+                               types=["multiple_choice", "multiple_select", "fill_blank"], count=BLOCK_QUESTIONS,
+                               language=language, job=job)
+    if not questions:
+        raise NothingToDo("The sources did not give enough to ask about.")
+    return {"title": f"Test yourself: {brief[:60]}", "questions": questions}
+
+
+def insert_block(content: dict, block: dict, after: str | None, suggestion_id: str | None) -> dict:
+    """The report's content with the block placed after `after` (or last), the suggestion it answers removed, and
+    nothing else changed. Block ids stay unique."""
+    blocks = list(content.get("blocks") or [])
+    used = {b["id"] for b in blocks}
+    n = len(blocks) + 1
+    while f"b{n}" in used:
+        n += 1
+    block = {**block, "id": f"b{n}", "after": after}
+    at = next((i + 1 for i, b in enumerate(blocks) if b["id"] == after), len(blocks))
+    # Keep the block with the visuals already hanging off the same section, in the order they were added.
+    while at < len(blocks) and blocks[at]["type"] != "prose" and blocks[at].get("after") == after:
+        at += 1
+    blocks.insert(at, block)
+    suggestions = [s for s in content.get("suggestions") or [] if s["id"] != suggestion_id]
+    return {**content, "blocks": blocks, "suggestions": suggestions}
+
+
+def handle_report_block(db: Session, job: Job) -> dict:
+    """Worker job: add one visual (new, or copied from an existing artifact) to a report."""
+    report = db.get(Artifact, uuid.UUID(job.params["artifact_id"]))
+    if not report or report.type != "report":
+        return {}
+    p = job.params
+    kind = p.get("kind")
+    if kind not in EMBED_KINDS:
+        raise PermanentJobError("Unknown kind of visual.")
+    try:
+        if p.get("existing_artifact_id"):
+            existing = db.get(Artifact, uuid.UUID(p["existing_artifact_id"]))
+            if not existing or existing.workspace_id != report.workspace_id or existing.type != kind \
+                    or existing.status != "ready":
+                raise NothingToDo("That one is not available.")
+            block = copy_block(kind, existing)
+        else:
+            block = make_block(db, job, report, kind, (p.get("brief") or "").strip(), p.get("theme"))
+    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"),
+                                       p.get("suggestion_id"))
+    db.commit()
+    return {"artifact_id": str(report.id)}
+
+
+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."""
+    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}

backend/app/routers/artifacts.py

@@ -1,24 +1,30 @@
+import re
 import uuid
 from typing import Literal
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Response
 from pydantic import BaseModel, Field
 from sqlalchemy import func, or_, select
 
 from app.auth import Ctx, get_ctx
 from app.config import settings
-from app.models import Artifact, CalendarItem, Document, Job, Notebook, UserSavedVoice
+from app.models import Artifact, CalendarItem, Chat, Document, Job, Notebook, UserSavedVoice
 from app.routers.notebooks import ensure_archive_notebook
+from app.infographics.image import ImageUnavailable, render_png
 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
+from app.infographics.themes import theme_id
 from app.services.renderer import COMPOSITIONS
 from app.services.storage import storage
 from app.services.usage import check_limit
 
 router = APIRouter(prefix="/api/artifacts", tags=["artifacts"])
 
-ArtifactType = Literal["summary", "audio_overview", "video", "quote_card", "carousel", "launch_kit", "mind_map"]
+ArtifactType = Literal["summary", "audio_overview", "video", "quote_card", "carousel", "launch_kit", "mind_map", "quiz", "flashcards", "report", "infographic"]
+
+
+SOURCE_TYPES = ("quiz", "flashcards", "report", "infographic")  # made from posts or chats picked in the dialog
 
 
 class RenderIn(BaseModel):
@@ -27,7 +33,7 @@ class RenderIn(BaseModel):
 
 
 class GenerateIn(BaseModel):
-    type: Literal["summary", "audio_overview", "video", "quote_card", "carousel", "launch_kit", "mind_map"]
+    type: Literal["summary", "audio_overview", "video", "quote_card", "carousel", "launch_kit", "mind_map", "quiz", "flashcards", "report", "infographic"]
     notebook_id: uuid.UUID | None = None
     document_id: uuid.UUID | None = None
     archive: bool = False  # no notebook or post picked: use the "All posts" notebook
@@ -46,6 +52,20 @@ class GenerateIn(BaseModel):
     # mind_map: the posts to chart (none picked means every post in the notebook) and what to centre on
     document_ids: list[uuid.UUID] | None = None
     focus: str | None = Field(None, max_length=500)
+    topic: str | None = Field(None, max_length=500)  # quiz: what to ask about (none: the material as a whole)
+    # quiz: from a notebook's posts (notebook_id and document_ids) or from notebook chats (chat_ids)
+    chat_ids: list[uuid.UUID] | None = Field(None, min_length=1, max_length=5)
+    count: Literal["fewer", "standard", "more"] = "standard"
+    difficulty: Literal["easy", "medium", "hard"] = "medium"
+    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: one of app.infographics.themes
+    # report: a written "document" or an "interactive" one, the template it started from, and the instructions the
+    # writer is given (the dialog's editable text; empty means the template's own)
+    report_format: Literal["document", "interactive"] = "document"
+    template_id: str | None = Field(None, max_length=40)
+    instructions: str | None = Field(None, max_length=4000)
 
 
 def _hosts(ctx: Ctx, body: GenerateIn) -> dict:
@@ -115,7 +135,21 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         if not body.slides:
             raise HTTPException(400, "A carousel needs slides")
         content = {"slides": body.slides[:12], "parent_id": str(body.parent_id) if body.parent_id else None}
-    target = _target_title(ctx, body.notebook_id, body.document_id)
+    if body.type in SOURCE_TYPES and body.chat_ids:
+        chats = list(ctx.db.scalars(select(Chat).where(Chat.id.in_(set(body.chat_ids)),
+                                                       Chat.workspace_id == ctx.workspace.id)
+                                    .order_by(Chat.created_at)))
+        if len(chats) != len(set(body.chat_ids)):
+            raise HTTPException(404, "Chat not found")
+        if not body.notebook_id and not body.document_id:
+            body.notebook_id = chats[0].notebook_id  # listed with its chats' notebook
+        target = chats[0].title or "Chat"
+    else:
+        if body.type in SOURCE_TYPES and not (body.notebook_id or body.document_id):
+            raise HTTPException(400, "Pick posts or chats to make this from")
+        if body.type in SOURCE_TYPES and body.notebook_id and not body.document_id and body.document_ids == []:
+            raise HTTPException(400, "Pick at least one post or chat to make this from")
+        target = _target_title(ctx, body.notebook_id, body.document_id)
     if body.type == "audio_overview":
         check_limit(ctx.db, ctx.workspace, "audio_minutes", body.minutes)
         params = {"format": body.format, "minutes": body.minutes, **_hosts(ctx, body)}
@@ -125,6 +159,33 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
             raise HTTPException(400, "A Mind Constellation is made from a notebook")
         params = {"document_ids": [str(i) for i in body.document_ids or []], "focus": (body.focus or "").strip()}
         title = f"Mind Constellation: {params['focus'][:60] or target}"
+    elif body.type == "flashcards":
+        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 []],
+                  "topic": (body.topic or "").strip(), "count": body.count, "difficulty": body.difficulty,
+                  "language": body.language}
+        title = f"Flashcards: {params['topic'][:60] or target}"
+    elif body.type == "report":
+        check_limit(ctx.db, ctx.workspace, "reports", 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 []],
+                  "topic": (body.topic or "").strip(), "language": body.language,
+                  "report_format": body.report_format, "template_id": body.template_id,
+                  "instructions": (body.instructions or "").strip()}
+        title = f"Report: {params['topic'][:60] or target}"
+    elif body.type == "infographic":
+        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]}
+        title = f"Infographic: {params['instructions'][:60] or target}"
+    elif body.type == "quiz":
+        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 []], "topic": (body.topic or "").strip(),
+                  "count": body.count, "difficulty": body.difficulty,
+                  "question_types": list(dict.fromkeys(body.question_types)), "language": body.language}
+        title = f"Quiz: {params['topic'][:60] or target}"
     elif body.type == "launch_kit":
         if not body.document_id:
             raise HTTPException(400, "A Launch Kit is made from one post")
@@ -177,6 +238,22 @@ def get_artifact(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
     return serialize_artifact(a, latest_jobs(ctx.db, [a.id]).get(a.id))
 
 
+@router.get("/{artifact_id}/image")
+def infographic_image(artifact_id: uuid.UUID, layout: Literal["landscape", "portrait"] = "landscape", ctx: Ctx = Depends(get_ctx)):
+    """A finished infographic as a PNG, wide (the default) or tall, for its Download button."""
+    a = get_artifact_or_404(ctx, artifact_id)
+    shown = serialize_artifact(a) if a.type == "infographic" and a.status == "ready" else {}
+    html = (shown.get("content") or {}).get("html_landscape" if layout == "landscape" else "html")
+    if not html:
+        raise HTTPException(404, "This infographic has no image to download.")
+    try:
+        png = render_png(html, layout)
+    except ImageUnavailable as exc:
+        raise HTTPException(503, str(exc)) from exc
+    name = re.sub(r"[^\w\- ]+", "", shown.get("title") or "infographic").strip()[:80] or "infographic"
+    return Response(png, media_type="image/png", headers={"Content-Disposition": f'attachment; filename="{name} ({layout}).png"'})
+
+
 @router.patch("/{artifact_id}")
 def patch_artifact(artifact_id: uuid.UUID, body: PatchIn, ctx: Ctx = Depends(get_ctx)):
     a = get_artifact_or_404(ctx, artifact_id)
@@ -214,6 +291,8 @@ def retry_artifact(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
         raise HTTPException(400, "Nothing to retry")
     if last.status not in {"failed", "done"}:
         raise HTTPException(409, "Still running")
+    if last.kind == "report_block":
+        raise HTTPException(409, "Add it again from the report")
     a.status = "pending"
     content = dict(a.content_json or {})
     content.pop("error", None)

backend/app/routers/reports.py

@@ -0,0 +1,113 @@
+import uuid
+from typing import Literal
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+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.routers.artifacts import get_artifact_or_404
+from app.routers.videos import FocusIn, _focus_material
+from app.services.artifacts import latest_jobs, serialize_artifact
+from app.services.jobs import create_job
+from app.services.usage import check_limit
+from app.services.report_templates import INTERACTIVE, TEMPLATES
+
+router = APIRouter(prefix="/api/reports", tags=["reports"])
+
+SUGGEST_ITEMS = 5  # sources the AI reads to suggest templates
+
+
+@router.get("/templates")
+def templates(_ctx: Ctx = Depends(get_ctx)):
+    """The fixed templates (each with its instruction text, {about} to be filled in) and the interactive one."""
+    return {"templates": TEMPLATES, "interactive": INTERACTIVE}
+
+
+class SuggestIn(FocusIn):
+    topic: str | None = Field(None, max_length=500)
+
+
+@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)
+    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]}
+
+
+class AddBlockIn(BaseModel):
+    kind: Literal["mind_map", "flashcards", "quiz", "infographic"]
+    theme: str | None = Field(None, max_length=30)  # infographic: the premade theme
+    after_block_id: str | None = Field(None, max_length=20)
+    suggestion_id: str | None = Field(None, max_length=20)
+    brief: str = Field("", max_length=500)
+    existing_artifact_id: uuid.UUID | None = None  # copy this Mind Constellation, quiz or flashcard set instead
+
+
+def _report_or_404(ctx: Ctx, artifact_id: uuid.UUID) -> Artifact:
+    a = get_artifact_or_404(ctx, artifact_id)
+    if a.type != "report" or a.status != "ready":
+        raise HTTPException(404, "Report not found")
+    return a
+
+
+@router.post("/{artifact_id}/blocks")
+def add_block(artifact_id: uuid.UUID, body: AddBlockIn, ctx: Ctx = Depends(get_ctx)):
+    """Add a visual after a section: made new from the report's sources, or copied from one you already made. Runs as a
+    job; the report page shows its progress and reloads when it is done."""
+    a = _report_or_404(ctx, artifact_id)
+    content = a.content_json or {}
+    if body.kind not in EMBED_KINDS:
+        raise HTTPException(400, "Unknown kind of visual")
+    if body.kind == "mind_map" and not content.get("source", {}).get("document_ids"):
+        raise HTTPException(400, "A Mind Constellation is made from posts, not chats")
+    if body.after_block_id and body.after_block_id not in {b["id"] for b in content.get("blocks") or []}:
+        raise HTTPException(404, "Section not found")
+    last = latest_jobs(ctx.db, [a.id]).get(a.id)
+    if last and last.status in {"queued", "running"}:
+        raise HTTPException(409, "Something is already being added to this report")
+    if body.existing_artifact_id:
+        existing = ctx.db.scalar(select(Artifact).where(Artifact.id == body.existing_artifact_id,
+                                                        Artifact.workspace_id == ctx.workspace.id,
+                                                        Artifact.type == body.kind, Artifact.status == "ready"))
+        if not existing:
+            raise HTTPException(404, "That one was not found")
+    if body.kind == "infographic" and not body.existing_artifact_id:
+        check_limit(ctx.db, ctx.workspace, "infographics", 1)
+    params = {"artifact_id": str(a.id), "kind": body.kind, "theme": body.theme, "after_block_id": body.after_block_id,
+              "suggestion_id": body.suggestion_id, "brief": body.brief.strip(),
+              "existing_artifact_id": str(body.existing_artifact_id) if body.existing_artifact_id else None}
+    job = create_job(ctx.db, ctx.workspace.id, "report_block", params, artifact_id=a.id, max_attempts=1)
+    return serialize_artifact(a, job)
+
+
+@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)
+    content = remove_block(a.content_json or {}, block_id)
+    if content is None:
+        raise HTTPException(404, "Visual not found")
+    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

@@ -21,6 +21,7 @@ class SettingsIn(BaseModel):
     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
 
 
@@ -30,7 +31,8 @@ def _serialize(ctx: Ctx) -> dict:
         "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},
+                      "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)),
@@ -56,6 +58,8 @@ def update_settings(body: SettingsIn, ctx: Ctx = Depends(get_ctx)):
         ctx.workspace.name = body.workspace_name.strip()
     if body.training_opt_in is not None:
         ctx.workspace.training_opt_in = body.training_opt_in
+    if body.allow_public_links is not None:
+        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 {})

backend/app/routers/share.py

@@ -0,0 +1,107 @@
+import time
+import uuid
+from collections import defaultdict, deque
+
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
+from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.auth import Ctx, get_ctx
+from app.db import get_db
+from app.models import Artifact, ArtifactShare, Workspace
+from app.routers.artifacts import get_artifact_or_404
+from app.services.share import new_token, public_infographic, public_report, share_url
+
+router = APIRouter(tags=["share"])
+
+PUBLIC_PER_MINUTE = 60  # reads of shared pages from one address
+_hits: dict[str, deque] = defaultdict(deque)
+
+
+def _limit(request: Request) -> None:
+    ip = (request.headers.get("x-forwarded-for") or "").split(",")[0].strip() or (request.client.host if request.client else "?")
+    now, window = time.monotonic(), _hits[ip]
+    while window and now - window[0] > 60:
+        window.popleft()
+    if len(window) >= PUBLIC_PER_MINUTE:
+        raise HTTPException(429, "Too many requests. Try again in a minute.")
+    window.append(now)
+
+
+SHAREABLE = ("report", "infographic")
+
+
+def _report(ctx: Ctx, artifact_id: uuid.UUID) -> Artifact:
+    """A finished report or infographic of this workspace."""
+    a = get_artifact_or_404(ctx, artifact_id)
+    if a.type not in SHAREABLE or a.status != "ready":
+        raise HTTPException(404, "Not found")
+    return a
+
+
+def _share(ctx: Ctx, a: Artifact) -> ArtifactShare | None:
+    return ctx.db.scalar(select(ArtifactShare).where(ArtifactShare.artifact_id == a.id))
+
+
+def _out(share: ArtifactShare | None) -> dict:
+    return {"shared": bool(share), "url": share_url(share.token) if share else None,
+            "show_sources": share.show_sources if share else True}
+
+
+@router.get("/api/artifacts/{artifact_id}/share")
+def get_share(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
+    return _out(_share(ctx, _report(ctx, artifact_id)))
+
+
+@router.post("/api/artifacts/{artifact_id}/share")
+def create_share(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
+    """Turn the link on (the same link if it already is)."""
+    a = _report(ctx, artifact_id)
+    if not ctx.workspace.allow_public_links:
+        raise HTTPException(403, "Public links are turned off for this workspace. Turn them on in Settings, Privacy.")
+    share = _share(ctx, a)
+    if not share:
+        share = ArtifactShare(workspace_id=ctx.workspace.id, artifact_id=a.id, token=new_token(), show_sources=True)
+        ctx.db.add(share)
+        ctx.db.commit()
+    return _out(share)
+
+
+class ShareIn(BaseModel):
+    show_sources: bool
+
+
+@router.patch("/api/artifacts/{artifact_id}/share")
+def update_share(artifact_id: uuid.UUID, body: ShareIn, ctx: Ctx = Depends(get_ctx)):
+    share = _share(ctx, _report(ctx, artifact_id))
+    if not share:
+        raise HTTPException(404, "This is not shared")
+    share.show_sources = body.show_sources
+    ctx.db.commit()
+    return _out(share)
+
+
+@router.delete("/api/artifacts/{artifact_id}/share")
+def delete_share(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
+    """Turn the link off for good: the old address stops working, and sharing again makes a new one."""
+    share = _share(ctx, _report(ctx, artifact_id))
+    if share:
+        ctx.db.delete(share)
+        ctx.db.commit()
+    return _out(None)
+
+
+@router.get("/api/public/reports/{token}")
+def public(token: str, request: Request, response: Response, db: Session = Depends(get_db)):
+    """The shared view of a report or an infographic. No sign in. A wrong, revoked or switched-off link is a plain 404."""
+    _limit(request)
+    response.headers["X-Robots-Tag"] = "noindex, nofollow"
+    response.headers["Cache-Control"] = "no-store"
+    share = db.scalar(select(ArtifactShare).where(ArtifactShare.token == token[:64]))
+    artifact = db.get(Artifact, share.artifact_id) if share else None
+    workspace = db.get(Workspace, share.workspace_id) if share else None
+    if not share or not artifact or artifact.type not in SHAREABLE or artifact.status != "ready" \
+            or not workspace or not workspace.allow_public_links:
+        raise HTTPException(404, "This link does not work")
+    return public_infographic(artifact) if artifact.type == "infographic" else public_report(artifact, share)

backend/app/routers/sources.py

@@ -184,6 +184,7 @@ def list_documents(
     ctx: Ctx = Depends(get_ctx),
     q: str = "",
     source_id: uuid.UUID | None = None,
+    indexed_only: bool = False,
     limit: int = 500,
     offset: int = 0,
 ):
@@ -197,6 +198,8 @@ def list_documents(
         query = query.where(or_(Document.title.ilike(like), Document.clean_text.ilike(like)))
     if source_id:
         query = query.where(Document.source_id == source_id)
+    if indexed_only:
+        query = query.where(Document.path.is_not(None))
     total = ctx.db.scalar(select(func.count()).select_from(query.subquery()))
     rows = ctx.db.execute(
         query.order_by(Document.published_at.desc().nulls_last(), Document.created_at.desc())

backend/app/routers/storage.py

@@ -30,6 +30,7 @@ ALLOWED_TYPES = {
     "text/markdown",
     "text/plain",
     "text/html",
+    "text/vtt",
 }
 
 

backend/app/services/artifacts.py

@@ -4,7 +4,7 @@ means: artifact row + queued job, returned together so the UI can stream progres
 import uuid
 
 from sqlalchemy import select
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, object_session
 
 from app.models import Artifact, Job
 from app.services.jobs import create_job, serialize_job
@@ -18,6 +18,10 @@ TYPE_LABELS = {
     "carousel": "Carousel",
     "launch_kit": "Launch Kit",
     "mind_map": "Mind Constellation",
+    "quiz": "Quiz",
+    "flashcards": "Flashcards",
+    "report": "Report",
+    "infographic": "Infographic",
 }
 
 
@@ -50,8 +54,37 @@ def latest_jobs(db: Session, artifact_ids: list[uuid.UUID]) -> dict[uuid.UUID, J
     return {j.artifact_id: j for j in jobs}  # later rows win, so this is the newest job per artifact
 
 
+def report_blocks(a: Artifact) -> list[dict]:
+    """A report's blocks, each infographic block with its page: the child artifact's html and status (or "missing"
+    once it was deleted). Read when the report is read, so one still being written shows up when it is ready."""
+    from app.pipeline.infographic import infographic_html  # not at import: pipeline imports this module
+
+    blocks = list((a.content_json or {}).get("blocks") or [])
+    ids = [uuid.UUID(b["artifact_id"]) for b in blocks if b.get("type") == "infographic" and b.get("artifact_id")]
+    db = object_session(a)
+    kids = {k.id: k for k in db.scalars(select(Artifact).where(Artifact.id.in_(ids), Artifact.workspace_id == a.workspace_id))} \
+        if ids and db else {}
+    out = []
+    for b in blocks:
+        if b.get("type") != "infographic":
+            out.append(b)
+            continue
+        kid = kids.get(uuid.UUID(b["artifact_id"])) if b.get("artifact_id") else None
+        ready = bool(kid and kid.status == "ready" and (kid.content_json or {}).get("content"))
+        out.append({**b, "status": kid.status if kid else "missing",
+                    "html": infographic_html(kid.content_json) if ready else None,
+                    "html_landscape": infographic_html(kid.content_json, "landscape") if ready else None})
+    return out
+
+
 def serialize_artifact(a: Artifact, job: Job | None = None) -> dict:
     content = a.content_json or {}
+    if a.type == "infographic" and a.status == "ready":
+        from app.pipeline.infographic import infographic_html  # not at import: pipeline imports this module
+
+        content = {**content, "html": infographic_html(content), "html_landscape": infographic_html(content, "landscape")}
+    if a.type == "report" and any(b.get("type") == "infographic" for b in content.get("blocks") or []):
+        content = {**content, "blocks": report_blocks(a)}
     slides = content.get("slide_keys") or []
     return {
         "id": str(a.id),

backend/app/services/plans.py

@@ -41,6 +41,8 @@ class Plan:
     # 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
 
 
 # metric -> period it counts over (app/services/video_limits.py)
@@ -72,6 +74,8 @@ DEFAULT_PLANS: dict[str, Plan] = {
         audio_minutes=3,
         videos=1,
         launch_kits=2,
+        reports=2,
+        infographics=2,
         voice_cloning=False,
         brand_kit=False,
         features=(
@@ -80,6 +84,8 @@ DEFAULT_PLANS: dict[str, Plan] = {
             "3 min of audio overviews a month",
             "1 video to try it",
             "2 Launch Kits a month",
+            "2 reports a month",
+            "2 infographics a month",
         ),
         video_limits=FREE_VIDEO_LIMITS,
         videos_monthly=False,
@@ -94,6 +100,8 @@ DEFAULT_PLANS: dict[str, Plan] = {
         audio_minutes=60,
         videos=10,
         launch_kits=50,
+        reports=30,
+        infographics=30,
         voice_cloning=True,
         brand_kit=True,
         features=(
@@ -101,6 +109,8 @@ DEFAULT_PLANS: dict[str, Plan] = {
             "60 min of audio overviews a month",
             "10 videos a month",
             "50 Launch Kits a month",
+            "30 reports a month",
+            "30 infographics a month",
             "Voice cloning with consent",
             "Your brand colors and logo",
         ),
@@ -117,6 +127,8 @@ DEFAULT_PLANS: dict[str, Plan] = {
         audio_minutes=240,
         videos=20,
         launch_kits=-1,
+        reports=-1,
+        infographics=-1,
         voice_cloning=True,
         brand_kit=True,
         features=(
@@ -124,6 +136,8 @@ DEFAULT_PLANS: dict[str, Plan] = {
             "240 min of audio overviews a month",
             "20 videos a month",
             "Unlimited Launch Kits",
+            "Unlimited reports",
+            "Unlimited infographics",
             "Launchpad calendar and resurfacing",
             "Priority rendering",
         ),
@@ -140,7 +154,8 @@ 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, voice_cloning=bool(row.voice_cloning),
+                videos=row.videos, launch_kits=row.launch_kits, reports=row.reports, infographics=row.infographics,
+                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),
                 video_limits={**{k: 0 for k in VIDEO_LIMITS}, **(row.video_limits or {})})

backend/app/services/report_templates.py

@@ -0,0 +1,74 @@
+"""The report templates offered in the Create report dialog. Each one is the instruction text the writer is given; the
+dialog fills {about} in with the report's topic (or the chosen sources) and lets the user edit the whole text before it
+is sent. Kept on the server so the dialog and the generator share one source of truth."""
+
+INTERACTIVE_ID = "interactive"
+CUSTOM_ID = "custom"
+
+TEMPLATES: list[dict] = [
+    {
+        "id": CUSTOM_ID,
+        "name": "Create Your Own",
+        "description": "Craft reports your way by specifying structure, style, tone, and more",
+        "prompt": "",
+    },
+    {
+        "id": "briefing",
+        "name": "Briefing Doc",
+        "description": "Overview of your sources featuring key insights and quotes",
+        "prompt": ("You are a highly capable research assistant. Write a briefing document on {about}. Open with a "
+                   "short Introduction, then give the key insights under clear, descriptive headings, and include the best "
+                   "short quotes from the sources that support them. End with a Summary of the main takeaways."),
+    },
+    {
+        "id": "study_guide",
+        "name": "Study Guide",
+        "description": "Short-answer quiz, suggested essay questions, and glossary of key terms",
+        "prompt": ("You are a highly capable research assistant and tutor. Create a detailed study guide on {about} "
+                   "designed to review understanding of the sources. Create a quiz with ten short-answer questions "
+                   "(2-3 sentences each) and include a separate answer key. Suggest five essay format questions, "
+                   "but do not supply answers. Also conclude with a comprehensive glossary of key terms with "
+                   "definitions. Start with an Introduction that says what the reader will be able to do by the end, and give "
+                   "every section a relevant, specific heading."),
+    },
+    {
+        "id": "blog_post",
+        "name": "Blog Post",
+        "description": "Insightful takeaways distilled into a highly readable article",
+        "prompt": ("Write an engaging blog post on {about}. Distill the most insightful takeaways from the sources "
+                   "into a highly readable article with a strong opening, short sections with clear subheadings, "
+                   "concrete examples from the sources, and a closing thought. Give every section a relevant, specific heading. Keep "
+                   "the tone warm and conversational."),
+    },
+]
+
+INTERACTIVE = {
+    "id": INTERACTIVE_ID,
+    "name": "Interactive report",
+    "description": "An interactive report with embedded studio content",
+    "prompt": ("Create an interactive report on {about}. Explain it clearly in well organised sections, starting "
+               "with an Introduction and ending with a Summary, and give every section a relevant, specific heading. "
+               "Suggest where a visual would help the reader, such as a mind map of how the ideas connect, flashcards "
+               "for the key terms, a short quiz, a comparison table or a timeline."),
+}
+
+DEFAULT_ABOUT = "the selected sources"
+
+
+def get_template(template_id: str | None) -> dict | None:
+    if template_id == INTERACTIVE_ID:
+        return INTERACTIVE
+    return next((t for t in TEMPLATES if t["id"] == template_id), None)
+
+
+def fill_prompt(template: dict, about: str | None = None) -> str:
+    """The template's instruction text for a report about `about` (the topic, or the sources when there is none)."""
+    return template["prompt"].replace("{about}", (about or "").strip() or DEFAULT_ABOUT)
+
+
+def default_instructions(report_format: str, template_id: str | None, about: str | None = None) -> str:
+    """What the writer is told when the dialog sent no instructions of its own."""
+    template = get_template(INTERACTIVE_ID if report_format == "interactive" else template_id)
+    if template and template["prompt"]:
+        return fill_prompt(template, about)
+    return f"Write a clear, well organised report on {(about or '').strip() or DEFAULT_ABOUT}."

backend/app/services/share.py

@@ -0,0 +1,97 @@
+"""What a shared report shows to someone with the link.
+
+The public view is built from a whitelist, field by field, never by filtering the stored content: a field added to a
+block later stays private until it is added here on purpose. It carries no post text, no quoted lines, no ids, no
+paths, no instructions, no suggestions, and no name of the author or workspace."""
+
+import re
+import secrets
+
+from app.config import settings
+from app.models import Artifact, ArtifactShare
+from app.pipeline.infographic import infographic_html
+from app.services.artifacts import report_blocks
+
+MARKER = re.compile(r"\s*\[\d+\](?:\[\d+\])*")  # [n] points into citations the public view does not carry
+MAX_TEXT = 20_000
+
+
+def new_token() -> str:
+    return secrets.token_urlsafe(16)
+
+
+def share_url(token: str) -> str:
+    return f"{settings.frontend_url.rstrip('/')}/r/{token}"
+
+
+def _s(value, limit: int = MAX_TEXT) -> str:
+    return str(value or "")[:limit]
+
+
+def _node(n: dict, depth: int = 0) -> dict:
+    """A mind map node as label, note and children only (no sources, no quotes)."""
+    kids = [] if depth > 6 else [_node(c, depth + 1) for c in (n.get("children") or []) if isinstance(c, dict)]
+    return {"id": _s(n.get("id"), 40), "label": _s(n.get("label"), 120), "note": _s(n.get("note"), 500),
+            "sources": [], "children": kids}
+
+
+def _block(b: dict) -> dict | None:
+    kind, base = b.get("type"), {"id": _s(b.get("id"), 20), "type": b.get("type"), "title": _s(b.get("title"), 200)}
+    if kind == "prose":
+        return {**base, "title": "", "text": MARKER.sub("", _s(b.get("text")))}
+    if kind == "callout":
+        return {**base, "text": MARKER.sub("", _s(b.get("text"), 2000))}
+    if kind == "key_terms":
+        return {**base, "terms": [{"term": _s(t.get("term"), 200), "definition": _s(t.get("definition"), 800)}
+                                  for t in b.get("terms") or [] if isinstance(t, dict)][:60]}
+    if kind == "table":
+        return {**base, "headers": [_s(h, 120) for h in b.get("headers") or []][:12],
+                "rows": [[_s(c, 400) for c in r][:12] for r in b.get("rows") or [] if isinstance(r, list)][:60]}
+    if kind == "timeline":
+        return {**base, "events": [{"when": _s(e.get("when"), 80), "title": _s(e.get("title"), 200),
+                                    "detail": _s(e.get("detail"), 800)}
+                                   for e in b.get("events") or [] if isinstance(e, dict)][:40]}
+    if kind == "mind_map" and isinstance(b.get("root"), dict):
+        return {**base, "root": _node(b["root"])}
+    if kind == "infographic":  # only a finished one, as the page our own template built (never the model's markup)
+        html, wide = b.get("html"), b.get("html_landscape")
+        return {**base, "html": html, "html_landscape": wide if isinstance(wide, str) else None} if isinstance(html, str) and html else None
+    if kind == "flashcards":
+        return {**base, "cards": [{"front": _s(c.get("front"), 300), "back": _s(c.get("back"), 800)}
+                                  for c in b.get("cards") or [] if isinstance(c, dict)][:60]}
+    if kind == "quiz":
+        return {**base, "questions": [{
+            "type": q.get("type"), "question": _s(q.get("question"), 600),
+            "options": [_s(o, 300) for o in q.get("options") or []][:8],
+            "correct": [i for i in q.get("correct") or [] if isinstance(i, int)][:8],
+            "answer": _s(q.get("answer"), 600), "accepted": [_s(a, 200) for a in q.get("accepted") or []][:8],
+            "explanation": _s(q.get("explanation"), 800)}
+            for q in b.get("questions") or [] if isinstance(q, dict)][:30]}
+    return None
+
+
+def public_report(artifact: Artifact, share: ArtifactShare) -> dict:
+    """The shared page's data for a report."""
+    c = artifact.content_json or {}
+    blocks = [x for b in report_blocks(artifact) if isinstance(b, dict) and (x := _block(b))]
+    out = {"kind": "report", "title": _s(c.get("title"), 300), "format": "interactive" if c.get("format") == "interactive" else "document",
+           "language": _s(c.get("language"), 40),
+           "created_at": artifact.created_at.isoformat() if artifact.created_at else None, "blocks": blocks,
+           "show_sources": bool(share.show_sources)}
+    if share.show_sources:
+        source = c.get("source") or {}
+        # Only a post's own public web address is shown; an upload or anything else is named by its title alone.
+        out["sources"] = {"chats": len(source.get("chat_ids") or []), "posts": [
+            {"title": _s(s.get("title"), 300),
+             "url": s["url"] if isinstance(s.get("url"), str) and re.match(r"https?://", s["url"]) else None}
+            for s in c.get("sources") or [] if isinstance(s, dict)][:60]}
+    return out
+
+
+def public_infographic(artifact: Artifact) -> dict:
+    """The shared page's data for an infographic: its title and the page our own template builds from the stored text
+    (every word escaped there). No source, no prompt, no ids."""
+    c = artifact.content_json or {}
+    return {"kind": "infographic", "title": _s(c.get("title"), 300), "html": infographic_html(c) or "",
+            "html_landscape": infographic_html(c, "landscape") or "",
+            "created_at": artifact.created_at.isoformat() if artifact.created_at else None}

backend/app/services/usage.py

@@ -31,9 +31,21 @@ def month_usage(db: Session, workspace_id) -> dict:
             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
     return {
         "audio_minutes": round(total("tts", "seconds") / 60, 1),
         "launch_kits": kits,
+        "reports": reports,
+        "infographics": infographics,
         "llm_tokens": int(total("llm", "tokens")),
         "since": since.isoformat(),
     }
@@ -49,7 +61,7 @@ def usage_report(db: Session, workspace: Workspace) -> dict:
         "used": used,
         "videos_resets_at": videos["resets_at"],
         "limits": {"audio_minutes": plan.audio_minutes, "videos": videos["limit"],
-                   "launch_kits": plan.launch_kits, "sources": plan.sources, "indexed_posts": plan.indexed_posts},
+                   "launch_kits": plan.launch_kits, "reports": plan.reports, "infographics": plan.infographics, "sources": plan.sources, "indexed_posts": plan.indexed_posts},
     }
 
 
@@ -57,7 +69,8 @@ def check_limit(db: Session, workspace: Workspace, kind: str, amount: float = 1)
     """Raise 402 plan_limit when this request would go over the monthly allowance."""
     plan = effective_plan(db, workspace)
     used = month_usage(db, workspace.id)
-    limit = {"audio_minutes": plan.audio_minutes, "launch_kits": plan.launch_kits}[kind]
+    limit = {"audio_minutes": plan.audio_minutes, "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.")

backend/app/support/corpus.py

@@ -74,12 +74,15 @@ def _plans_doc() -> Doc:
             monthly, yearly = annual_prices(p)
             price += f", or ${monthly:g} a month billed yearly (${yearly:g} a year)"
         kits = "unlimited" if p.launch_kits < 0 else str(p.launch_kits)
+        reports = "unlimited" if p.reports < 0 else str(p.reports)
+        infographics = "unlimited" if p.infographics < 0 else str(p.infographics)
         lines += [
             f"## {p.name}",
             f"{p.tagline}. Price: {price}.",
             f"Limits: {p.sources} sources, {p.indexed_posts} indexed posts, "
             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"{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'}.",
             "Includes: " + "; ".join(p.features) + ".",
         ]
@@ -94,7 +97,7 @@ def _plans_doc() -> Doc:
     return Doc(
         id="plans-and-billing", title="Plans, pricing and billing", route="/pricing",
         keywords=("price", "pricing", "plan", "plans", "free", "writer", "studio", "cost", "billing", "upgrade",
-                  "limits", "annual", "monthly", "subscription", "refund", "cancel", "usage"),
+                  "limits", "annual", "monthly", "subscription", "refund", "cancel", "usage", "reports", "infographics"),
         questions=("How much does Notestack cost?", "What is in the free plan?", "What are the plan limits?",
                    "How do I upgrade?", "Is there annual billing?"),
         related_paths=("/app/settings",), headings=tuple(re.findall(r"^#{1,3}\s+(.+)$", body, re.M)), body=body,

backend/app/support/prompts.py

@@ -27,8 +27,10 @@ steering back to Notestack. Do not answer the off topic question.
 COMPETITORS: represent Notestack only. Never recommend or name another product to use, even if a document \
 mentions one. If Notestack cannot do something, say so plainly and point to the closest thing it does.
 
-HOW TO: you only give written instructions. Say where to go using the real menu names: Notebooks, Sources and \
-Launchpad are in the left sidebar, Settings is at the bottom of the sidebar, Pricing is on the website menu. When \
+HOW TO: you only give written instructions. Say where to go using the real menu names: Notebooks, Sources, \
+Library and Launchpad are in the left sidebar, Settings is at the bottom of the sidebar, Pricing is on the website menu. \
+Inside a notebook the Create panel on the right makes audio, video, reports, summaries, infographics, quizzes, \
+flashcards and Mind Constellations. When \
 the answer has more than one step, use a numbered markdown list, one step per line ("1.", "2."), with **bold** \
 for button and menu names. One short intro sentence first. Never describe a button or page that the documents do \
 not mention.

backend/app/support/scope.py

@@ -22,13 +22,14 @@ def scrub_path(path: str | None) -> str | None:
 
 # "How do I ..." style questions are product help even when they mention "my notebook".
 _HOWTO = re.compile(
-    r"^\s*(?:hi|hello|hey|please|ok|okay)?[\s,!.]*(?:how\s+(?:do|can|could|should|to|does|would)\b|where\s+(?:do|can|is|are)\b|"
-    r"can\s+(?:i|you|notestack)\b|could\s+(?:i|you)\b|is\s+it\s+possible\b|which\s+plan\b|what\s+(?:does|is\s+a|is\s+the)\b)",
+    r"^\s*(?:hi|hello|hey|please|ok|okay)?[\s,!.]*(?:how\s+(?:do|can|could|should|to|does|would)\b|i(?:\s+(?:really|just))?\s+(?:want|need|wanna|would\s+like|'d\s+like)\s+to\b|make\s+me\b|where\s+(?:do|can|is|are)\b|"
+    r"can\s+(?:i|you|notestack)\b|could\s+(?:i|you)\b|is\s+it\s+possible\b|which\s+plan\b|what\s+(?:does|is\s+a|is\s+the)\b|"
+    r"(?:can|could|will|would|do|does|are|is)\s+(?:people|anyone|anybody|others|someone|they|readers?|visitors?)\b)",
     re.I,
 )
 _MINE = (
     r"(?:notebooks?|posts?|articles?|sources?|archive|documents?|newsletters?|blog|videos?|audio|podcasts?|"
-    r"launch\s*kits?|drafts?|files?|chats?|conversations?|topics?|quotes?|summar(?:y|ies)|writing|content|stuff|data)"
+    r"reports?|quiz(?:zes)?|flashcards?|infographics?|mind\s*(?:map|constellation)s?|launch\s*kits?|drafts?|files?|chats?|conversations?|topics?|quotes?|summar(?:y|ies)|writing|content|stuff|data)"
 )
 _ABOUT_MY_DATA = re.compile(
     rf"""(?ix)
@@ -46,7 +47,7 @@ _ABOUT_MY_DATA = re.compile(
     """
 )
 # Words that mean something went wrong with their work; the reply also offers the human form.
-_BROKEN = re.compile(r"(?i)\b(?:fail\w*|error|broken|stuck|crash\w*|not\s+working|won'?t|doesn'?t\s+work|missing|lost)\b")
+_BROKEN = re.compile(r"(?i)\b(?:fail\w*|slow|forever|too\s+long|taking\s+(?:so\s+|way\s+)?long|hang\w*|never\s+(?:finish|load|appear)\w*|error|broken|stuck|crash\w*|not\s+working|won'?t|doesn'?t\s+work|missing|lost)\b")
 
 OUT_OF_SCOPE_REPLY = (
     "I can help with how Notestack works, but I can't see your notebooks, posts, files or account, so I can't answer "

backend/app/worker.py

@@ -45,7 +45,7 @@ from app.models import (
     Workspace,
     WorkspaceMember,
 )
-from app.pipeline import generate, launchkit, media
+from app.pipeline import flashcards, generate, infographic, launchkit, media, quiz, report
 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
@@ -282,6 +282,11 @@ HANDLERS: dict[str, Callable[[Session, Job], object]] = {
     "resurface_scan": handle_resurface,
     "summary": _artifact_handler(generate.summarize_notebook, "Summary ready"),
     "mind_map": _artifact_handler(generate.build_mind_map, "Mind Constellation ready"),
+    "quiz": _artifact_handler(quiz.build_quiz, "Quiz ready"),
+    "flashcards": _artifact_handler(flashcards.build_flashcards, "Flashcards ready"),
+    "report": _artifact_handler(report.build_report, "Report ready"),
+    "infographic": _artifact_handler(infographic.build_infographic, "Infographic ready"),
+    "report_block": report.handle_report_block,
     "audio_overview": _artifact_handler(media.audio_overview, "Audio overview ready"),
     "video": _artifact_handler(media.make_video, "Audiogram ready"),  # audiograms; videos come from blog2video
     "quote_card": _artifact_handler(media.make_quote_card, "Quote card ready"),
@@ -292,7 +297,8 @@ HANDLERS: dict[str, Callable[[Session, Job], object]] = {
 
 
 def mark_artifact_failed(db: Session, job: Job, error: str) -> None:
-    if job.artifact_id:
+    # A failed "add a visual" job leaves the report as it was; the job's own error tells the page what went wrong.
+    if job.artifact_id and job.kind != "report_block":
         artifact = db.get(Artifact, job.artifact_id)
         if artifact:
             artifact.status = "failed"

backend/requirements.txt

@@ -20,6 +20,7 @@ feedparser==6.*
 beautifulsoup4==4.*
 pypdf==5.*
 stripe==13.*
+jinja2==3.*
 
 # Dev tools (tests, lint)
 pytest==8.*

backend/scripts/render_theme_thumbnails.py

@@ -0,0 +1,45 @@
+"""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.
+
+  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
+Set CHROME to the browser binary if it is not found."""
+
+import glob
+import os
+import subprocess
+import sys
+import tempfile
+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
+
+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:
+    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)
+
+
+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.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)
+        print(out)

backend/tests/conftest.py

@@ -11,8 +11,10 @@ os.environ["ELEVENLABS_API_KEY"] = ""
 os.environ["FIRECRAWL_API_KEY"] = ""
 os.environ["R2_PREFIX"] = ""
 os.environ["TYPESAFE_API_KEY"] = ""
-os.environ["STRIPE_SECRET_KEY"] = ""
-os.environ["STRIPE_WEBHOOK_SECRET"] = ""
+# Every name the settings accept for these, so a key exported in the shell under another name cannot get through.
+for _name in ("STRIPE_SECRET_KEY", "STRIPE_API_KEY", "STRIPE_SECRET", "STRIPE_WEBHOOK_SECRET",
+              "STRIPE_WEBHOOK_SIGNING_SECRET", "STRIPE_SIGNING_SECRET"):
+    os.environ[_name] = ""
 os.environ["STRIPE_PRICE_WRITER_MONTHLY"] = ""
 os.environ["STRIPE_PRICE_WRITER_ANNUAL"] = ""
 os.environ["STRIPE_PRICE_STUDIO_MONTHLY"] = ""
@@ -71,6 +73,18 @@ def run_jobs(session_factory, db_session):
     return drain
 
 
+@pytest.fixture(autouse=True)
+def never_reach_stripe(monkeypatch):
+    """No test can talk to the real Stripe account: building a real client fails loudly. A test that needs Stripe swaps in
+    a fake (`monkeypatch.setattr(stripe_billing, "client", lambda: fake)`), which never builds one."""
+    import stripe
+
+    def blocked(*_args, **_kwargs):
+        raise RuntimeError("A test tried to create a real Stripe client. Use a fake one (see tests/test_stripe_billing.py).")
+
+    monkeypatch.setattr(stripe, "StripeClient", blocked)
+
+
 @pytest.fixture()
 def client(db_session):
     app.dependency_overrides[get_db] = lambda: db_session