Merge pull request #2 from FireBird-Technologies/fix/b2v-integration

.env.example

@@ -1,131 +0,0 @@
-# ---- App
-ENV=development
-APP_NAME=Notestack
-FRONTEND_URL=http://localhost:5173
-API_URL=http://localhost:8000
-CORS_ORIGINS=http://localhost:5173
-INTERNAL_TOKEN=replace-with-random-token
-BILLING_ENABLED=false
-# Stripe. Checkout, the customer portal and webhooks. Prices are found or created by lookup key
-# (notestack_<plan>_<cycle>) from backend/app/services/plans.py; set STRIPE_PRICE_* to pin existing ones.
-# Webhook endpoint: {API_URL}/api/billing/webhook with events checkout.session.completed,
-# checkout.session.async_payment_succeeded, checkout.session.async_payment_failed,
-# customer.subscription.created, customer.subscription.updated, customer.subscription.deleted,
-# customer.subscription.paused, customer.subscription.resumed, invoice.paid, invoice.payment_failed,
-# invoice.payment_action_required, charge.dispute.created.
-STRIPE_SECRET_KEY=
-STRIPE_WEBHOOK_SECRET=
-STRIPE_PRICE_WRITER_MONTHLY=
-STRIPE_PRICE_WRITER_ANNUAL=
-STRIPE_PRICE_STUDIO_MONTHLY=
-STRIPE_PRICE_STUDIO_ANNUAL=
-
-# ---- Auth (JWT). Revocation bumps users.token_version, so tokens can be long lived.
-JWT_SECRET=replace-with-64-random-chars
-JWT_ALGORITHM=HS256
-JWT_EXPIRATION_HOURS=72
-JWT_REFRESH_EXPIRATION_DAYS=30
-
-# ---- Database (also backs the job queue)
-# Local: a SQLite file, created by `alembic upgrade head` run from backend/.
-# Prod (Neon, Supabase, RDS...): Postgres with the psycopg driver, e.g.
-#   DATABASE_URL=postgresql+psycopg://user:pass@host:5432/dbname?sslmode=require
-# docker-compose ignores this and points at its own Postgres container.
-DATABASE_URL=sqlite:///./notestack.db
-
-# ---- Google sign in (OAuth client, type Web; add http://localhost:5173 to authorized JS origins)
-# Client ID only: popup sign in (Google Identity Services), no redirect URIs needed.
-# Client ID + secret: redirect flow with server side code exchange. Add the redirect URI
-# (default {API_URL}/api/auth/google/callback, e.g. http://localhost:8000/api/auth/google/callback)
-# to "Authorized redirect URIs" on the OAuth client. Never prefix the secret with VITE_.
-GOOGLE_CLIENT_ID=
-GOOGLE_CLIENT_SECRET=
-GOOGLE_REDIRECT_URI=
-
-# ---- Email (Resend). EMAIL_PROVIDER=console prints emails to the API log instead.
-EMAIL_PROVIDER=console
-RESEND_API_KEY=
-FROM_EMAIL=Notestack <hello@notestack.ai>
-ALERTS_EMAIL=arslan@firebird-technologies.com
-UNSUBSCRIBE_SECRET=replace-me
-# Hour (UTC, 0 to 23) at which scheduled update email campaigns send their daily batch.
-UPDATE_EMAIL_SEND_HOUR=9
-
-# ---- Local dev conveniences
-# The API runs the job worker in process when ENV=development (set false to use python -m app.worker).
-RUN_WORKER_IN_API=
-# auto = local disk (LOCAL_STORAGE_DIR) when no R2 account or endpoint is set, else R2
-STORAGE_BACKEND=auto
-LOCAL_STORAGE_DIR=.storage
-
-# ---- Storage: Cloudflare R2
-# Prod: set account id + keys, leave R2_ENDPOINT_URL empty.
-# Local: docker-compose points R2_ENDPOINT_URL at MinIO (keys minioadmin/minioadmin).
-R2_ACCOUNT_ID=
-R2_ACCESS_KEY_ID=minioadmin
-R2_SECRET_ACCESS_KEY=minioadmin
-R2_BUCKET=notestack-assets
-R2_ENDPOINT_URL=
-R2_PUBLIC_BASE_URL=
-# Folder inside the bucket when it is shared with other apps, e.g. notestack. Empty = bucket root.
-R2_PREFIX=
-# How long presigned download links stay valid, in seconds.
-R2_PRESIGN_TTL_SECONDS=3600
-# Largest file a browser may upload (bytes). 209715200 = 200 MB.
-MAX_UPLOAD_BYTES=209715200
-
-# ---- LLM (any LiteLLM model string). Defaults target Z.ai GLM-5.3 via its OpenAI compatible API.
-# GLM-5.x always reasons; LLM_REASONING_EFFORT (low | high | max) trades cost for depth.
-# Cheaper: LLM_MODEL=openai/glm-5.3-flash. Free for local dev: openai/glm-4.7-flash
-LLM_MODEL=openai/glm-5.3
-LLM_FAST_MODEL=openai/glm-5.3-flash
-LLM_API_BASE=https://api.z.ai/api/paas/v4
-LLM_API_KEY=
-LLM_TEMPERATURE=1.0
-LLM_MAX_TOKENS=10000
-LLM_REASONING_EFFORT=low
-# Fallback chat triage model when Jev is not configured. Empty = LLM_FAST_MODEL.
-LLM_TRIAGE_MODEL=
-
-# ---- Chat triage: TypeSafe Jev (https://typesafe.ai)
-# A fast classifier (typed choices, no text generation) that decides what each chat message needs
-# before any research runs. With a key set, greetings, off topic and app questions never reach the
-# LLM, and archive questions get a quick or deep research budget. Empty = LLM triage above.
-TYPESAFE_API_KEY=
-TYPESAFE_MODEL=jev-latest
-TYPESAFE_URL=https://api.typesafe.ai
-
-# Firecrawl (firecrawl.dev): lets Connect read sites with no RSS feed, including JavaScript sites
-# (Next.js, Framer, Webflow), and makes single URL imports reliable. Empty = plain HTTP fetching only.
-FIRECRAWL_API_KEY=
-
-# ---- Research corpus (posts as markdown files; the agent greps and reads them, no vector index)
-CORPUS_CACHE_DIR=.corpus-cache
-RESEARCH_MAX_STEPS=10
-
-# ---- Worker (jobs queue lives in the database; no Redis)
-WORKER_CONCURRENCY=4
-WORKER_POLL_SECONDS=1
-JOB_STALE_SECONDS=900
-
-# ---- ElevenLabs (audio overviews, video narration, voice cloning)
-ELEVENLABS_API_KEY=
-ELEVENLABS_MODEL=eleven_multilingual_v2
-ELEVENLABS_VOICE_A=EXAVITQu4vr4xnSDxMaL
-ELEVENLABS_VOICE_B=JBFqnCBsd6RMkjVDRZzb
-
-# ---- Renderer (Remotion service for videos, quote cards and carousels: cd renderer && npm start)
-RENDERER_URL=http://localhost:3100
-
-# ---- Launchpad social publishing
-# Bluesky needs nothing here (users connect with an app password).
-# X: developer app with OAuth 2.0, type Web App, scopes tweet.read tweet.write users.read offline.access.
-#   Callback URI: {API_URL}/api/social/x/callback  e.g. http://localhost:8000/api/social/x/callback
-# LinkedIn: app with the "Sign In with LinkedIn using OpenID Connect" and "Share on LinkedIn" products.
-#   Redirect URL: {API_URL}/api/social/linkedin/callback
-X_CLIENT_ID=
-X_CLIENT_SECRET=
-LINKEDIN_CLIENT_ID=
-LINKEDIN_CLIENT_SECRET=
-# Fernet key for stored social tokens; derived from JWT_SECRET when empty.
-SOCIAL_TOKEN_KEY=

backend/alembic/versions/0005_video_quota.py

@@ -0,0 +1,48 @@
+"""subscriptions.video_plan / videos_used / video_limit / videos_period_start: the video allowance
+
+Revision ID: 0005_video_quota
+Revises: 0004_archive_notebook
+Create Date: 2026-09-29
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0005_video_quota"
+down_revision = "0004_archive_notebook"
+branch_labels = None
+depends_on = None
+
+COLUMNS = ("video_plan", "videos_used", "video_limit", "videos_period_start")
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the columns.
+    existing = {c["name"] for c in sa.inspect(op.get_bind()).get_columns("subscriptions")}
+    new = {
+        "video_plan": sa.Column("video_plan", sa.String(20), nullable=False, server_default="free"),
+        "videos_used": sa.Column("videos_used", sa.Integer(), nullable=False, server_default="0"),
+        "video_limit": sa.Column("video_limit", sa.Integer(), nullable=False, server_default="0"),
+        "videos_period_start": sa.Column("videos_period_start", sa.DateTime(timezone=True), nullable=True),
+    }
+    missing = [new[name] for name in COLUMNS if name not in existing]
+    if missing:
+        with op.batch_alter_table("subscriptions") as batch:
+            for column in missing:
+                batch.add_column(column)
+    # Same limits as app/services/plans.py; the app re-syncs on first use (billing disabled -> studio).
+    op.execute("""
+        UPDATE subscriptions SET
+          video_plan = CASE WHEN status IN ('active', 'trialing', 'past_due') AND plan IN ('writer', 'studio')
+                            THEN plan ELSE 'free' END
+    """)
+    op.execute("""
+        UPDATE subscriptions SET
+          video_limit = CASE video_plan WHEN 'studio' THEN 30 WHEN 'writer' THEN 10 ELSE 1 END,
+          videos_period_start = COALESCE(videos_period_start, CURRENT_TIMESTAMP)
+    """)
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("subscriptions") as batch:
+        for name in reversed(COLUMNS):
+            batch.drop_column(name)

backend/alembic/versions/0006_plans.py

@@ -0,0 +1,71 @@
+"""plans: one row per plan (limits, price, pricing-page copy), editable without a deploy
+
+Seeded with the plans that were hard-coded in app/services/plans.py. Rows that already exist are left alone.
+
+Revision ID: 0006_plans
+Revises: 0005_video_quota
+Create Date: 2026-09-29
+"""
+from datetime import UTC, datetime
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0006_plans"
+down_revision = "0005_video_quota"
+branch_labels = None
+depends_on = None
+
+SEED = [
+    {"id": "free", "sort_order": 0, "name": "Free", "tagline": "For trying Notestack on your archive",
+     "price_monthly_usd": 0, "sources": 1, "indexed_posts": 5, "audio_minutes": 3, "videos": 1, "launch_kits": 2,
+     "voice_cloning": False, "brand_kit": False,
+     "features": ["1 source, your latest 5 posts indexed", "Grounded research chat with citations",
+                  "3 min of audio overviews a month", "1 video a month", "2 Launch Kits a month"]},
+    {"id": "writer", "sort_order": 1, "name": "Writer", "tagline": "For writers publishing every week",
+     "price_monthly_usd": 24.99, "sources": 3, "indexed_posts": 500, "audio_minutes": 60, "videos": 10,
+     "launch_kits": 50, "voice_cloning": True, "brand_kit": True,
+     "features": ["3 sources, 500 indexed posts", "60 min of audio overviews a month", "10 videos a month",
+                  "50 Launch Kits a month", "Voice cloning with consent", "Your brand colors and logo"]},
+    {"id": "studio", "sort_order": 2, "name": "Studio", "tagline": "For publications and power users",
+     "price_monthly_usd": 48.99, "sources": 10, "indexed_posts": 5000, "audio_minutes": 240, "videos": 30,
+     "launch_kits": -1, "voice_cloning": True, "brand_kit": True,
+     "features": ["10 sources, 5,000 indexed posts", "240 min of audio overviews a month", "30 videos a month",
+                  "Unlimited Launch Kits", "Launchpad calendar and resurfacing", "Priority rendering"]},
+]
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    # 0001 builds from the live models, so a fresh database may already have the table (empty).
+    if "plans" not in sa.inspect(bind).get_table_names():
+        op.create_table(
+            "plans",
+            sa.Column("id", sa.String(20), primary_key=True),
+            sa.Column("sort_order", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("name", sa.String(50), nullable=False),
+            sa.Column("tagline", sa.String(200), nullable=False, server_default=""),
+            sa.Column("price_monthly_usd", sa.Float(), nullable=False, server_default="0"),
+            sa.Column("sources", sa.Integer(), nullable=False, server_default="1"),
+            sa.Column("indexed_posts", sa.Integer(), nullable=False, server_default="5"),
+            sa.Column("audio_minutes", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("videos", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("launch_kits", sa.Integer(), nullable=False, server_default="0"),
+            sa.Column("voice_cloning", sa.Boolean(), nullable=False, server_default=sa.false()),
+            sa.Column("brand_kit", sa.Boolean(), nullable=False, server_default=sa.false()),
+            sa.Column("features", sa.JSON(), nullable=False),
+            sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+            sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        )
+    types = {"features": sa.JSON(), "voice_cloning": sa.Boolean(), "brand_kit": sa.Boolean(),
+             "created_at": sa.DateTime(timezone=True), "updated_at": sa.DateTime(timezone=True)}
+    plans = sa.table("plans", *(sa.column(k, types.get(k)) for k in [*SEED[0], "created_at", "updated_at"]))
+    existing = {row[0] for row in bind.execute(sa.text("SELECT id FROM plans"))}
+    now = datetime.now(UTC)
+    missing = [{**p, "created_at": now, "updated_at": now} for p in SEED if p["id"] not in existing]
+    if missing:
+        op.bulk_insert(plans, missing)
+
+
+def downgrade() -> None:
+    op.drop_table("plans")

backend/alembic/versions/0007_subscription_plan_fk.py

@@ -0,0 +1,36 @@
+"""subscriptions.plan -> plans.id: the plan is picked from the plans table, not typed as free text
+
+Unknown plan values (typos, removed plans) become 'free' first so the constraint can be added.
+
+Revision ID: 0007_subscription_plan_fk
+Revises: 0006_plans
+Create Date: 2026-09-29
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0007_subscription_plan_fk"
+down_revision = "0006_plans"
+branch_labels = None
+depends_on = None
+
+NAME = "fk_subscriptions_plan_plans"
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    # 0001 builds from the live models, so a fresh database may already have the constraint.
+    if any(fk["referred_table"] == "plans" for fk in sa.inspect(bind).get_foreign_keys("subscriptions")):
+        return
+    op.execute("UPDATE subscriptions SET plan = 'free' WHERE plan IS NULL OR plan NOT IN (SELECT id FROM plans)")
+    with op.batch_alter_table("subscriptions") as batch:
+        batch.create_foreign_key(NAME, "plans", ["plan"], ["id"], onupdate="CASCADE")
+
+
+def downgrade() -> None:
+    fks = sa.inspect(op.get_bind()).get_foreign_keys("subscriptions")
+    name = next((fk["name"] for fk in fks if fk["referred_table"] == "plans"), None)
+    if not name:
+        return  # unnamed (built by 0001 on SQLite): nothing we can drop by name
+    with op.batch_alter_table("subscriptions") as batch:
+        batch.drop_constraint(name, type_="foreignkey")

backend/alembic/versions/0008_b2v_videos.py

@@ -0,0 +1,40 @@
+"""b2v_videos: which workspace owns each blog2video video, and whether its allowance is still charged
+
+blog2video now only takes our account's API key, so this table is our access control and refund ledger.
+blog2video no longer connects to this database: drop the role it used (see docs/BLOG2VIDEO.md).
+
+Revision ID: 0008_b2v_videos
+Revises: 0007_subscription_plan_fk
+Create Date: 2026-09-30
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0008_b2v_videos"
+down_revision = "0007_subscription_plan_fk"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the table.
+    if sa.inspect(op.get_bind()).has_table("b2v_videos"):
+        return
+    op.create_table(
+        "b2v_videos",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        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="SET NULL"), nullable=True),
+        sa.Column("b2v_video_id", sa.Integer(), nullable=True, unique=True),
+        sa.Column("idempotency_key", sa.String(100), nullable=False, unique=True),
+        sa.Column("quota_state", sa.String(20), nullable=False, server_default="charged"),
+        sa.Column("status", sa.String(40), nullable=False, server_default="queued"),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()),
+    )
+    op.create_index("ix_b2v_videos_ws_created", "b2v_videos", ["workspace_id", "created_at"])
+    op.create_index("ix_b2v_videos_artifact_id", "b2v_videos", ["artifact_id"])
+
+
+def downgrade() -> None:
+    op.drop_table("b2v_videos")

backend/alembic/versions/0009_b2v_resources.py

@@ -0,0 +1,111 @@
+"""blog2video resources per workspace: templates, custom voices, saved voices, styles, usage counters;
+b2v_videos.created_via / template_ref; plans.video_premium / video_limits
+
+Everything made with our blog2video key belongs to one account, so these tables are what keeps each workspace's
+templates, voices and styles its own (app/services/b2v_access.py).
+
+Revision ID: 0009_b2v_resources
+Revises: 0008_b2v_videos
+Create Date: 2026-09-30
+"""
+import json
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0009_b2v_resources"
+down_revision = "0008_b2v_videos"
+branch_labels = None
+depends_on = None
+
+# Same as app/services/plans.py
+VIDEO_LIMITS = {
+    "free": {"ai_edits": 20, "templates": 0, "template_ai_daily": 0, "voice_designs_daily": 0,
+             "voice_samples_daily": 0, "custom_voices": 0},
+    "writer": {"ai_edits": 300, "templates": 2, "template_ai_daily": 3, "voice_designs_daily": 5,
+               "voice_samples_daily": 20, "custom_voices": 3},
+    "studio": {"ai_edits": 1000, "templates": 5, "template_ai_daily": 5, "voice_designs_daily": 10,
+               "voice_samples_daily": 40, "custom_voices": 10},
+}
+
+
+def _ws() -> sa.Column:
+    return sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False,
+                     index=True)
+
+
+def _times() -> list[sa.Column]:
+    return [sa.Column("created_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()),
+            sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now())]
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    # 0001 builds from the live models, so a fresh database may already have all of this.
+    video_cols = {c["name"] for c in inspector.get_columns("b2v_videos")}
+    with op.batch_alter_table("b2v_videos") as batch:
+        if "created_via" not in video_cols:
+            batch.add_column(sa.Column("created_via", sa.String(10), nullable=False, server_default="v1"))
+        if "template_ref" not in video_cols:
+            batch.add_column(sa.Column("template_ref", sa.String(100), nullable=True))
+        batch.alter_column("idempotency_key", existing_type=sa.String(100), nullable=True)
+
+    if not inspector.has_table("b2v_templates"):
+        op.create_table("b2v_templates",
+                        sa.Column("b2v_template_id", sa.Integer(), primary_key=True, autoincrement=False), _ws(),
+                        sa.Column("name", sa.String(255), nullable=False),
+                        sa.Column("ready", sa.Boolean(), nullable=False, server_default=sa.false()), *_times())
+    if not inspector.has_table("b2v_custom_voices"):
+        op.create_table("b2v_custom_voices",
+                        sa.Column("b2v_custom_voice_id", sa.Integer(), primary_key=True, autoincrement=False), _ws(),
+                        sa.Column("voice_id", sa.String(100), nullable=False, unique=True),
+                        sa.Column("name", sa.String(255), nullable=False),
+                        sa.Column("source", sa.String(20), nullable=False),
+                        sa.Column("preview_url", sa.String(1000), nullable=True), *_times())
+    if not inspector.has_table("user_saved_voices"):
+        op.create_table("user_saved_voices",
+                        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                  primary_key=True),
+                        sa.Column("voice_id", sa.String(100), primary_key=True),
+                        sa.Column("name", sa.String(255), nullable=False),
+                        sa.Column("preview_url", sa.String(1000), nullable=True),
+                        sa.Column("gender", sa.String(20), nullable=True),
+                        sa.Column("accent", sa.String(50), nullable=True),
+                        sa.Column("premium", sa.Boolean(), nullable=False, server_default=sa.false()),
+                        sa.Column("is_custom", sa.Boolean(), nullable=False, server_default=sa.false()), *_times())
+    if not inspector.has_table("b2v_styles"):
+        op.create_table("b2v_styles",
+                        sa.Column("b2v_style_id", sa.Integer(), primary_key=True, autoincrement=False), _ws(),
+                        sa.Column("name", sa.String(80), nullable=False), *_times())
+    if not inspector.has_table("usage_counters"):
+        op.create_table("usage_counters",
+                        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                  primary_key=True),
+                        sa.Column("period", sa.String(10), primary_key=True),
+                        sa.Column("metric", sa.String(30), primary_key=True),
+                        sa.Column("used", sa.Integer(), nullable=False, server_default="0"))
+
+    plan_cols = {c["name"] for c in inspector.get_columns("plans")}
+    with op.batch_alter_table("plans") as batch:
+        if "video_premium" not in plan_cols:
+            batch.add_column(sa.Column("video_premium", sa.Boolean(), nullable=False, server_default=sa.false()))
+        if "video_limits" not in plan_cols:
+            batch.add_column(sa.Column("video_limits", sa.JSON(), nullable=True))
+    plans = sa.table("plans", sa.column("id", sa.String), sa.column("video_premium", sa.Boolean),
+                     sa.column("video_limits", sa.JSON))
+    for plan_id, limits in VIDEO_LIMITS.items():
+        op.execute(plans.update().where(plans.c.id == plan_id)
+                   .values(video_premium=plan_id != "free", video_limits=json.loads(json.dumps(limits))))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("plans") as batch:
+        batch.drop_column("video_limits")
+        batch.drop_column("video_premium")
+    for table in ("usage_counters", "b2v_styles", "user_saved_voices", "b2v_custom_voices", "b2v_templates"):
+        op.drop_table(table)
+    with op.batch_alter_table("b2v_videos") as batch:
+        batch.drop_column("template_ref")
+        batch.drop_column("created_via")

backend/alembic/versions/0010_b2v_video_refs.py

@@ -0,0 +1,96 @@
+"""b2v_videos holds each video's full reference (who made it, title, source, links); video limits 1 total / 10 / 20
+
+- b2v_videos: user_id, title, source_url, aspect_ratio, preview_url, video_url, backfilled from the workspace owner
+  and the linked artifact.
+- plans: videos_monthly (False on Free: 1 video in total, never refilled); Studio 20 videos a month.
+
+Revision ID: 0010_b2v_video_refs
+Revises: 0009_b2v_resources
+Create Date: 2026-09-30
+"""
+import json
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0010_b2v_video_refs"
+down_revision = "0009_b2v_resources"
+branch_labels = None
+depends_on = None
+
+VIDEO_COLUMNS = {
+    "user_id": lambda: sa.Column("user_id", sa.Uuid(), nullable=True),
+    "title": lambda: sa.Column("title", sa.String(300), nullable=True),
+    "source_url": lambda: sa.Column("source_url", sa.String(2000), nullable=True),
+    "aspect_ratio": lambda: sa.Column("aspect_ratio", sa.String(20), nullable=True),
+    "preview_url": lambda: sa.Column("preview_url", sa.String(1000), nullable=True),
+    "video_url": lambda: sa.Column("video_url", sa.String(1000), nullable=True),
+}
+
+# Same as app/services/plans.py
+PLAN_VIDEOS = {"free": (1, False, "1 video a month", "1 video to try it"),
+               "writer": (10, True, None, None),
+               "studio": (20, True, "30 videos a month", "20 videos a month")}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    # 0001 builds from the live models, so a fresh database may already have these columns.
+    existing = {c["name"] for c in inspector.get_columns("b2v_videos")}
+    missing = [make() for name, make in VIDEO_COLUMNS.items() if name not in existing]
+    if missing:
+        with op.batch_alter_table("b2v_videos") as batch:
+            for column in missing:
+                batch.add_column(column)
+            if "user_id" not in existing:
+                batch.create_foreign_key("fk_b2v_videos_user_id_users", "users", ["user_id"], ["id"],
+                                         ondelete="SET NULL")
+                batch.create_index("ix_b2v_videos_user_id", ["user_id"])
+
+    # Backfill: the workspace owner made it; title and links come from the artifact.
+    rows = bind.execute(sa.text("""
+        SELECT v.id, w.owner_id, a.content_json FROM b2v_videos v
+        JOIN workspaces w ON w.id = v.workspace_id
+        LEFT JOIN artifacts a ON a.id = v.artifact_id
+        WHERE v.user_id IS NULL
+    """)).fetchall()
+    for vid, owner_id, content in rows:
+        c = content if isinstance(content, dict) else json.loads(content or "{}")
+        bind.execute(sa.text("""
+            UPDATE b2v_videos SET user_id = :u, title = COALESCE(title, :t), aspect_ratio = COALESCE(aspect_ratio, :ar),
+                   preview_url = COALESCE(preview_url, :p), video_url = COALESCE(video_url, :v) WHERE id = :id
+        """), {"u": owner_id, "t": (c.get("title") or None), "ar": c.get("aspect_ratio"), "p": c.get("preview_url"),
+               "v": c.get("video_url"), "id": vid})
+
+    plan_cols = {c["name"] for c in inspector.get_columns("plans")}
+    if "videos_monthly" not in plan_cols:
+        with op.batch_alter_table("plans") as batch:
+            batch.add_column(sa.Column("videos_monthly", sa.Boolean(), nullable=False, server_default=sa.true()))
+    for plan_id, (videos, monthly, old, new) in PLAN_VIDEOS.items():
+        row = bind.execute(sa.text("SELECT features FROM plans WHERE id = :id"), {"id": plan_id}).fetchone()
+        if row is None:
+            continue
+        features = row[0] if isinstance(row[0], list) else json.loads(row[0] or "[]")
+        if old:
+            features = [new if f == old else f for f in features]
+        bind.execute(sa.text("UPDATE plans SET videos = :v, videos_monthly = :m, features = :f WHERE id = :id"),
+                     {"v": videos, "m": monthly, "f": json.dumps(features), "id": plan_id})
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("plans") as batch:
+        batch.drop_column("videos_monthly")
+    # A database built from the models (0001) names these differently, so look them up.
+    inspector = sa.inspect(op.get_bind())
+    fks = [fk["name"] for fk in inspector.get_foreign_keys("b2v_videos")
+           if fk["constrained_columns"] == ["user_id"] and fk.get("name")]
+    indexes = [ix["name"] for ix in inspector.get_indexes("b2v_videos") if ix["column_names"] == ["user_id"]]
+    with op.batch_alter_table("b2v_videos") as batch:
+        for name in indexes:
+            batch.drop_index(name)
+        for name in fks:
+            batch.drop_constraint(name, type_="foreignkey")
+        for name in reversed(list(VIDEO_COLUMNS)):
+            batch.drop_column(name)

backend/alembic/versions/0011_one_archive_notebook.py

@@ -0,0 +1,48 @@
+"""One "All posts" notebook per workspace
+
+Two requests opening the Notebooks page at once could each create the archive notebook. This merges the copies into
+the oldest one (its posts, chats and artifacts move over) and adds a unique index so it cannot happen again.
+
+Revision ID: 0011_one_archive_notebook
+Revises: 0010_b2v_video_refs
+Create Date: 2026-10-01
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0011_one_archive_notebook"
+down_revision = "0010_b2v_video_refs"
+branch_labels = None
+depends_on = None
+
+INDEX = "uq_notebooks_one_archive"
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    rows = conn.execute(sa.text(
+        "SELECT workspace_id, id FROM notebooks WHERE is_archive ORDER BY workspace_id, created_at, id"
+    )).all()
+    keep: dict = {}
+    for ws, nb in rows:
+        if ws not in keep:
+            keep[ws] = nb
+            continue
+        ids = {"keep": keep[ws], "dup": nb}
+        conn.execute(sa.text(
+            "INSERT INTO notebook_documents (notebook_id, document_id) "
+            "SELECT :keep, document_id FROM notebook_documents WHERE notebook_id = :dup AND document_id NOT IN "
+            "(SELECT document_id FROM notebook_documents WHERE notebook_id = :keep)"
+        ), ids)
+        conn.execute(sa.text("UPDATE chats SET notebook_id = :keep WHERE notebook_id = :dup"), ids)
+        conn.execute(sa.text("UPDATE artifacts SET notebook_id = :keep WHERE notebook_id = :dup"), ids)
+        conn.execute(sa.text("DELETE FROM notebooks WHERE id = :dup"), ids)
+
+    # 0001 builds from the live models, so a fresh database may already have the index.
+    if INDEX not in {i["name"] for i in sa.inspect(conn).get_indexes("notebooks")}:
+        op.create_index(INDEX, "notebooks", ["workspace_id"], unique=True,
+                        postgresql_where=sa.text("is_archive"), sqlite_where=sa.text("is_archive"))
+
+
+def downgrade() -> None:
+    op.drop_index(INDEX, table_name="notebooks")

backend/alembic/versions/0012_artifact_status_len.py

@@ -0,0 +1,26 @@
+"""Longer artifact status
+
+A video's artifact now takes blog2video's job statuses as they are (e.g. "language_regenerating", 21 characters),
+which do not fit the old 20.
+
+Revision ID: 0012_artifact_status_len
+Revises: 0011_one_archive_notebook
+Create Date: 2026-10-02
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0012_artifact_status_len"
+down_revision = "0011_one_archive_notebook"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("artifacts") as batch:
+        batch.alter_column("status", existing_type=sa.String(20), type_=sa.String(40), existing_nullable=False)
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("artifacts") as batch:
+        batch.alter_column("status", existing_type=sa.String(40), type_=sa.String(20), existing_nullable=False)

backend/alembic/versions/{0005_workspace_memory.py → 0013_workspace_memory.py}

@@ -1,14 +1,14 @@
 """workspace_memory: one row of standing notes per workspace, stored as JSON
 
-Revision ID: 0005_workspace_memory
-Revises: 0004_archive_notebook
+Revision ID: 0013_workspace_memory
+Revises: 0012_artifact_status_len
 Create Date: 2026-09-30
 """
 import sqlalchemy as sa
 from alembic import op
 
-revision = "0005_workspace_memory"
-down_revision = "0004_archive_notebook"
+revision = "0013_workspace_memory"
+down_revision = "0012_artifact_status_len"
 branch_labels = None
 depends_on = None
 

backend/alembic/versions/{0006_chat_citations.py → 0014_chat_citations.py}

@@ -1,14 +1,14 @@
 """citations.kind: a citation can point at an earlier chat (no document) as well as a post
 
-Revision ID: 0006_chat_citations
-Revises: 0005_workspace_memory
+Revision ID: 0014_chat_citations
+Revises: 0013_workspace_memory
 Create Date: 2026-10-01
 """
 import sqlalchemy as sa
 from alembic import op
 
-revision = "0006_chat_citations"
-down_revision = "0005_workspace_memory"
+revision = "0014_chat_citations"
+down_revision = "0013_workspace_memory"
 branch_labels = None
 depends_on = None
 

backend/alembic/versions/{0007_message_feedback.py → 0015_message_feedback.py}

@@ -1,14 +1,14 @@
 """message_feedback: thumbs up/down on chat answers, plus messages.recall_json (how the answer was produced)
 
-Revision ID: 0007_message_feedback
-Revises: 0006_chat_citations
+Revision ID: 0015_message_feedback
+Revises: 0014_chat_citations
 Create Date: 2026-10-02
 """
 import sqlalchemy as sa
 from alembic import op
 
-revision = "0007_message_feedback"
-down_revision = "0006_chat_citations"
+revision = "0015_message_feedback"
+down_revision = "0014_chat_citations"
 branch_labels = None
 depends_on = None
 

backend/alembic/versions/{0008_support_chat.py → 0016_support_chat.py}

@@ -1,14 +1,14 @@
 """support_chat: conversations and messages for the in app help bot
 
-Revision ID: 0008_support_chat
-Revises: 0007_message_feedback
+Revision ID: 0016_support_chat
+Revises: 0015_message_feedback
 Create Date: 2026-10-06
 """
 import sqlalchemy as sa
 from alembic import op
 
-revision = "0008_support_chat"
-down_revision = "0007_message_feedback"
+revision = "0016_support_chat"
+down_revision = "0015_message_feedback"
 branch_labels = None
 depends_on = None
 

backend/app/config.py

@@ -121,6 +121,15 @@ class Settings(BaseSettings):
     linkedin_client_id: str = ""
     linkedin_client_secret: str = ""
 
+    # blog2video: makes the videos. We call its public API with our own account's key (b2v_live_...), so every
+    # video is charged to that account. Backend only: the key must never reach the browser or the logs.
+    b2v_api_base_url: str = Field("", validation_alias=AliasChoices("B2V_API_BASE_URL", "B2V_API_URL"))
+    b2v_api_key: str = ""
+    # blog2video's web app: serves the template poster images (<app>/template-posters/<id>.webp).
+    b2v_app_url: str = "https://blog2video.app"
+    b2v_timeout_seconds: float = 30  # creates, uploads and full-project reads; other calls also wait 30s (STATUS_TIMEOUT)
+    b2v_capacity_alert_below: int = 20  # log an error when our blog2video account has fewer videos left
+
     # Renderer
     renderer_url: str = "http://localhost:3100"
     internal_token: str = "internal-change-me"

backend/app/llm/provider.py

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

backend/app/llm/run.py

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

backend/app/llm/signatures.py

@@ -47,14 +47,6 @@ class ScriptLine(BaseModel):
     sources: list[SourceRef] = Field(default_factory=list)
 
 
-class Scene(BaseModel):
-    type: Literal["title", "section", "pull_quote", "number", "outro"]
-    on_screen_text: str
-    narration: str
-    duration_hint_s: float
-    visual: str = ""
-
-
 class Hook(BaseModel):
     text: str
     strength: float = Field(ge=0, le=1)
@@ -278,14 +270,6 @@ class PodcastScript(dspy.Signature):
     lines: list[ScriptLine] = dspy.OutputField()
 
 
-class VideoStoryboard(dspy.Signature):
-    """Turn the post into a scene list for a Remotion composition."""
-
-    passages: list[str] = dspy.InputField()
-    aspect: Literal["16:9", "9:16", "1:1"] = dspy.InputField()
-    scenes: list[Scene] = dspy.OutputField()
-
-
 class HookGenerator(dspy.Signature):
     """Write scroll stopping hooks for the post in the writer's voice. No em dashes."""
 
@@ -458,3 +442,30 @@ class TriageWithMemory(TriageMessage):
                                        "`slug | label | last active | gist`")
     topic: str = dspy.OutputField(desc="The slug of the topic the message belongs to, or none")
     memory: Literal["none", "lookup", "replay", "compose"] = dspy.OutputField()
+
+
+class FocusTopic(BaseModel):
+    # Not "title"/"description": with those names GLM sometimes wrote the word "Description" as every title.
+    topic: str = Field(description="The angle itself in 3 to 7 words, e.g. \"Why tokens break software margins\". "
+                                   "Never a label such as Title, Topic or Description. No trailing period")
+    summary: str = Field(description="Two short sentences (at most 40 words): what the video would cover and the "
+                                     "angle it takes, using only this material")
+
+
+class FocusAngle(FocusTopic):
+    tag: str = Field(description="The candidate tag this angle is built on, copied exactly (its name only), or an "
+                                 "empty string when it comes from the material alone")
+
+
+class VideoFocusAngles(dspy.Signature):
+    """Suggest three distinct angles a short explainer video could focus on, drawn only from this material. Build
+    each angle on a different candidate tag when tags are given (a tag shared by several items makes a good angle that
+    connects them). Each has a short, specific topic (different for each of the three) and a two sentence summary of
+    what the video covers about that angle. Never reuse or closely reword an avoided title: find a new angle instead.
+    Never use em dashes."""
+
+    items: list[str] = dspy.InputField(desc="Each item: a title (when there is one), then the start of its text")
+    candidate_tags: list[str] = dspy.InputField(
+        desc="Topics this material is about: 'Name (in how many items): what it covers'. May be empty")
+    avoid_titles: list[str] = dspy.InputField(desc="Titles already suggested. Do not repeat or reword them")
+    topics: list[FocusAngle] = dspy.OutputField(desc="Exactly 3 focus topics")

backend/app/main.py

@@ -23,6 +23,10 @@ from app.routers import (
     support,
     topics,
     unsubscribe,
+    video_edit,
+    video_styles,
+    video_voices,
+    videos,
     voice,
 )
 from app.routers import settings as settings_router
@@ -88,8 +92,9 @@ def health():
     return {"ok": True, "llm": settings.llm_model, "billing_enabled": settings.billing_enabled}
 
 
+# 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, settings_router, memory, support):
+          launchpad, videos, video_edit, video_voices, video_styles, settings_router, memory, support):
     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,9 @@
 from app.models.content import (
     Artifact,
+    B2VCustomVoice,
+    B2VStyle,
+    B2VTemplate,
+    B2VVideo,
     CalendarItem,
     Chat,
     Citation,
@@ -17,20 +21,26 @@ from app.models.content import (
     Topic,
     TrackedLink,
     Upload,
+    UsageCounter,
     UsageEvent,
+    UserSavedVoice,
     VoiceConsent,
     VoiceProfile,
     WorkspaceMemory,
 )
 from app.models.email import EmailVerificationCode, UpdateEmail, UpdateEmailSend, VerificationPurpose
 from app.models.support import SupportConversation, SupportMessage
-from app.models.user import AuthProvider, BillingEvent, Subscription, User, Workspace, WorkspaceMember
+from app.models.user import AuthProvider, BillingEvent, PlanRecord, Subscription, User, Workspace, WorkspaceMember
 
 __all__ = [
     "SupportConversation",
     "SupportMessage",
     "Artifact",
     "AuthProvider",
+    "B2VCustomVoice",
+    "B2VStyle",
+    "B2VTemplate",
+    "B2VVideo",
     "BillingEvent",
     "CalendarItem",
     "Chat",
@@ -44,6 +54,7 @@ __all__ = [
     "Message",
     "MessageFeedback",
     "Notebook",
+    "PlanRecord",
     "NotebookDocument",
     "SocialAccount",
     "Source",
@@ -53,7 +64,9 @@ __all__ = [
     "UpdateEmail",
     "UpdateEmailSend",
     "Upload",
+    "UsageCounter",
     "UsageEvent",
+    "UserSavedVoice",
     "User",
     "VerificationPurpose",
     "VoiceConsent",

backend/app/models/content.py

@@ -14,6 +14,7 @@ from sqlalchemy import (
     Text,
     UniqueConstraint,
     Uuid,
+    text,
 )
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -60,6 +61,9 @@ class Document(IdMixin, TimestampMixin, Base):
 
 class Notebook(IdMixin, TimestampMixin, Base):
     __tablename__ = "notebooks"
+    # One "All posts" notebook per workspace: two requests opening it at once cannot both create one.
+    __table_args__ = (Index("uq_notebooks_one_archive", "workspace_id", unique=True,
+                            postgresql_where=text("is_archive"), sqlite_where=text("is_archive")),)
 
     workspace_id: Mapped[uuid.UUID] = _ws_fk()
     title: Mapped[str] = mapped_column(String(300))
@@ -184,11 +188,106 @@ class Artifact(IdMixin, TimestampMixin, Base):
     document_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("documents.id", ondelete="SET NULL"))
     # summary | audio_overview | video | thread | linkedin | notes | quote_card | carousel | seo
     type: Mapped[str] = mapped_column(String(30))
-    status: Mapped[str] = mapped_column(String(20), default="pending")
+    # pending | generating | ready | failed | rendering | review; a video also takes blog2video's job statuses as they
+    # are: regenerating (template switch) | voice_regenerating | language_regenerating | script_regenerating
+    status: Mapped[str] = mapped_column(String(40), default="pending")
     content_json: Mapped[dict] = mapped_column(JSON, default=dict)
     storage_key: Mapped[str | None] = mapped_column(String(500))
 
 
+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
+    and whether the workspace's video allowance is still charged for it.
+
+    Our API key reaches every video it created, for every workspace, so this table (with the artifact) is what
+    ties a blog2video id to one workspace. quota_state moves charged -> refunded (or -> kept once generated), with a
+    conditional UPDATE (see video_quota.refund), so the status poller and the sweep can not refund twice."""
+
+    __tablename__ = "b2v_videos"
+    __table_args__ = (Index("ix_b2v_videos_ws_created", "workspace_id", "created_at"),)
+
+    workspace_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"))
+    user_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("users.id", ondelete="SET NULL"),
+                                                      index=True)  # who made it
+    artifact_id: Mapped[uuid.UUID | None] = mapped_column(Uuid, ForeignKey("artifacts.id", ondelete="SET NULL"),
+                                                          index=True)
+    # blog2video's video id, which is also its project id. Null until blog2video accepts the create.
+    b2v_video_id: Mapped[int | None] = mapped_column(Integer, unique=True)
+    idempotency_key: Mapped[str | None] = mapped_column(String(100), unique=True)  # "<workspace_id>:<uuid>"; v1 only
+    created_via: Mapped[str] = mapped_column(String(10), default="v1", server_default="v1")  # v1 | upload
+    template_ref: Mapped[str | None] = mapped_column(String(100))  # e.g. custom_58: blocks deleting that template
+    title: Mapped[str | None] = mapped_column(String(300))
+    source_url: Mapped[str | None] = mapped_column(String(2000))  # the link it was made from (null for files, text)
+    aspect_ratio: Mapped[str | None] = mapped_column(String(20))
+    preview_url: Mapped[str | None] = mapped_column(String(1000))  # public live preview (embed token)
+    video_url: Mapped[str | None] = mapped_column(String(1000))  # the rendered MP4
+    quota_state: Mapped[str] = mapped_column(String(20), default="charged")  # charged | refunded | kept
+    status: Mapped[str] = mapped_column(String(40), default="queued")  # last known blog2video status
+
+
+class B2VTemplate(TimestampMixin, Base):
+    """A custom template this workspace made. Used on videos as custom_<b2v_template_id>; only when ready."""
+
+    __tablename__ = "b2v_templates"
+
+    b2v_template_id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=False)
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    name: Mapped[str] = mapped_column(String(255))
+    ready: Mapped[bool] = mapped_column(Boolean, default=False)  # code generation finished ('complete')
+
+
+class B2VCustomVoice(TimestampMixin, Base):
+    """A designed or cloned voice this workspace made. Videos reference it by voice_id (custom_voice_id)."""
+
+    __tablename__ = "b2v_custom_voices"
+
+    b2v_custom_voice_id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=False)  # preview/delete
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    voice_id: Mapped[str] = mapped_column(String(100), unique=True)  # the ElevenLabs id sent as custom_voice_id
+    name: Mapped[str] = mapped_column(String(255))
+    source: Mapped[str] = mapped_column(String(20))  # prompt | preset | clone
+    preview_url: Mapped[str | None] = mapped_column(String(1000))
+
+
+class UserSavedVoice(TimestampMixin, Base):
+    """The workspace's "My voices" list. Kept only here: blog2video's saved-voice list is shared by everyone."""
+
+    __tablename__ = "user_saved_voices"
+
+    workspace_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                                    primary_key=True)
+    voice_id: Mapped[str] = mapped_column(String(100), primary_key=True)
+    name: Mapped[str] = mapped_column(String(255))
+    preview_url: Mapped[str | None] = mapped_column(String(1000))
+    gender: Mapped[str | None] = mapped_column(String(20))
+    accent: Mapped[str | None] = mapped_column(String(50))
+    premium: Mapped[bool] = mapped_column(Boolean, default=False)  # a paid built-in voice, or any custom voice
+    is_custom: Mapped[bool] = mapped_column(Boolean, default=False)
+
+
+class B2VStyle(TimestampMixin, Base):
+    """A custom video style this workspace made. Used on videos as custom:<b2v_style_id>."""
+
+    __tablename__ = "b2v_styles"
+
+    b2v_style_id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=False)
+    workspace_id: Mapped[uuid.UUID] = _ws_fk()
+    name: Mapped[str] = mapped_column(String(80))
+
+
+class UsageCounter(Base):
+    """Per-workspace counters for the video features blog2video only limits account-wide (video_limits.py)."""
+
+    __tablename__ = "usage_counters"
+
+    workspace_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"),
+                                                    primary_key=True)
+    period: Mapped[str] = mapped_column(String(10), primary_key=True)  # 2026-10 | 2026-10-02 | all
+    metric: Mapped[str] = mapped_column(String(30), primary_key=True)
+    used: Mapped[int] = mapped_column(Integer, default=0)
+
+
 class Job(IdMixin, TimestampMixin, Base):
     """Covers ingest, tts and render jobs. kind decides which fields matter.
 

backend/app/models/user.py

@@ -2,7 +2,20 @@ import enum
 import uuid
 from datetime import datetime
 
-from sqlalchemy import JSON, Boolean, DateTime, Enum, ForeignKey, Integer, String, UniqueConstraint, Uuid
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    Integer,
+    String,
+    UniqueConstraint,
+    Uuid,
+    false,
+    true,
+)
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from app.db import Base
@@ -64,12 +77,45 @@ class Subscription(IdMixin, TimestampMixin, Base):
     workspace_id: Mapped[uuid.UUID] = mapped_column(
         Uuid, ForeignKey("workspaces.id", ondelete="CASCADE"), unique=True
     )
-    plan: Mapped[str] = mapped_column(String(20), default="free")  # free | writer | studio
+    # A row of the plans table. Only kept while status is active/trialing/past_due (see plans.effective_plan).
+    plan: Mapped[str] = mapped_column(String(20), ForeignKey("plans.id", onupdate="CASCADE"), default="free")
     status: Mapped[str] = mapped_column(String(20), default="active")
     provider: Mapped[str | None] = mapped_column(String(20))
     provider_customer_id: Mapped[str | None] = mapped_column(String(100))
     provider_subscription_id: Mapped[str | None] = mapped_column(String(100))
     current_period_end: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    # Video allowance, enforced by us (see app/services/video_quota.py): +1 per video before we call blog2video,
+    # -1 when it fails; video_plan/video_limit follow the effective plan and videos_used resets each period.
+    video_plan: Mapped[str] = mapped_column(String(20), default="free", server_default="free")
+    videos_used: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
+    video_limit: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
+    videos_period_start: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+
+
+class PlanRecord(TimestampMixin, Base):
+    """One row per plan: limits, price and pricing-page copy. Edit a row to change a plan without a deploy
+    (app/services/plans.py reloads within a minute). Ids are fixed: Stripe prices and subscriptions use them."""
+
+    __tablename__ = "plans"
+
+    id: Mapped[str] = mapped_column(String(20), primary_key=True)  # free | writer | studio
+    sort_order: Mapped[int] = mapped_column(Integer, default=0)  # cheapest first; upgrades go up this order
+    name: Mapped[str] = mapped_column(String(50))
+    tagline: Mapped[str] = mapped_column(String(200), default="")
+    price_monthly_usd: Mapped[float] = mapped_column(Float, default=0)
+    sources: Mapped[int] = mapped_column(Integer, default=1)
+    indexed_posts: Mapped[int] = mapped_column(Integer, default=5)
+    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
+    voice_cloning: Mapped[bool] = mapped_column(Boolean, default=False)
+    brand_kit: Mapped[bool] = mapped_column(Boolean, default=False)
+    features: Mapped[list] = mapped_column(JSON, default=list)  # bullet points on the pricing page
+    # Server defaults: 0006 seeds this table without these columns on a database 0001 built from the models.
+    video_premium: Mapped[bool] = mapped_column(Boolean, default=False, server_default=false())  # premium options
+    # False: `videos` is a lifetime total that never refills (Free). True: per month.
+    videos_monthly: Mapped[bool] = mapped_column(Boolean, default=True, server_default=true())
+    video_limits: Mapped[dict | None] = mapped_column(JSON, default=dict)  # see plans.VIDEO_LIMITS
 
 
 class BillingEvent(Base):

backend/app/pipeline/generate.py

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

backend/app/pipeline/media.py

@@ -1,4 +1,4 @@
-"""Audio overviews (two hosts, ElevenLabs), videos and stills (Remotion renderer)."""
+"""Audio overviews (two hosts, ElevenLabs), audiograms and stills (Remotion renderer)."""
 
 import uuid
 
@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session
 from app.config import settings
 from app.corpus import Corpus
 from app.llm import run
-from app.llm.signatures import PickQuotes, PodcastScript, VideoStoryboard
+from app.llm.signatures import PickQuotes, PodcastScript
 from app.models import Artifact, Document, Job, Source, User, VoiceProfile, Workspace
 from app.pipeline.generate import NothingToDo
 from app.pipeline.passages import notebook_docs, passages_for, tools_for, verify_refs
@@ -17,12 +17,6 @@ from app.services.jobs import record_usage, update_job
 from app.services.renderer import PermanentJobError, brand_props, request_render
 from app.services.storage import keys, storage
 
-SCENE_TYPES = {"title", "section", "pull_quote", "number", "outro"}
-VIDEO_STYLES = {
-    "short": ("ShortVertical", "9:16"),
-    "explainer": ("ExplainerLong", "16:9"),
-}
-
 
 def artifact_docs(db: Session, artifact: Artifact) -> list[Document]:
     if artifact.document_id:
@@ -112,91 +106,13 @@ def audio_overview(db: Session, job: Job, artifact: Artifact) -> dict:
     return {"artifact_id": str(artifact.id), "duration_s": round(t, 1)}
 
 
-# Video
-
-
-def _clamp(value, lo: float, hi: float) -> float:
-    try:
-        return max(lo, min(hi, float(value)))
-    except (TypeError, ValueError):
-        return lo
+# Video: blog2video makes videos now (app/routers/videos.py). The renderer still makes audiograms.
 
 
 def make_video(db: Session, job: Job, artifact: Artifact) -> None:
-    style = job.params.get("style", "short")
-    if style == "audiogram":
+    if job.params.get("style") == "audiogram":
         return make_audiogram(db, job, artifact)
-    composition, aspect = VIDEO_STYLES[style]
-    docs = artifact_docs(db, artifact)
-    if not docs:
-        raise NothingToDo("Add posts before making a video.")
-    corpus = Corpus(artifact.workspace_id)
-    workspace = db.get(Workspace, artifact.workspace_id)
-    update_job(db, job, progress=0.05, message="Storyboarding")
-    passages = passages_for(corpus, docs, budget_chars=60_000)
-    out = run.predict(VideoStoryboard, db=db, workspace_id=artifact.workspace_id, job=job,
-                      passages=passages, aspect=aspect)
-    scenes = [s for s in (out.get("scenes") or []) if (s.get("on_screen_text") or "").strip()]
-    if not scenes:
-        raise RuntimeError("The storyboard came back empty")
-    max_scenes = 8 if style == "short" else 14
-    scenes = scenes[:max_scenes]
-
-    captions: list[dict] = []
-    audio = bytearray()
-    cursor = 0.0
-    voice_a, _ = host_voices(db, artifact.workspace_id)
-    narrator = host_settings(db, artifact.workspace_id)["host_a"]
-    out_scenes = []
-    for i, s in enumerate(scenes):
-        narration = (s.get("narration") or "").strip()
-        duration = _clamp(s.get("duration_hint_s"), 2.0, 20.0)
-        if narration and settings.elevenlabs_api_key:
-            update_job(db, job, progress=0.15 + 0.5 * i / len(scenes), message=f"Narrating scene {i + 1}")
-            clip, words = tts.synthesize_with_timestamps(artifact.workspace_id, narration, voice_a, narrator)
-            seconds = tts.mp3_seconds(clip)
-            # Pad with silence so each clip starts exactly when its scene does.
-            audio += _silence(cursor - tts.mp3_seconds(bytes(audio)))
-            offset = int(cursor * 1000)
-            captions += [{**w, "startMs": w["startMs"] + offset, "endMs": w["endMs"] + offset} for w in words]
-            audio += clip
-            duration = max(duration, seconds + 0.3)
-        cursor += duration
-        scene_type = s.get("type") if s.get("type") in SCENE_TYPES else "section"
-        out_scenes.append({"type": scene_type, "onScreenText": s["on_screen_text"][:300],
-                           "narration": narration, "durationS": round(_clamp(duration, 0.5, 60), 2)})
-
-    props: dict = {"scenes": out_scenes, "captions": captions, "brand": brand_props(workspace)}
-    title = docs[0].title if len(docs) == 1 else (artifact.content_json or {}).get("title", "Notestack")
-    if composition == "ShortVertical":
-        hook = next((sc["onScreenText"] for sc in out_scenes if sc["type"] == "title"), title)
-        props["hook"] = hook[:120]
-    else:
-        props["title"] = title[:140]
-    if audio:
-        key = keys.artifact(artifact.workspace_id, artifact.id, "narration", "mp3")
-        storage.put_bytes(key, bytes(audio), "audio/mpeg")
-        props["audioUrl"] = storage.presign_get(key, ttl=6 * 3600)
-    artifact.content_json = {**(artifact.content_json or {}), "style": style, "composition": composition,
-                             "scenes": out_scenes, "duration_s": round(cursor, 1)}
-    artifact.status = "rendering"
-    db.commit()
-    update_job(db, job, progress=0.7, message="Handing off to the renderer")
-    request_render(job, artifact, composition, props)
-    record_usage(db, workspace_id=artifact.workspace_id, kind="video", provider="remotion",
-                 quantity=round(cursor, 1), unit="seconds", job=job)
-
-
-_SILENT_FRAME = None
-
-
-def _silence(seconds: float) -> bytes:
-    """MPEG1 Layer III 128 kbps 44.1 kHz silent frames (417 bytes, ~26 ms each)."""
-    global _SILENT_FRAME
-    if _SILENT_FRAME is None:
-        _SILENT_FRAME = bytes([0xFF, 0xFB, 0x90, 0x64]) + bytes(413)
-    frames = int(seconds / 0.026122)
-    return _SILENT_FRAME * max(frames, 0)
+    raise PermanentJobError("Videos are now made in the Videos editor.")
 
 
 def make_audiogram(db: Session, job: Job, artifact: Artifact) -> None:
@@ -217,7 +133,7 @@ def make_audiogram(db: Session, job: Job, artifact: Artifact) -> None:
     db.commit()
     update_job(db, job, progress=0.1, message="Handing off to the renderer")
     request_render(job, artifact, "AudiogramSquare", props)
-    record_usage(db, workspace_id=artifact.workspace_id, kind="video", provider="remotion",
+    record_usage(db, workspace_id=artifact.workspace_id, kind="render", provider="remotion",
                  quantity=props["durationS"], unit="seconds", job=job)
 
 

backend/app/routers/artifacts.py

@@ -21,7 +21,7 @@ ArtifactType = Literal["summary", "audio_overview", "video", "quote_card", "caro
 
 
 class RenderIn(BaseModel):
-    composition: Literal["ShortVertical", "ExplainerLong", "AudiogramSquare", "QuoteCard", "CarouselSlide"]
+    composition: Literal["AudiogramSquare", "QuoteCard", "CarouselSlide"]
     props: dict
 
 
@@ -33,8 +33,8 @@ class GenerateIn(BaseModel):
     # audio_overview
     format: Literal["deep_dive", "brief", "debate"] = "deep_dive"
     minutes: int = Field(6, ge=1, le=30)
-    # video
-    style: Literal["short", "explainer", "audiogram"] = "short"
+    # video: only audiograms here; other videos are made by blog2video (/api/videos)
+    style: str = "audiogram"
     audio_artifact_id: uuid.UUID | None = None
     # carousel
     slides: list[dict] | None = None
@@ -84,12 +84,12 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         body.notebook_id = ensure_archive_notebook(ctx).id
     params: dict = {}
     content: dict = {}
-    if body.type == "video" and body.style == "audiogram":
+    if body.type == "video" and body.style != "audiogram":
+        raise HTTPException(410, "Videos moved to /app/videos")
+    if body.type == "video":
         if not body.audio_artifact_id:
             raise HTTPException(400, "Pick an audio overview for the audiogram")
         source = get_artifact_or_404(ctx, body.audio_artifact_id)
-        seconds = float((source.content_json or {}).get("duration_s", 60))
-        check_limit(ctx.db, ctx.workspace, "video_minutes", seconds / 60)
         title = f"Audiogram: {(source.content_json or {}).get('title', 'Audio overview')}"
         params = {"style": "audiogram", "audio_artifact_id": str(source.id)}
         artifact, job = start_artifact(ctx.db, ctx.workspace.id, "video", title=title, notebook_id=source.notebook_id,
@@ -104,10 +104,6 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         check_limit(ctx.db, ctx.workspace, "audio_minutes", body.minutes)
         params = {"format": body.format, "minutes": body.minutes}
         title = f"Audio overview: {target}"
-    elif body.type == "video":
-        check_limit(ctx.db, ctx.workspace, "video_minutes", 1 if body.style == "short" else 3)
-        params = {"style": body.style}
-        title = f"{'Short' if body.style == 'short' else 'Explainer'} video: {target}"
     elif body.type == "mind_map":
         if not body.notebook_id:
             raise HTTPException(400, "A Mind Constellation is made from a notebook")
@@ -182,6 +178,11 @@ def patch_artifact(artifact_id: uuid.UUID, body: PatchIn, ctx: Ctx = Depends(get
 @router.delete("/{artifact_id}")
 def delete_artifact(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
     a = get_artifact_or_404(ctx, artifact_id)
+    if a.type == "video" and (a.content_json or {}).get("provider") == "blog2video":
+        from app.routers.videos import remove_video  # also removes it from blog2video
+
+        remove_video(ctx, a)
+        return {"ok": True}
     storage.delete_prefix(f"ws/{ctx.workspace.id}/artifacts/{a.id}/")
     ctx.db.query(CalendarItem).filter(CalendarItem.artifact_id == a.id, CalendarItem.status == "scheduled").delete()
     ctx.db.delete(a)

backend/app/routers/billing.py

@@ -8,7 +8,7 @@ from app.auth import Ctx, get_ctx
 from app.config import settings
 from app.db import get_db
 from app.services.billing import billing_status, create_checkout_url, create_portal_url
-from app.services.plans import PLAN_ORDER, PLANS, effective_plan, plan_dict
+from app.services.plans import PLANS, effective_plan, plan_dict, plan_order
 
 router = APIRouter(prefix="/api/billing", tags=["billing"])
 
@@ -40,7 +40,8 @@ def checkout(body: CheckoutIn, ctx: Ctx = Depends(get_ctx)):
     if not settings.billing_enabled:
         raise HTTPException(409, {"code": "billing_disabled", "message": "Checkout is not available yet."})
     current = effective_plan(ctx.db, ctx.workspace)
-    if PLAN_ORDER.index(body.plan) <= PLAN_ORDER.index(current.id):
+    order = plan_order()
+    if body.plan not in PLANS or order.index(body.plan) <= order.index(current.id):
         raise HTTPException(409, {"code": "already_on_plan", "message": f"You are already on {current.name}."})
     return {"url": create_checkout_url(ctx.db, ctx.user, ctx.workspace, PLANS[body.plan], body.cycle)}
 

backend/app/routers/notebooks.py

@@ -10,6 +10,7 @@ from fastapi import APIRouter, Depends, HTTPException
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 from sqlalchemy import delete, func, select
+from sqlalchemy.exc import IntegrityError
 
 from app.auth import Ctx, get_ctx
 from app.chat_memory.context import load_chat_memory
@@ -103,12 +104,20 @@ ARCHIVE_TITLE = "All posts"
 
 def ensure_archive_notebook(ctx: Ctx) -> Notebook:
     """The workspace's "All posts" notebook, topped up with every indexed post (locked posts are skipped)."""
-    nb = ctx.db.scalar(select(Notebook).where(Notebook.workspace_id == ctx.workspace.id, Notebook.is_archive.is_(True)))
+    def find() -> Notebook | None:
+        return ctx.db.scalar(select(Notebook).where(Notebook.workspace_id == ctx.workspace.id,
+                                                    Notebook.is_archive.is_(True)))
+
+    nb = find()
     if not nb:
-        nb = Notebook(workspace_id=ctx.workspace.id, title=ARCHIVE_TITLE, is_archive=True,
-                      description="Every indexed post in your archive, kept up to date.")
-        ctx.db.add(nb)
-        ctx.db.flush()
+        try:
+            nb = Notebook(workspace_id=ctx.workspace.id, title=ARCHIVE_TITLE, is_archive=True,
+                          description="Every indexed post in your archive, kept up to date.")
+            ctx.db.add(nb)
+            ctx.db.flush()
+        except IntegrityError:  # a concurrent request made it first (uq_notebooks_one_archive)
+            ctx.db.rollback()
+            nb = find()
     ids = list(ctx.db.scalars(select(Document.id).where(Document.workspace_id == ctx.workspace.id)))
     _add_docs(ctx, nb, ids)
     ctx.db.commit()
@@ -161,6 +170,21 @@ def list_notebooks(ctx: Ctx = Depends(get_ctx)):
     ]
 
 
+# Above /{notebook_id}, so "chats" is not read as a notebook id.
+@router.get("/chats")
+def list_all_chats(ctx: Ctx = Depends(get_ctx)):
+    """Every chat in the workspace that has an answer, newest first (the video wizard's "Made from" menu)."""
+    answered = select(Message.chat_id).where(Message.role == "assistant")
+    rows = ctx.db.execute(
+        select(Chat, Notebook.title).join(Notebook, Notebook.id == Chat.notebook_id)
+        .where(Chat.workspace_id == ctx.workspace.id, Chat.id.in_(answered))
+        .order_by(Chat.updated_at.desc())
+    ).all()
+    return [{"id": str(c.id), "title": c.title, "notebook_id": str(c.notebook_id), "notebook_title": nb_title,
+             "updated_at": c.updated_at.isoformat() if c.updated_at else None}
+            for c, nb_title in rows]
+
+
 @router.get("/{notebook_id}")
 def get_notebook(notebook_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
     nb = _get(ctx, notebook_id)

backend/app/routers/topics.py

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

backend/app/routers/video_edit.py

@@ -0,0 +1,212 @@
+"""The video editor: one allowlisted proxy onto blog2video's /api/projects/{id}/... endpoints.
+
+    <METHOD> /api/videos/{artifact_id}/p/<path>  ->  <METHOD> /api/projects/{blog2video id}/<path>
+
+Only paths in RULES pass (anything else is 404). Before forwarding, the video must be this workspace's
+(b2v_access.video_or_404), every template / voice / style id in a JSON body must be this workspace's (check_refs),
+premium (★) features need a paid plan, and AI edits come out of the workspace's own counter (given back if
+blog2video refuses). A template switch also uses one video, as it does on blog2video.
+
+JSON bodies, multipart uploads (images, voiceovers, portraits) and binary answers (downloads, stills) pass through.
+"""
+
+import json
+import re
+import uuid
+from dataclasses import dataclass
+
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
+from starlette.concurrency import run_in_threadpool
+from starlette.datastructures import UploadFile
+
+from app.auth import Ctx, get_ctx
+from app.routers.videos import b2v_ready, store, upstream
+from app.services import b2v_access, video_limits, video_quota
+from app.services import blog2video as b2v
+from app.services.plans import effective_plan, plan_limit_error
+
+router = APIRouter(prefix="/api/videos", tags=["videos"])
+
+MAX_JSON_BYTES = 512 * 1024
+MAX_FILE_BYTES = 50 * 1024 * 1024
+S = r"\d+"  # a scene id
+
+
+@dataclass(frozen=True)
+class Rule:
+    ai_edits: int = 0  # AI edits this call uses (per workspace, video_limits "ai_edits")
+    per_scene: bool = False  # ai_edits is per scene_ids entry (avatar batches)
+    premium: str | None = None  # ★: what to call it in the upgrade message
+    uses_video: bool = False  # a template switch: one video from the allowance
+    raw: bool = False  # binary answer (download, still)
+    timeout: float = 30
+    status: str | None = None  # artifact status to show once it started
+
+
+RULES: list[tuple[str, re.Pattern, Rule]] = [(m, re.compile(f"^{p}$"), r) for m, p, r in [
+    # Project settings, logo, assets
+    ("GET", "", Rule(timeout=60)),  # the whole project: slow on a far-away database
+    ("PATCH", "update-project", Rule()),
+    ("PATCH", "", Rule()),
+    ("POST", "logo", Rule()),
+    ("DELETE", "logo", Rule()),
+    ("PATCH", rf"assets/{S}/exclude", Rule()),
+    ("DELETE", rf"assets/{S}", Rule()),
+    ("GET", "layouts", Rule()),
+    ("GET", "status", Rule()),
+    # Scenes
+    ("PUT", rf"scenes/{S}", Rule()),
+    ("DELETE", rf"scenes/{S}", Rule()),
+    ("PUT", "bulk-update-scenes", Rule()),
+    ("POST", "scenes/reorder", Rule()),
+    ("POST", rf"scenes/{S}/regenerate", Rule(ai_edits=1, timeout=120)),
+    ("POST", "scenes/add", Rule(ai_edits=1)),
+    ("GET", "scenes/add-status", Rule()),
+    # Images
+    ("POST", rf"scenes/{S}/image", Rule(timeout=60)),
+    ("POST", rf"scenes/{S}/generate-image", Rule(ai_edits=1, timeout=120)),
+    ("PATCH", rf"scenes/{S}/image-focus", Rule()),
+    ("POST", "images/move", Rule()),
+    ("POST", "images/swap", Rule()),
+    ("POST", "images/duplicate", Rule()),
+    ("POST", "images/assign-existing", Rule()),
+    # Stock footage
+    ("GET", "stock-footage/search", Rule()),
+    ("POST", rf"scenes/{S}/stock-footage", Rule(ai_edits=1, timeout=60)),
+    ("GET", "stock-footage/pending", Rule()),
+    ("POST", "stock-footage/link", Rule()),
+    ("POST", "stock-footage/approve", Rule(status="generating")),
+    ("POST", "stock-footage/reject", Rule(status="generating")),
+    # Voice, voiceovers, language, template
+    ("POST", rf"scenes/{S}/voiceover", Rule(timeout=60)),
+    # blog2video keeps the project's status during a voiceover delete; marking ours lets a reload resume its progress
+    # (voice-change-status reports it, kind "delete"), and the next status check sets it back.
+    ("POST", "delete-voiceover", Rule(status="voice_regenerating")),
+    ("POST", "change-voice", Rule(status="voice_regenerating")),
+    ("GET", "voice-change-status", Rule()),
+    ("POST", "change-language", Rule(status="language_regenerating")),
+    ("GET", "language-change-status", Rule()),
+    ("POST", "change-template-regenerate-layouts", Rule(uses_video=True, status="regenerating")),
+    ("GET", "template-change-status", Rule()),
+    # Refresh the script
+    ("POST", "regenerate-script", Rule(status="script_regenerating")),
+    ("GET", "regenerate-script-status", Rule()),
+    ("GET", "regenerate-script/preview", Rule()),
+    ("POST", "regenerate-script/verify", Rule()),
+    ("POST", "regenerate-script/regenerate", Rule()),
+    # AI chat editing ★
+    ("POST", "chat", Rule(ai_edits=1, premium="AI chat editing", timeout=120)),
+    ("GET", "chat/history", Rule(premium="AI chat editing")),
+    # Avatars ★ (blog2video charges the whole batch at authorize: 10 AI edits per scene)
+    ("POST", "avatar-batch/authorize", Rule(ai_edits=10, per_scene=True, premium="Avatars")),
+    ("POST", rf"scenes/{S}/avatar", Rule(premium="Avatars")),
+    ("GET", rf"scenes/{S}/avatar-status", Rule()),
+    ("DELETE", rf"scenes/{S}/avatar", Rule()),
+    ("POST", rf"scenes/{S}/avatar-matte", Rule(premium="Avatars")),
+    ("POST", "avatar-matte-all", Rule(premium="Avatars")),
+    ("POST", "avatar-retry-failed", Rule(premium="Avatars")),
+    ("GET", "avatar-progress", Rule()),
+    ("POST", "avatar-portrait", Rule(premium="Avatars", timeout=60)),
+    ("DELETE", "avatar-portrait", Rule()),
+    ("PATCH", rf"scenes/{S}/avatar-focus", Rule()),
+    ("PATCH", rf"scenes/{S}/avatar-appearance", Rule()),
+    # Render, download, frames
+    ("POST", "render", Rule(status="rendering")),
+    ("GET", "render-status", Rule()),
+    ("POST", "cancel-render", Rule()),
+    ("GET", "download-url", Rule()),
+    ("GET", "download", Rule(raw=True, timeout=120)),
+    ("GET", "download-studio", Rule(raw=True, premium="The Remotion source download", timeout=120)),
+    ("GET", "render-still", Rule(raw=True, timeout=60)),
+    ("POST", "render-stills", Rule(timeout=120)),
+]]
+
+
+def rule_for(method: str, path: str) -> Rule | None:
+    for m, pattern, rule in RULES:
+        if m == method and pattern.match(path):
+            return rule
+    return None
+
+
+async def _read_body(request: Request) -> tuple[dict | None, dict | None, list | None]:
+    """(json, form fields, files) from the browser's request."""
+    ctype = request.headers.get("content-type", "")
+    if ctype.startswith("multipart/form-data"):
+        form = await request.form()
+        data, files = {}, []
+        for key, value in form.multi_items():
+            if isinstance(value, UploadFile):
+                content = await value.read(MAX_FILE_BYTES + 1)
+                if len(content) > MAX_FILE_BYTES:
+                    raise HTTPException(413, "That file is too large.")
+                files.append((key, (value.filename or "file", content, value.content_type or
+                                    "application/octet-stream")))
+            else:
+                data[key] = value
+        return None, data, files
+    raw = await request.body()
+    if not raw:
+        return None, None, None
+    if len(raw) > MAX_JSON_BYTES:
+        raise HTTPException(413, "Request too large")
+    try:
+        return json.loads(raw), None, None
+    except ValueError:
+        raise HTTPException(400, "Send JSON") from None
+
+
+def _charge(ctx: Ctx, rule: Rule, body: dict | None, form: dict | None) -> int:
+    """Premium, references and counters, all before blog2video is called. Returns AI edits taken."""
+    plan = effective_plan(ctx.db, ctx.workspace)
+    if rule.premium:
+        video_limits.require_premium(ctx.db, ctx.workspace, rule.premium, plan)
+    refs = body if isinstance(body, dict) else (form or {})
+    with upstream():  # checking a template or voice may need blog2video's catalog
+        b2v_access.check_refs(ctx, refs, plan)
+    edits = rule.ai_edits
+    if rule.per_scene:
+        scenes = (body or {}).get("scene_ids") if isinstance(body, dict) else None
+        if not isinstance(scenes, list) or not scenes:
+            raise HTTPException(400, "Pick at least one scene")
+        edits *= len(scenes)
+    if edits:
+        video_limits.take(ctx.db, ctx.workspace, "ai_edits", edits, plan=plan)
+    if rule.uses_video and not video_quota.reserve(ctx.db, ctx.workspace.id):
+        if edits:
+            video_limits.give_back(ctx.db, ctx.workspace.id, "ai_edits", edits)
+        raise plan_limit_error(plan, "videos", "Switching the template uses a video, and you have none left.")
+    return edits
+
+
+@router.api_route("/{artifact_id}/p/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"])
+async def project_proxy(artifact_id: uuid.UUID, path: str, request: Request, ctx: Ctx = Depends(get_ctx),
+                        _: None = Depends(b2v_ready)):
+    path = path.strip("/")
+    rule = rule_for(request.method, path)
+    if rule is None:
+        raise HTTPException(404, "Not found")
+    a, vid, _row = b2v_access.video_or_404(ctx, artifact_id)
+    body, form, files = await _read_body(request)
+    edits = await run_in_threadpool(_charge, ctx, rule, body, form)
+    params = dict(request.query_params)
+
+    def call():
+        return b2v.project_call(request.method, vid, path, json=body, data=form, files=files or None,
+                                params=params or None, timeout=rule.timeout, raw=rule.raw)
+
+    try:
+        with upstream():
+            result = await run_in_threadpool(call)
+    except HTTPException:
+        if edits:
+            video_limits.give_back(ctx.db, ctx.workspace.id, "ai_edits", edits)
+        if rule.uses_video:
+            video_quota.unreserve(ctx.db, ctx.workspace.id)
+        raise
+    if rule.status:
+        store(ctx, a, status=rule.status)
+    if rule.raw:
+        content, ctype = result
+        return Response(content, media_type=ctype, headers={"Cache-Control": "no-store"})
+    return result

backend/app/routers/video_styles.py

@@ -0,0 +1,88 @@
+"""Custom video styles: writing guidance for the script, used on videos as custom:<id>.
+
+Styles are made on our one blog2video account, so b2v_styles records which workspace made each; only that
+workspace sees, uses, edits or deletes it. Built-in styles are read-only here, and "Your Style" (which learns from
+every workspace's edits) is never offered. The account-wide style selection, pin and built-in overrides are never
+touched (blog2video.DENIED).
+"""
+
+from typing import Literal
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+
+from app.auth import Ctx, get_ctx
+from app.models import B2VStyle
+from app.routers.videos import b2v_ready, upstream
+from app.services import b2v_access
+from app.services import blog2video as b2v
+
+router = APIRouter(prefix="/api/video-styles", tags=["videos"])
+
+
+class DraftIn(BaseModel):
+    prompt: str = Field(min_length=20, max_length=1000)
+
+
+class StyleIn(BaseModel):
+    name: str = Field(min_length=1, max_length=80)
+    guidance: str = Field(min_length=1, max_length=2000)
+    creation_method: Literal["manual", "ai"] = "manual"
+    source_prompt: str | None = Field(None, max_length=1000)
+
+
+class StylePatchIn(BaseModel):
+    name: str = Field(min_length=1, max_length=80)
+    guidance: str = Field(min_length=1, max_length=2000)
+    version: int = Field(ge=0)
+
+
+@router.get("")
+def list_styles(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    with upstream():
+        return b2v_access.visible_styles(ctx)
+
+
+@router.post("/ai-draft")
+def ai_draft(body: DraftIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """A name and guidance written from a description; nothing is saved."""
+    with upstream():
+        return b2v.request("POST", "/api/video-styles/ai-draft", json=body.model_dump(), timeout=90)
+
+
+def _out(s: dict) -> dict:
+    return {"id": s.get("id"), "custom_id": s.get("custom_id"), "name": s.get("name"), "guidance": s.get("guidance"),
+            "description": s.get("description"), "version": s.get("version"), "kind": "custom"}
+
+
+@router.post("", status_code=201)
+def create_style(body: StyleIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    with upstream():
+        made = b2v.request("POST", "/api/video-styles/custom", json=body.model_dump())
+    ctx.db.add(B2VStyle(b2v_style_id=int(made["custom_id"]), workspace_id=ctx.workspace.id, name=body.name))
+    ctx.db.commit()
+    return _out(made)
+
+
+@router.patch("/{style_id}")
+def update_style(style_id: int, body: StylePatchIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_style(ctx, style_id)
+    with upstream():
+        made = b2v.request("PATCH", f"/api/video-styles/custom/{style_id}", json=body.model_dump())
+    row.name = body.name
+    ctx.db.commit()
+    return _out(made)
+
+
+@router.delete("/{style_id}")
+def delete_style(style_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_style(ctx, style_id)
+    try:
+        with upstream():
+            b2v.request("DELETE", f"/api/video-styles/custom/{style_id}")
+    except HTTPException as e:
+        if e.status_code != 404:
+            raise
+    ctx.db.delete(row)
+    ctx.db.commit()
+    return {"ok": True}

backend/app/routers/video_templates.py

@@ -0,0 +1,277 @@
+"""Custom video templates: made from a website, a document or a description, then generated and edited.
+
+Templates are made on our one blog2video account, which has a small lifetime number of template slots (a delete
+does not give one back). b2v_templates records which workspace made each template; only that workspace sees, uses,
+edits or deletes it, and each workspace has its own share of slots and daily AI steps (video_limits).
+
+Create: extract a theme (/extract/url | /extract/doc | /extract/prompt) -> POST "" (uses a slot) -> /{id}/generate
+-> poll /{id}/generation-status until complete (the template becomes usable in the wizard) or error.
+Edit: /{id}/p/<path> -> /api/custom-templates/{id}/<path>, allowlisted in RULES.
+"""
+
+import json
+import re
+from dataclasses import dataclass
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Request, Response, UploadFile
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from starlette.concurrency import run_in_threadpool
+from starlette.datastructures import UploadFile as StarletteUpload
+
+from app.auth import Ctx, get_ctx
+from app.models import B2VTemplate, B2VVideo
+from app.routers.videos import b2v_ready, upstream
+from app.services import b2v_access, video_limits
+from app.services import blog2video as b2v
+from app.services.plans import effective_plan, plan_limit_error
+
+router = APIRouter(prefix="/api/video-templates", tags=["videos"])
+
+DOC_MAX_BYTES = 10 * 1024 * 1024
+LOGO_MAX_BYTES = 2 * 1024 * 1024
+AI_TIMEOUT = 120
+
+
+def _out(t: B2VTemplate) -> dict:
+    return {"id": t.b2v_template_id, "ref": f"custom_{t.b2v_template_id}", "name": t.name, "ready": t.ready,
+            "created_at": t.created_at.isoformat() if t.created_at else None}
+
+
+def _can_make(ctx: Ctx) -> None:
+    """Refuse early (before any AI work) when the workspace has no template slots left."""
+    plan = effective_plan(ctx.db, ctx.workspace)
+    limit = int(plan.video_limits.get("templates", 0))
+    if limit >= 0 and video_limits.used(ctx.db, ctx.workspace.id, "templates") >= limit:
+        raise plan_limit_error(plan, "video_limits.templates",
+                               "Your plan does not include custom templates." if limit == 0
+                               else f"You have made all {limit} custom templates your plan includes.")
+
+
+def _counted(ctx: Ctx, metric: str, call):
+    video_limits.take(ctx.db, ctx.workspace, metric)
+    try:
+        with upstream():
+            return call()
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, metric)
+        raise
+
+
+@router.get("")
+def list_templates(ctx: Ctx = Depends(get_ctx)):
+    limits = video_limits.report(ctx.db, ctx.workspace)["limits"]
+    return {"templates": [_out(t) for t in b2v_access.my_templates(ctx)],
+            "limits": {k: limits[k] for k in ("templates", "template_ai_daily")}}
+
+
+# 1. Extract a theme
+
+
+class ExtractUrlIn(BaseModel):
+    url: str = Field(min_length=1, max_length=2048)
+
+
+class ExtractPromptIn(BaseModel):
+    prompt: str = Field(min_length=15, max_length=5000)
+    name: str | None = Field(None, max_length=255)
+
+
+@router.post("/extract/url")
+def extract_from_url(body: ExtractUrlIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    if not re.match(r"https?://", body.url):
+        raise HTTPException(400, "Enter a link that starts with http:// or https://")
+    _can_make(ctx)
+    with upstream():
+        return b2v.request("POST", "/api/custom-templates/extract-theme", json=body.model_dump(), timeout=AI_TIMEOUT)
+
+
+@router.post("/extract/prompt")
+def extract_from_prompt(body: ExtractPromptIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    _can_make(ctx)
+    return _counted(ctx, "template_ai_daily", lambda: b2v.request(
+        "POST", "/api/custom-templates/extract-theme-from-prompt", json=body.model_dump(), timeout=AI_TIMEOUT))
+
+
+@router.post("/extract/doc")
+async def extract_from_doc(file: UploadFile = File(...), name: str = Form(""), ctx: Ctx = Depends(get_ctx),
+                           _: None = Depends(b2v_ready)):
+    data = await file.read(DOC_MAX_BYTES + 1)
+    if len(data) > DOC_MAX_BYTES:
+        raise HTTPException(400, "Keep the document under 10 MB.")
+    _can_make(ctx)
+    files = {"file": (file.filename or "brand.pdf", data, file.content_type or "application/octet-stream")}
+    return await run_in_threadpool(_counted, ctx, "template_ai_daily", lambda: b2v.request(
+        "POST", "/api/custom-templates/extract-theme-from-doc", data={"name": name[:255]}, files=files,
+        timeout=AI_TIMEOUT))
+
+
+# 2. Create (uses a slot) and 3. generate
+
+
+class CreateIn(BaseModel):
+    name: str = Field(min_length=1, max_length=255)
+    theme: dict
+    source_url: str | None = Field(None, max_length=2048)
+    logo_urls: list[str] | None = Field(None, max_length=20)
+    og_image: str | None = Field(None, max_length=2048)
+    screenshot_url: str | None = Field(None, max_length=2048)
+    reason: str | None = Field(None, max_length=2000)
+
+
+@router.post("", status_code=201)
+def create_template(body: CreateIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    made = _counted(ctx, "templates", lambda: b2v.request("POST", "/api/custom-templates",
+                                                          json=body.model_dump(exclude_none=True), timeout=60))
+    row = B2VTemplate(b2v_template_id=int(made["id"]), workspace_id=ctx.workspace.id, name=body.name[:255])
+    ctx.db.add(row)
+    ctx.db.commit()
+    return _out(row)
+
+
+@router.post("/{template_id}/generate")
+def generate(template_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    b2v_access.owned_template(ctx, template_id)
+    return _counted(ctx, "template_ai_daily", lambda: b2v.request(
+        "POST", f"/api/custom-templates/{template_id}/generate-code", timeout=60))
+
+
+@router.get("/{template_id}/generation-status")
+def generation_status(template_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_template(ctx, template_id)
+    with upstream():
+        s = b2v.request("GET", f"/api/custom-templates/{template_id}/generation-status") or {}
+    ready = s.get("status") == "complete"
+    if ready != row.ready:
+        row.ready = ready
+        ctx.db.commit()
+    return {**s, "ready": ready}
+
+
+@router.delete("/{template_id}")
+def delete_template(template_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """blog2video refuses (template_in_use) while any video on the account uses the template. We force it only
+    when every such video is this workspace's: another workspace's video must never lose its template."""
+    row = b2v_access.owned_template(ctx, template_id)
+    ref = f"custom_{template_id}"
+    try:
+        with upstream():
+            b2v.request("DELETE", f"/api/custom-templates/{template_id}")
+    except HTTPException as e:
+        if e.status_code == 404:
+            pass
+        elif e.status_code == 409:
+            others = ctx.db.scalar(select(B2VVideo.id).where(B2VVideo.template_ref == ref,
+                                                             B2VVideo.workspace_id != ctx.workspace.id).limit(1))
+            if others is not None:
+                raise HTTPException(409, "This template is in use and can not be deleted.") from None
+            with upstream():
+                b2v.request("DELETE", f"/api/custom-templates/{template_id}", params={"force": "true"})
+        else:
+            raise
+    ctx.db.delete(row)
+    ctx.db.commit()
+    return {"ok": True}  # the slot is not given back: blog2video's slots are lifetime
+
+
+# Editing: allowlisted proxy
+
+
+@dataclass(frozen=True)
+class Rule:
+    ai_edit: bool = False  # ★ one AI edit
+    metric: str | None = None  # another counter this uses (a lifetime slot, a daily AI step)
+    raw: bool = False
+
+
+K = r"(intro|outro|content_\d+)"  # scene keys
+RULES: list[tuple[str, re.Pattern, Rule]] = [(m, re.compile(f"^{p}$"), r) for m, p, r in [
+    ("GET", "", Rule()),
+    ("PUT", "", Rule()),
+    ("GET", "code", Rule()),
+    ("POST", "upload-logo", Rule()),
+    ("POST", f"scenes/{K}/ai-edit", Rule(ai_edit=True)),
+    ("GET", f"scenes/{K}/ai-edit/status", Rule()),
+    ("GET", "scene-drafts", Rule()),
+    ("GET", f"scenes/{K}/draft", Rule()),
+    ("POST", f"scenes/{K}/draft/apply", Rule()),
+    ("POST", f"scenes/{K}/draft/discard", Rule()),
+    ("PATCH", f"scenes/{K}/chart", Rule()),
+    ("PATCH", f"scenes/{K}/font-defaults", Rule()),
+    ("PATCH", "scenes/font-defaults", Rule()),
+    ("GET", "versions", Rule()),
+    ("POST", r"versions/\d+/rollback", Rule()),
+    ("POST", "regenerate-code", Rule(metric="templates")),  # uses a slot, like creating one
+    ("POST", "resume-generation", Rule()),
+    ("POST", "rating", Rule()),
+]]
+
+
+def _rule(method: str, path: str) -> Rule | None:
+    return next((r for m, p, r in RULES if m == method and p.match(path)), None)
+
+
+def _take(ctx: Ctx, rule: Rule) -> list[str]:
+    taken: list[str] = []
+    try:
+        if rule.ai_edit:
+            plan = video_limits.require_premium(ctx.db, ctx.workspace, "AI template editing")
+            video_limits.take(ctx.db, ctx.workspace, "ai_edits", plan=plan)
+            taken.append("ai_edits")
+        if rule.metric:
+            video_limits.take(ctx.db, ctx.workspace, rule.metric)
+            taken.append(rule.metric)
+    except HTTPException:
+        for metric in taken:
+            video_limits.give_back(ctx.db, ctx.workspace.id, metric)
+        raise
+    return taken
+
+
+@router.api_route("/{template_id}/p/{path:path}", methods=["GET", "POST", "PUT", "PATCH"])
+async def template_proxy(template_id: int, path: str, request: Request, ctx: Ctx = Depends(get_ctx),
+                         _: None = Depends(b2v_ready)):
+    path = path.strip("/")
+    rule = _rule(request.method, path)
+    if rule is None:
+        raise HTTPException(404, "Not found")
+    row = b2v_access.owned_template(ctx, template_id)
+    body = form = files = None
+    if request.headers.get("content-type", "").startswith("multipart/form-data"):
+        parsed = await request.form()
+        form, files = {}, []
+        for key, value in parsed.multi_items():
+            if isinstance(value, StarletteUpload):
+                content = await value.read(LOGO_MAX_BYTES + 1)
+                if len(content) > LOGO_MAX_BYTES:
+                    raise HTTPException(413, "Keep the file under 2 MB.")
+                files.append((key, (value.filename or "logo.png", content, value.content_type or "image/png")))
+            else:
+                form[key] = value
+    elif raw := await request.body():
+        try:
+            body = json.loads(raw)
+        except ValueError:
+            raise HTTPException(400, "Send JSON") from None
+    taken = await run_in_threadpool(_take, ctx, rule)
+
+    def call():
+        return b2v.request(request.method, f"/api/custom-templates/{template_id}/{path}".rstrip("/"), json=body,
+                           data=form, files=files or None, params=dict(request.query_params) or None,
+                           timeout=AI_TIMEOUT, raw=rule.raw)
+
+    try:
+        with upstream():
+            result = await run_in_threadpool(call)
+    except HTTPException:
+        for metric in taken:
+            video_limits.give_back(ctx.db, ctx.workspace.id, metric)
+        raise
+    if request.method == "PUT" and path == "" and isinstance(body, dict) and body.get("name"):
+        row.name = str(body["name"])[:255]
+        ctx.db.commit()
+    if rule.raw:
+        content, ctype = result
+        return Response(content, media_type=ctype)
+    return result
+

backend/app/routers/video_voices.py

@@ -0,0 +1,297 @@
+"""Voices for videos: the workspace's saved voices, the built-in library, custom voices (design, clone), and its
+Notestack voices (made on the Voice page; blog2video speaks with the same ElevenLabs account).
+
+"My voices" (user_saved_voices, at most MAX_SAVED_VOICES) lives only here: blog2video's saved-voice list is one list
+for the whole account.
+Custom voices are made on our blog2video account, so b2v_custom_voices records which workspace made each one;
+only that workspace can use, play or delete it. Designing, keeping, cloning and samples are premium (★) and come out
+of the workspace's own daily and total counters (video_limits).
+"""
+
+import logging
+from typing import Literal
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Response, UploadFile
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+
+from app.auth import Ctx, get_ctx
+from app.models import B2VCustomVoice, UserSavedVoice
+from app.routers.videos import b2v_ready, upstream
+from app.services import b2v_access, video_limits
+from app.services import blog2video as b2v
+from app.services.notestack_voices import notestack_voices
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/video-voices", tags=["videos"])
+
+CLONE_MAX_BYTES = 50 * 1024 * 1024
+STARTER_VOICES = 4  # a new workspace starts with this many free built-in voices saved
+MAX_SAVED_VOICES = 5  # "My voices": what step 3 of a new video offers
+
+
+def _labels(v: dict) -> dict:
+    return v.get("labels") or {}
+
+
+def _voice_out(v: UserSavedVoice, ours: set[str] = frozenset()) -> dict:
+    return {"voice_id": v.voice_id, "name": v.name, "preview_url": v.preview_url, "gender": v.gender,
+            "accent": v.accent, "premium": v.premium, "is_custom": v.is_custom,
+            "source": "notestack" if v.voice_id in ours else "blog2video"}
+
+
+def _room(ctx: Ctx) -> bool:
+    return len(_saved(ctx)) < MAX_SAVED_VOICES
+
+
+def _full() -> HTTPException:
+    return HTTPException(409, f"You can keep {MAX_SAVED_VOICES} voices. Remove one first.")
+
+
+def _library_out(v: dict, saved: set[str]) -> dict:
+    labels = _labels(v)
+    return {"voice_id": v["voice_id"], "name": (v.get("name") or "Voice").split(" - ")[0].strip(),
+            "description": v.get("description") or labels.get("description") or "", "preview_url": v.get("preview_url"),
+            "gender": labels.get("gender"), "accent": labels.get("accent"), "age": labels.get("age"),
+            "premium": v.get("plan") == "paid", "saved": v["voice_id"] in saved}
+
+
+def _save_builtin(ctx: Ctx, v: dict) -> UserSavedVoice:
+    labels = _labels(v)
+    row = UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=v["voice_id"],
+                         name=(v.get("name") or "Voice").split(" - ")[0].strip()[:255],
+                         preview_url=v.get("preview_url"),
+                         gender=labels.get("gender"), accent=labels.get("accent"), premium=v.get("plan") == "paid")
+    ctx.db.merge(row)
+    return row
+
+
+def _saved(ctx: Ctx) -> list[UserSavedVoice]:
+    return list(ctx.db.scalars(select(UserSavedVoice).where(UserSavedVoice.workspace_id == ctx.workspace.id)
+                               .order_by(UserSavedVoice.created_at)))
+
+
+@router.get("")
+def voices(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """My voices (for the wizard), the built-in library (to save from) and my custom voices."""
+    with upstream():
+        library = b2v.prebuilt_voices()
+    saved = _saved(ctx)
+    if not saved:
+        for v in [v for v in library if v.get("plan") != "paid" and v.get("voice_id")][:STARTER_VOICES]:
+            _save_builtin(ctx, v)
+        ctx.db.commit()
+        saved = _saved(ctx)
+    ids = {v.voice_id for v in saved}
+    custom = ctx.db.scalars(select(B2VCustomVoice).where(B2VCustomVoice.workspace_id == ctx.workspace.id)
+                            .order_by(B2VCustomVoice.created_at.desc()))
+    mine = notestack_voices(ctx.db, ctx.workspace.id)
+    ours = {v["voice_id"] for v in mine}
+    return {"saved": [_voice_out(v, ours) for v in saved], "max_saved": MAX_SAVED_VOICES,
+            "notestack": [{**v, "saved": v["voice_id"] in ids} for v in mine],
+            "library": [_library_out(v, ids) for v in library if v.get("voice_id")],
+            "custom": [{"id": c.b2v_custom_voice_id, "voice_id": c.voice_id, "name": c.name, "source": c.source,
+                        "preview_url": c.preview_url, "saved": c.voice_id in ids} for c in custom]}
+
+
+class SaveIn(BaseModel):
+    voice_id: str = Field(min_length=1, max_length=100)
+
+
+@router.post("/saved", status_code=201)
+def save_voice(body: SaveIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    if ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": body.voice_id}):
+        return _voice_out(ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": body.voice_id}))
+    if not _room(ctx):
+        raise _full()
+    custom = ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.voice_id == body.voice_id,
+                                                        B2VCustomVoice.workspace_id == ctx.workspace.id))
+    mine = next((v for v in notestack_voices(ctx.db, ctx.workspace.id) if v["voice_id"] == body.voice_id), None)
+    if mine:
+        # A Notestack voice: premium, like a custom voice. No preview link (the Voice page plays it).
+        video_limits.require_premium(ctx.db, ctx.workspace, "Custom voices")
+        row = ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=mine["voice_id"],
+                                          name=mine["name"][:255], premium=True, is_custom=True))
+        ctx.db.commit()
+        return _voice_out(row, {row.voice_id})
+    if custom:
+        row = ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=custom.voice_id, name=custom.name,
+                                          preview_url=custom.preview_url, premium=True, is_custom=True))
+    else:
+        with upstream():
+            v = next((v for v in b2v.prebuilt_voices() if v.get("voice_id") == body.voice_id), None)
+        if not v:
+            raise HTTPException(404, "Voice not found")
+        if v.get("plan") == "paid":
+            video_limits.require_premium(ctx.db, ctx.workspace, "This voice")
+        row = _save_builtin(ctx, v)
+    ctx.db.commit()
+    return _voice_out(row)
+
+
+@router.delete("/saved/{voice_id}")
+def unsave_voice(voice_id: str, ctx: Ctx = Depends(get_ctx)):
+    row = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": voice_id})
+    if not row:
+        raise HTTPException(404, "Voice not found")
+    ctx.db.delete(row)
+    ctx.db.commit()
+    return {"ok": True}
+
+
+# Design a voice ★: a description or options -> a few previews; keep one to make it a custom voice
+
+
+class DesignPromptIn(BaseModel):
+    prompt: str = Field(min_length=20, max_length=1000)
+
+
+class DesignPresetIn(BaseModel):
+    gender: str = Field("", max_length=30)
+    age: str = Field("", max_length=30)
+    persona: str = Field("", max_length=100)
+    speed: str = Field("", max_length=30)
+    accent: str = Field("", max_length=60)
+
+
+def _design(ctx: Ctx, path: str, body: dict) -> dict:
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Designing a voice")
+    video_limits.take(ctx.db, ctx.workspace, "voice_designs_daily", plan=plan)
+    try:
+        with upstream():
+            data = b2v.request("POST", path, json=body, timeout=90) or {}
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "voice_designs_daily")
+        raise
+    return {"previews": [{k: p.get(k) for k in ("generated_voice_id", "audio_base_64", "media_type", "duration_secs")}
+                         for p in data.get("previews") or []]}
+
+
+@router.post("/design/prompt")
+def design_from_prompt(body: DesignPromptIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    return _design(ctx, "/api/voices/design-from-prompt", body.model_dump())
+
+
+@router.post("/design/preset")
+def design_from_preset(body: DesignPresetIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    return _design(ctx, "/api/voices/design-from-preset", body.model_dump())
+
+
+class KeepIn(BaseModel):
+    generated_voice_id: str = Field(min_length=1, max_length=200)
+    source: Literal["prompt", "preset"]
+    name: str = Field(min_length=1, max_length=100)
+    prompt_text: str | None = Field(None, max_length=1000)
+    preview_url: str | None = Field(None, max_length=1000)
+
+
+def _record_custom(ctx: Ctx, made: dict, source: str) -> dict:
+    row = B2VCustomVoice(b2v_custom_voice_id=int(made["id"]), workspace_id=ctx.workspace.id,
+                         voice_id=made["voice_id"], name=(made.get("name") or "My voice")[:255], source=source,
+                         preview_url=made.get("preview_url"))
+    ctx.db.add(row)
+    saved = _room(ctx)  # kept in My voices only while there is room; otherwise added from the list later
+    if saved:
+        ctx.db.merge(UserSavedVoice(workspace_id=ctx.workspace.id, voice_id=row.voice_id, name=row.name,
+                                    preview_url=row.preview_url, premium=True, is_custom=True))
+    ctx.db.commit()
+    return {"id": row.b2v_custom_voice_id, "voice_id": row.voice_id, "name": row.name, "source": source,
+            "preview_url": row.preview_url, "saved": saved}
+
+
+def _make_custom(ctx: Ctx, source: str, send) -> dict:
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Custom voices")
+    video_limits.take(ctx.db, ctx.workspace, "custom_voices", plan=plan)
+    try:
+        with upstream():
+            made = send()
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "custom_voices")
+        raise
+    return _record_custom(ctx, made, source)
+
+
+@router.post("/custom", status_code=201)
+def keep_designed_voice(body: KeepIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """Keep one designed preview as a permanent custom voice."""
+    payload = {"voice_id": body.generated_voice_id, "source": "prompt" if body.source == "prompt" else "form",
+               "name": body.name, "prompt_text": body.prompt_text, "preview_url": body.preview_url}
+    return _make_custom(ctx, body.source,
+                        lambda: b2v.request("POST", "/api/voices/custom", json=payload, timeout=60))
+
+
+@router.post("/clone", status_code=201)
+async def clone_voice(name: str = Form(..., min_length=1, max_length=100), remove_background_noise: bool = Form(True),
+                      file: UploadFile = File(...), ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """Clone a voice from one audio or video file (up to 50 MB)."""
+    data = await file.read(CLONE_MAX_BYTES + 1)
+    if not data:
+        raise HTTPException(400, "The file is empty.")
+    if len(data) > CLONE_MAX_BYTES:
+        raise HTTPException(400, "The file must be under 50 MB.")
+    form = {"name": name, "remove_background_noise": "true" if remove_background_noise else "false"}
+    files = {"file": (file.filename or "voice.mp3", data, file.content_type or "application/octet-stream")}
+    return _make_custom(ctx, "clone",
+                        lambda: b2v.request("POST", "/api/voices/clone", data=form, files=files, timeout=180))
+
+
+@router.get("/custom/{custom_id}/preview")
+def custom_preview(custom_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_custom_voice(ctx, custom_id)
+    if row.preview_url:
+        return {"preview_url": row.preview_url, "ready": True}
+    with upstream():
+        result = b2v.request("GET", f"/api/voices/custom/{custom_id}/preview") or {}
+    if result.get("preview_url"):
+        row.preview_url = result["preview_url"]
+        saved = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": row.voice_id})
+        if saved:
+            saved.preview_url = row.preview_url
+        ctx.db.commit()
+    return {"preview_url": result.get("preview_url"), "ready": bool(result.get("ready"))}
+
+
+@router.delete("/custom/{custom_id}")
+def delete_custom(custom_id: int, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    row = b2v_access.owned_custom_voice(ctx, custom_id)
+    try:
+        with upstream():
+            b2v.request("DELETE", f"/api/voices/custom/{custom_id}")
+    except HTTPException as e:
+        if e.status_code != 404:
+            raise
+    saved = ctx.db.get(UserSavedVoice, {"workspace_id": ctx.workspace.id, "voice_id": row.voice_id})
+    if saved:
+        ctx.db.delete(saved)
+    ctx.db.delete(row)
+    ctx.db.commit()
+    video_limits.give_back(ctx.db, ctx.workspace.id, "custom_voices")
+    return {"ok": True}
+
+
+# Voice sample ★: a few seconds of the chosen voice with the chosen tuning
+
+
+class SampleIn(BaseModel):
+    voice_gender: Literal["female", "male"] = "female"
+    voice_accent: str = Field("american", max_length=30)
+    custom_voice_id: str | None = Field(None, max_length=100)
+    voice_emotion: str | None = Field(None, max_length=200)
+    video_style: str | None = Field(None, max_length=40)
+
+
+@router.post("/sample")
+def voice_sample(body: SampleIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "Voice samples")
+    payload = body.model_dump(exclude_none=True)
+    with upstream():  # checking the voice may need blog2video's catalog
+        b2v_access.check_refs(ctx, {k: v for k, v in payload.items() if k != "voice_emotion"}, plan)
+    video_limits.take(ctx.db, ctx.workspace, "voice_samples_daily", plan=plan)
+    try:
+        with upstream():
+            audio, ctype = b2v.request("POST", "/api/voice/preview", json=payload, timeout=60, raw=True)
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "voice_samples_daily")
+        raise
+    return Response(audio, media_type=ctype or "audio/mpeg", headers={"Cache-Control": "no-store"})

backend/app/routers/videos.py

@@ -0,0 +1,949 @@
+"""Videos, made by blog2video: the 3-step wizard (Project, Template, Voice), script review, status and delete.
+Editing after creation is in video_edit.py; voices, templates and styles have their own routers.
+
+The browser only talks to these routes; the backend calls blog2video with our account's API key, which reaches
+every video we ever made. So every route that takes a video first checks it belongs to the current workspace
+(b2v_access.owned_video: 404 otherwise), and every create has its template, style and voice checked (check_refs).
+
+A video is an Artifact(type="video") with content_json.provider == "blog2video", so it shows up in the Library and
+Studio like everything else, plus a b2v_videos row: the ownership and allowance ledger. Routes take our artifact id.
+
+Videos made through the old partner integration have no b2v_videos row. blog2video answers 404 for them now, so
+they are "legacy": we keep showing the preview/video links we stored and refuse edits.
+"""
+
+import json
+import logging
+import re
+import uuid
+from collections.abc import Callable
+from contextlib import contextmanager
+from typing import Literal
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from pydantic import BaseModel, Field, ValidationError, model_validator
+from sqlalchemy import select
+
+from app.auth import Ctx, get_ctx
+from app.config import settings
+from app.llm import run
+from app.llm.provider import focus_lm
+from app.llm.signatures import VideoFocusAngles
+from app.models import Artifact, B2VVideo, Chat, Document, Message, Notebook, Upload
+from app.routers.sources import is_locked
+from app.services import b2v_access, video_focus, video_limits, video_quota
+from app.services import blog2video as b2v
+from app.services.artifacts import serialize_artifact
+from app.services.plans import Plan, plan_limit_error
+from app.services.storage import storage
+from app.services.video_quota import sync_video_quota, video_usage
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/videos", tags=["videos"])
+
+MIN_CONTENT = 50
+MAX_CONTENT = 100_000
+MAX_LINKS = 10
+MAX_POSTS = 200  # a notebook's posts, combined into one video (the ingest SCAN_CAP)
+MAX_CHATS = 5  # notebook chats, combined into one video (the wizard's cap, as for posts)
+MAX_FILES = 5
+# Sent ahead of chat transcripts: blog2video only takes content, so this tells its script writer what it is reading.
+CHAT_CONTEXT = ("The text below is one or more conversations between a user and an AI assistant. Make the video about "
+                "the subject of these conversations: the questions the user asked and the answers and conclusions "
+                "reached. Present it "
+                "as a clear explainer for a general audience, in your own narration. Do not read it out as a dialogue, "
+                "and do not mention the chat, the user or the AI assistant.")
+FILE_MAX_BYTES = 5 * 1024 * 1024
+FILE_TYPES = {".pdf", ".docx", ".pptx", ".md", ".txt", ".vtt"}
+LOGO_MAX_BYTES = 2 * 1024 * 1024
+LOGO_TYPES = {"image/png", "image/jpeg", "image/webp", "image/svg+xml"}
+LANGUAGES = [("en", "English"), ("es", "Spanish"), ("fr", "French"), ("de", "German"), ("it", "Italian"),
+             ("pt", "Portuguese"), ("nl", "Dutch"), ("pl", "Polish"), ("hi", "Hindi"), ("ar", "Arabic"),
+             ("ja", "Japanese"), ("ko", "Korean"), ("zh", "Chinese"), ("tr", "Turkish"), ("ru", "Russian"),
+             ("id", "Indonesian")]
+
+# blog2video status -> our artifact status
+STATUS_MAP = {"failed": "failed", "error": "failed", "awaiting_stock_footage_review": "review",
+              "awaiting_script_review": "review", "rendering": "rendering"}
+# blog2video's statuses while an edit job runs on a finished video, kept on the artifact as they are so the list and
+# the editor can tell them from first generation: regenerating is a template switch (its relayout).
+JOB_STATUSES = {"regenerating", "voice_regenerating", "language_regenerating", "script_regenerating"}
+# Statuses the video list re-checks with blog2video, in case the work ended while nobody was watching.
+BUSY_STATUSES = JOB_STATUSES | {"generating", "rendering"}
+
+
+def b2v_ready(ctx: Ctx = Depends(get_ctx)) -> None:
+    if not b2v.configured():
+        raise HTTPException(503, {"code": "video_not_configured", "message": "Video is not set up yet."})
+    sync_video_quota(ctx.db, ctx.workspace)
+
+
+@contextmanager
+def upstream():
+    """blog2video errors -> our HTTP errors. Problems with our own blog2video account (out of videos, key or plan)
+    are not the user's: they get "temporarily unavailable" and ops get an ALERT log line."""
+    try:
+        yield
+    except b2v.Denied:
+        raise HTTPException(404, "Not found") from None
+    except b2v.NotFound as e:
+        raise HTTPException(404, str(e)) from None  # e.g. "Scene not found": the editor reloads
+    except (b2v.Busy, b2v.TemplateInUse) as e:
+        raise HTTPException(e.status, str(e)) from None
+    except b2v.BadRequest as e:
+        raise HTTPException(400, str(e)) from None
+    except b2v.B2VError as e:
+        raise HTTPException(e.status if e.status == 503 else 502, str(e)) from None
+
+
+ROW_FIELDS = {"video_url", "preview_url", "title"}
+
+
+def store(ctx: Ctx, a: Artifact, row: B2VVideo | None = None, **fields) -> None:
+    """Merge fields into content_json (and status), and the reference fields into the video's row, committing only
+    when something changed."""
+    if row is not None:
+        for key in ROW_FIELDS & fields.keys():
+            if fields[key] is not None and getattr(row, key) != fields[key]:
+                setattr(row, key, fields[key])
+                ctx.db.commit()
+    content = dict(a.content_json or {})
+    status = fields.pop("status", None)
+    changed = {k: v for k, v in fields.items() if v is not None and content.get(k) != v}
+    if changed or (status and status != a.status):
+        a.content_json = {**content, **changed}
+        if status:
+            a.status = status
+        ctx.db.commit()
+
+
+def sync_status(ctx: Ctx, a: Artifact, row: B2VVideo, s: dict) -> None:
+    raw = str(s.get("status") or "")
+    video_quota.record_status(ctx.db, row, "failed" if s.get("error") and raw not in STATUS_MAP else raw)
+    if s.get("error") or raw in STATUS_MAP:
+        status = STATUS_MAP.get(raw, "failed")
+    elif raw in JOB_STATUSES:
+        status = raw
+    elif s.get("ready") or raw in {"generated", "done"}:
+        status = "ready"
+    else:
+        status = "generating"
+    store(ctx, a, row, status=status, b2v_status=raw or None, step=s.get("step"), video_url=s.get("video_url"),
+          error=s.get("error"))
+
+
+# The wizard's options (every field of blog2video's 3 steps)
+
+
+class VideoOptions(BaseModel):
+    # Step 1: Project (script review is always off: blog2video goes straight to the video)
+    stock_footage_enabled: bool = True
+    aspect_ratio: Literal["landscape", "portrait"] = "landscape"
+    video_length: Literal["short", "medium", "detailed", "more_detailed"] = "short"
+    logo_upload_id: uuid.UUID | None = None  # a file uploaded through /api/storage/uploads
+    logo_position: Literal["bottom_right", "bottom_left", "top_left", "top_right"] = "bottom_right"
+    logo_opacity: float = Field(0.9, ge=0.1, le=1.0)
+    # Step 2: Template
+    template: str = Field("default", max_length=100)
+    video_style: str = Field("auto", max_length=40)
+    accent_color: str | None = Field(None, pattern=r"^#[0-9a-fA-F]{6}$")
+    bg_color: str | None = Field(None, pattern=r"^#[0-9a-fA-F]{6}$")
+    text_color: str | None = Field(None, pattern=r"^#[0-9a-fA-F]{6}$")
+    # Step 3: Voice
+    content_language: str | None = Field(None, max_length=10)  # None = detect from the content
+    voice_gender: Literal["female", "male", "none"] = "female"
+    voice_accent: str = Field("american", max_length=30)
+    custom_voice_id: str | None = Field(None, max_length=100)
+    voice_emotion: str | None = Field(None, max_length=200)  # ["<expressiveness>","<speed>","<emotion>",...]
+    bgm_track_id: str | None = Field(None, max_length=100)
+    bgm_volume: float = Field(0.10, ge=0, le=1)
+
+    def payload(self) -> dict:
+        """The fields blog2video takes, as it names them."""
+        # Only the wizard's own fields: a subclass (VideoCreateIn) adds the source, which is sent separately.
+        data = self.model_dump(include=set(VideoOptions.model_fields) - {"logo_upload_id"}, exclude_none=True,
+                               mode="json")
+        data["script_review_enabled"] = False
+        if self.voice_gender == "none":
+            data.pop("custom_voice_id", None)
+            data.pop("voice_emotion", None)
+        if not self.bgm_track_id:
+            data.pop("bgm_volume", None)
+        return data
+
+
+class FocusIn(BaseModel):
+    # A source from the workspace: exactly one of these. document_ids are a notebook's ticked posts, combined into one
+    # video; chat_ids are notebook chats, sent as their transcripts (combined too).
+    document_id: uuid.UUID | None = None
+    document_ids: list[uuid.UUID] | None = Field(None, min_length=1, max_length=MAX_POSTS)
+    chat_ids: list[uuid.UUID] | None = Field(None, min_length=1, max_length=MAX_CHATS)
+    notebook_id: uuid.UUID | None = None  # names a combined video after its notebook
+
+    @model_validator(mode="after")
+    def one_source(self):
+        if sum(x is not None for x in (self.document_id, self.document_ids, self.chat_ids)) != 1:
+            raise ValueError("Pick one source: a notebook, a post or chats")
+        return self
+
+
+class VideoCreateIn(VideoOptions):
+    # Source: exactly one of these (the first three as in FocusIn).
+    document_id: uuid.UUID | None = None
+    document_ids: list[uuid.UUID] | None = Field(None, min_length=1, max_length=MAX_POSTS)
+    chat_ids: list[uuid.UUID] | None = Field(None, min_length=1, max_length=MAX_CHATS)
+    url: str | None = Field(None, max_length=2000)
+    content: str | None = Field(None, max_length=MAX_CONTENT)
+    title: str | None = Field(None, max_length=300)
+    notebook_id: uuid.UUID | None = None  # names a combined video after its notebook
+    # One of the suggested focus topics (/focus-topics): the video is mainly about it. None = the material as a whole.
+    focus: str | None = Field(None, max_length=200)
+    focus_detail: str | None = Field(None, max_length=400)  # the topic's description: what the video should cover
+    # Or the user's own topic, in their words: followed as far as the material supports it (instead of `focus`).
+    focus_prompt: str | None = Field(None, max_length=500)
+
+    @model_validator(mode="after")
+    def one_source(self):
+        if sum(x is not None for x in (self.document_id, self.document_ids, self.url, self.content, self.chat_ids)) != 1:
+            raise ValueError("Pick one source: a notebook, a post, chats, a link or pasted text")
+        if self.document_ids and len(self.document_ids) == 1:
+            self.document_id, self.document_ids = self.document_ids[0], None
+        return self
+
+    @model_validator(mode="after")
+    def one_focus(self):
+        self.focus_prompt = re.sub(r"\s+", " ", self.focus_prompt or "").strip() or None
+        if self.focus_prompt and (self.focus or "").strip():
+            raise ValueError("Pick a suggested topic or write your own, not both")
+        return self
+
+
+class VideoBatchIn(VideoOptions):
+    urls: list[str] = Field(min_length=1, max_length=MAX_LINKS)
+
+
+def _not_indexed(count: int) -> HTTPException:
+    return HTTPException(400, f"{count} of these posts {'is' if count == 1 else 'are'} not indexed on your plan. "
+                              "Untick them or upgrade to index your whole archive.")
+
+
+def _combined(ctx: Ctx, body: FocusIn | VideoCreateIn, limit: int) -> tuple[str, str]:
+    """Several posts as one text, oldest first, each given an equal share so none is cut off entirely."""
+    ids = set(body.document_ids or [])
+    docs = list(ctx.db.scalars(select(Document).where(Document.id.in_(ids),
+                                                      Document.workspace_id == ctx.workspace.id)))
+    if len(docs) != len(ids):
+        raise HTTPException(404, "Post not found")
+    locked = sum(is_locked(d) for d in docs)
+    if locked:
+        raise _not_indexed(locked)
+    docs.sort(key=lambda d: (d.published_at is None, d.published_at.timestamp() if d.published_at else 0))
+    share = limit // len(docs)
+    text = "\n\n".join(f"# {d.title}\n\n{(d.clean_text or '').strip()}"[:share] for d in docs)
+    nb = ctx.db.scalar(select(Notebook).where(Notebook.id == body.notebook_id,
+                                              Notebook.workspace_id == ctx.workspace.id)) if body.notebook_id else None
+    return (nb.title if nb else f"{docs[0].title} + {len(docs) - 1} more"), text
+
+
+def _cite_free(text: str) -> str:
+    """Citation markers ([1], [2]) point at the notebook's posts, which blog2video never sees."""
+    return re.sub(r"\s*\[\d+\]", "", text).strip()
+
+
+def _load_chats(ctx: Ctx, ids: list[uuid.UUID]) -> list[tuple[Chat, list[Message]]]:
+    """This workspace's chats, oldest first, each with its messages in order. 404 if any is not ours."""
+    chats = list(ctx.db.scalars(select(Chat).where(Chat.id.in_(set(ids)), Chat.workspace_id == ctx.workspace.id)
+                                .order_by(Chat.created_at)))
+    if len(chats) != len(set(ids)):
+        raise HTTPException(404, "Chat not found")
+    msgs = ctx.db.scalars(select(Message).where(Message.chat_id.in_([c.id for c in chats]))
+                          .order_by(Message.created_at)).all()
+    return [(c, [m for m in msgs if m.chat_id == c.id]) for c in chats]
+
+
+def _chat_title(chat: Chat, msgs: list[Message]) -> str:
+    return chat.title or next((m.content for m in msgs if m.role == "user"), "")[:80] or "Chat"
+
+
+def _chats(ctx: Ctx, ids: list[uuid.UUID], limit: int) -> tuple[str, str]:
+    """Chats' turns as one text, each chat given an equal share. Over its share, a chat's oldest turns go so its
+    conclusion stays. Several chats are headed by their titles."""
+    loaded = _load_chats(ctx, ids)
+    share = limit // len(loaded)
+    parts = []
+    for chat, msgs in loaded:
+        if not any(m.role == "assistant" for m in msgs):
+            raise HTTPException(400, f'"{_chat_title(chat, msgs)}" has no answers yet')
+        turns = [f"{'User' if m.role == 'user' else 'Assistant'}: {t}" for m in msgs if (t := _cite_free(m.content))]
+        head = f"# {_chat_title(chat, msgs)}\n\n" if len(loaded) > 1 else ""
+        size = len(head) + sum(len(t) + 2 for t in turns)
+        while len(turns) > 1 and size > share:
+            size -= len(turns.pop(0)) + 2
+        parts.append(head + "\n\n".join(turns))
+    first = _chat_title(*loaded[0])
+    return (first if len(loaded) == 1 else f"{first} + {len(loaded) - 1} more"), "\n\n".join(parts)
+
+
+def _doc(ctx: Ctx, document_id: uuid.UUID) -> Document:
+    doc = ctx.db.scalar(select(Document).where(Document.id == document_id, Document.workspace_id == ctx.workspace.id))
+    if not doc:
+        raise HTTPException(404, "Post not found")
+    if is_locked(doc):
+        raise _not_indexed(1)
+    return doc
+
+
+def _source_text(ctx: Ctx, body: FocusIn | VideoCreateIn, limit: int = MAX_CONTENT) -> tuple[str, str]:
+    """A workspace source (posts, a chat, one post) or pasted text as a title and one text."""
+    if body.document_ids:
+        return _combined(ctx, body, limit)
+    if body.chat_ids:
+        return _chats(ctx, body.chat_ids, limit)
+    if body.document_id:
+        doc = _doc(ctx, body.document_id)
+        return doc.title, (doc.clean_text or "")[:limit]
+    return getattr(body, "title", None) or "", getattr(body, "content", None) or ""
+
+
+def _instructions(body: VideoCreateIn) -> str:
+    """What blog2video's script writer is told ahead of the material: what a chat is, and the focus picked or written
+    by the user (worded for the house style's depth). Empty when neither applies."""
+    parts = [CHAT_CONTEXT] if body.chat_ids else []
+    if prompt := (body.focus_prompt or "").replace('"', "'"):
+        depth = {"short": " Make it a brief overview.", "medium": " Make it a deep dive."}
+        parts.append(f'The user wants this video to focus on: "{prompt}". Follow it only as far as the material below '
+                     "supports it: use what the material says about it and leave the rest out. If the material does "
+                     "not cover it, ignore this request and make a general video about the material."
+                     + depth.get(b2v_access.house_length(body.video_style), ""))
+    elif focus := (body.focus or "").strip():
+        detail = re.sub(r"\s+", " ", body.focus_detail or "").strip().rstrip(".")
+        cover = f" What to cover: {detail}." if detail else ""
+        length = b2v_access.house_length(body.video_style)
+        if length == "short":
+            parts.append(f'The main focus of this video is one topic only: "{focus}".{cover} Make it an overview of '
+                         "that topic: cover just the parts of the material about it, briefly, and leave the rest out.")
+        elif length == "medium":
+            parts.append(f'The main focus of this video is one topic only: "{focus}".{cover} Make it a deep dive into '
+                         "that topic: explore it in depth using the parts of the material about it, and leave the rest "
+                         "out.")
+        else:
+            parts.append(f'The main focus of this video is: "{focus}".{cover} Leave out parts of the material not '
+                         "about it.")
+    return " ".join(parts)
+
+
+def _source(ctx: Ctx, body: VideoCreateIn) -> tuple[dict, str]:
+    """The blog2video source fields and a title for our artifact."""
+    if body.url:
+        if not re.match(r"https?://", body.url):
+            raise HTTPException(400, "Enter a link that starts with http:// or https://")
+        return {"url": body.url}, body.title or body.url
+    if body.document_id and not (body.focus or body.focus_prompt):
+        doc = _doc(ctx, body.document_id)
+        if re.match(r"https?://", doc.url or ""):
+            return {"url": doc.url, "title": doc.title[:255]}, doc.title
+        # Uploaded files have no public link (upload://name): their text is sent instead (below). So is any post
+        # given a focus, which goes in front of the text.
+    with upstream():  # the focus wording needs the house styles
+        head = _instructions(body)
+    title, text = _source_text(ctx, body, MAX_CONTENT - len(head) - 10)
+    if body.content is not None and not title.strip():
+        raise HTTPException(400, "Give the pasted text a title")
+    text = text.strip()
+    if len(text) < MIN_CONTENT:
+        raise HTTPException(400, f"Add at least {MIN_CONTENT} characters of text")
+    content = f"{head}\n\n---\n\n{text}" if head else text
+    return {"content": content[:MAX_CONTENT], "title": title[:255]}, title
+
+
+def _metadata(ctx: Ctx, row: B2VVideo, **extra) -> dict:
+    """Sent with every create, and returned by blog2video: ties the video back to us from its side too."""
+    return {"workspace_id": str(ctx.workspace.id), "user_id": str(ctx.user.id), "video_ref": str(row.id), **extra}
+
+
+def _check(ctx: Ctx, options: VideoOptions) -> tuple[dict, Plan]:
+    payload = options.payload()
+    with upstream():  # checking a template or voice may need blog2video's catalog
+        # A house style decides the length, whatever the client sent (before the checks, which gate some lengths).
+        if length := b2v_access.house_length(payload.get("video_style")):
+            payload["video_length"] = length
+        plan = b2v_access.check_refs(ctx, payload)
+    accent = (ctx.workspace.brand_json or {}).get("accent")
+    if plan.brand_kit and accent and "accent_color" not in payload:
+        payload["accent_color"] = accent
+    return payload, plan
+
+
+def _logo(ctx: Ctx, upload_id: uuid.UUID | None) -> tuple[str, str, bytes] | None:
+    if not upload_id:
+        return None
+    upload = ctx.db.scalar(select(Upload).where(Upload.id == upload_id, Upload.workspace_id == ctx.workspace.id))
+    if not upload or upload.status != "complete" or upload.content_type not in LOGO_TYPES:
+        raise HTTPException(400, "The logo must be a PNG, JPG, WebP or SVG.")
+    data = storage.get_bytes(upload.key)
+    if len(data) > LOGO_MAX_BYTES:
+        raise HTTPException(400, "The logo must be under 2 MB.")
+    return upload.filename, upload.content_type, data
+
+
+def _start(ctx: Ctx, plan: Plan, title: str, aspect_ratio: str, template: str, created_via: str,
+           call: Callable[[B2VVideo], int], logo: tuple[str, str, bytes] | None = None,
+           document_id: uuid.UUID | None = None, source_url: str | None = None) -> Artifact:
+    """Reserve one video, record it, ask blog2video for it (call returns its id), refund if that fails."""
+    if not video_quota.reserve(ctx.db, ctx.workspace.id):
+        usage = video_usage(ctx.db, ctx.workspace)
+        raise plan_limit_error(plan, "videos",
+                               f"You have made {usage['used']} of {usage['limit']} videos this period.")
+    try:
+        artifact = Artifact(workspace_id=ctx.workspace.id, type="video", status="generating", document_id=document_id,
+                            content_json={"provider": "blog2video", "title": title[:300],
+                                          "aspect_ratio": aspect_ratio})
+        ctx.db.add(artifact)
+        ctx.db.flush()
+        row = B2VVideo(workspace_id=ctx.workspace.id, user_id=ctx.user.id, artifact_id=artifact.id,
+                       created_via=created_via, template_ref=template, title=title[:300], source_url=source_url,
+                       aspect_ratio=aspect_ratio,
+                       # Keys are unique across our whole blog2video account, so they start with the workspace id.
+                       idempotency_key=f"{ctx.workspace.id}:{uuid.uuid4()}" if created_via == "v1" else None)
+        ctx.db.add(row)
+        ctx.db.commit()
+    except Exception:
+        ctx.db.rollback()
+        video_quota.unreserve(ctx.db, ctx.workspace.id)
+        raise
+    try:
+        with upstream():
+            vid = call(row)
+    except HTTPException:
+        # Refused, or no answer after every retry: the user gets the video back.
+        video_quota.refund(ctx.db, row, "failed")
+        ctx.db.delete(artifact)
+        ctx.db.commit()
+        raise
+    row.b2v_video_id, row.status = vid, "queued"
+    ctx.db.commit()
+    store(ctx, artifact, row, b2v_video_id=vid, b2v_status="queued")
+    if logo:
+        try:
+            b2v.upload_logo(vid, *logo)
+        except b2v.B2VError:
+            log.warning("logo upload failed for video artifact %s", artifact.id)  # the video is made without it
+    return artifact
+
+
+@router.post("", status_code=201)
+def create_video(body: VideoCreateIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """From a link, pasted text or one of the workspace's posts: POST /api/v1/videos, which starts generating."""
+    source, title = _source(ctx, body)
+    payload, plan = _check(ctx, body)
+    logo = _logo(ctx, body.logo_upload_id)
+
+    def call(row: B2VVideo) -> int:
+        # Retried with the same key on no answer: blog2video returns the same video, charged once.
+        created = b2v.create_video({**source, **payload, "external_user_id": str(ctx.workspace.id),
+                                    "metadata": _metadata(ctx, row, artifact_id=str(row.artifact_id),
+                                                          document_id=str(body.document_id) if body.document_id
+                                                          else None,
+                                                          document_ids=[str(d) for d in body.document_ids or []]
+                                                          or None,
+                                                          chat_ids=[str(c) for c in body.chat_ids or []] or None)},
+                                   row.idempotency_key)
+        return int(created["video_id"])
+
+    a = _start(ctx, plan, title, body.aspect_ratio, body.template, "v1", call, logo, body.document_id,
+               source_url=source.get("url"))
+    return serialize_artifact(a)
+
+
+def _excerpt(text: str | None, limit: int) -> str:
+    """The start of a text, cut on a word boundary."""
+    text = re.sub(r"\s+", " ", text or "").strip()
+    if len(text) <= limit:
+        return text
+    return text[:limit].rsplit(" ", 1)[0] + "..."
+
+
+def _focus_material(ctx: Ctx, body: FocusIn) -> tuple[dict[str, str], list[Document]]:
+    """What the focus suggestions read, per post or chat (by id): each post's title and the start of its text, or a
+    chat's title and first exchange. A little text, so a vague title or an untitled chat still says what it is about.
+    Also the posts themselves (none for chats). Checked like a create (another workspace's source 404s, locked posts
+    400)."""
+    if body.chat_ids:
+        loaded = _load_chats(ctx, body.chat_ids)
+        answer_len = 600 if len(loaded) == 1 else 300
+        material = {}
+        for chat, msgs in loaded:
+            question = next((m.content for m in msgs if m.role == "user"), "")
+            answer = next((m.content for m in msgs if m.role == "assistant"), "")
+            parts = [chat.title or "", _excerpt(question, 300), _excerpt(_cite_free(answer), answer_len)]
+            if item := "\n".join(p for p in parts if p):
+                material[str(chat.id)] = item
+        return material, []
+    ids = set(body.document_ids or [body.document_id])
+    docs = list(ctx.db.scalars(select(Document).where(Document.id.in_(ids),
+                                                      Document.workspace_id == ctx.workspace.id)))
+    if len(docs) != len(ids):
+        raise HTTPException(404, "Post not found")
+    if locked := sum(is_locked(d) for d in docs):
+        raise _not_indexed(locked)
+    docs.sort(key=lambda d: d.published_at or d.created_at, reverse=True)
+    each = 800 if len(docs) == 1 else 400
+    items = {str(d.id): "\n".join(p for p in (d.title or "", _excerpt(d.clean_text, each)) if p) for d in docs}
+    return {k: v for k, v in items.items() if v}, docs
+
+
+@router.post("/focus-topics")
+def focus_topics(body: FocusIn, ctx: Ctx = Depends(get_ctx)):
+    """Up to three topics a video from this source could focus on: the topics the workspace already has for it,
+    shown as they are (untagged posts are tagged on demand; a chat's are the cited posts' topics). The AI writes them
+    only when there are none. Asked for and shown on the wizard's step 1, once the source is chosen."""
+    material, docs = _focus_material(ctx, body)
+    if not material:
+        return {"topics": []}
+    ws = ctx.workspace.id
+    if body.chat_ids:
+        cited, docs = video_focus.chat_citations(ctx.db, ws, body.chat_ids)
+        sources = {chat: cited.get(chat, {}) for chat in material}
+    else:
+        sources = {str(d.id): {d.id: 1.0} for d in docs}
+    video_focus.ensure_tags(ctx.db, ws, docs)
+    if cards := video_focus.pick_cards(video_focus.build_pool(ctx.db, ws, sources, docs)):
+        return {"topics": [{"title": c.name, "description": c.summary} for c in cards]}
+    items = list(material.values())[:FOCUS_ITEMS]
+    topics: list[dict] = []
+    # One retry when the answer has fewer than 3 usable topics (a placeholder for every title, repeats).
+    for retry in (False, True):
+        out = run.predict(VideoFocusAngles, db=ctx.db, workspace_id=ws, lm=focus_lm(retry), items=items,
+                          candidate_tags=[], avoid_titles=[])
+        _add_topics(topics, out.get("topics"))
+        if len(topics) >= 3:
+            break
+    return {"topics": topics[:3]}
+
+
+FOCUS_ITEMS = 5  # posts or chats the AI reads when there are no topics to show
+FOCUS_PLACEHOLDERS = {"title", "topic", "description", "summary", "name", "angle", "focus"}
+
+
+def _add_topics(topics: list[dict], raw) -> None:
+    """Add the model's usable topics to `topics` (as {title, description}): a real title, not seen before."""
+    for t in raw or []:
+        if not isinstance(t, dict):
+            continue
+        title = str(t.get("topic") or t.get("title") or "").strip().strip(".").strip()[:120]
+        description = re.sub(r"\s+", " ", str(t.get("summary") or t.get("description") or "")).strip()[:300]
+        if not title or title.lower() in FOCUS_PLACEHOLDERS:
+            continue
+        if title.lower() not in {x["title"].lower() for x in topics}:
+            topics.append({"title": title, "description": description})
+
+
+@router.post("/batch", status_code=201)
+def create_videos(body: VideoBatchIn, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """Multi-link: one video per link, each charged and keyed on its own. Background music is single-video only."""
+    urls = [u.strip() for u in body.urls if re.match(r"https?://\S+", u.strip())]
+    if not urls:
+        raise HTTPException(400, "Enter at least one link that starts with http:// or https://")
+    options = body.model_copy(update={"bgm_track_id": None})
+    payload, plan = _check(ctx, options)
+    logo = _logo(ctx, body.logo_upload_id)
+    made: list[dict] = []
+    for url in urls:
+        def call(row: B2VVideo, url=url) -> int:
+            created = b2v.create_video({"url": url, **payload, "external_user_id": str(ctx.workspace.id),
+                                        "metadata": _metadata(ctx, row, artifact_id=str(row.artifact_id))},
+                                       row.idempotency_key)
+            return int(created["video_id"])
+
+        try:
+            made.append(serialize_artifact(_start(ctx, plan, url, body.aspect_ratio, body.template, "v1", call,
+                                                  logo, source_url=url)))
+        except HTTPException as e:
+            if not made:
+                raise
+            # Keep what was made; say where it stopped (usually the allowance ran out).
+            detail = e.detail if isinstance(e.detail, str) else (e.detail or {}).get("message")
+            made.append({"error": detail, "url": url})
+            break
+    return made
+
+
+@router.post("/upload", status_code=201)
+async def create_from_files(files: list[UploadFile] = File(...), options: str = Form("{}"),
+                            ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """From up to 5 documents (pdf, docx, pptx, md, txt, vtt; 5 MB each): blog2video parses them itself.
+    `options` is the wizard's VideoOptions as JSON."""
+    try:
+        opts = VideoOptions.model_validate(json.loads(options or "{}"))
+    except (ValueError, ValidationError) as e:
+        raise HTTPException(422, str(e)[:500]) from None
+    if not files or len(files) > MAX_FILES:
+        raise HTTPException(400, f"Add 1 to {MAX_FILES} files.")
+    parts: list[tuple[str, bytes, str]] = []
+    for f in files:
+        name = f.filename or "document"
+        if not any(name.lower().endswith(ext) for ext in FILE_TYPES):
+            raise HTTPException(400, f"{name}: use PDF, DOCX, PPTX, MD, TXT or VTT.")
+        data = await f.read(FILE_MAX_BYTES + 1)
+        if len(data) > FILE_MAX_BYTES:
+            raise HTTPException(400, f"{name} is over 5 MB.")
+        parts.append((name, data, f.content_type or "application/octet-stream"))
+    payload, plan = _check(ctx, opts)
+    logo = _logo(ctx, opts.logo_upload_id)
+    title = parts[0][0].rsplit(".", 1)[0] if len(parts) == 1 else f"{len(parts)} documents"
+    form = {k: (str(v).lower() if isinstance(v, bool) else str(v)) for k, v in payload.items()}
+
+    def call(row: B2VVideo) -> int:
+        project = b2v.upload_project({**form, "name": title[:255]}, parts)
+        pid = int(project["id"])
+        try:
+            b2v.generate(pid)
+        except b2v.B2VError:
+            try:
+                b2v.delete_project(pid)
+            except b2v.B2VError:
+                log.warning("could not remove blog2video project %s after generate failed", pid)
+            raise
+        return pid
+
+    a = _start(ctx, plan, title, opts.aspect_ratio, opts.template, "upload", call, logo)
+    return serialize_artifact(a)
+
+
+# Read
+
+
+@router.get("/config")
+def video_config(ctx: Ctx = Depends(get_ctx)):
+    return {"configured": b2v.configured(), **video_limits.report(ctx.db, ctx.workspace)}
+
+
+@router.get("/quota")
+def quota(ctx: Ctx = Depends(get_ctx)):
+    return video_usage(ctx.db, ctx.workspace)
+
+
+def _with_posters(t: dict) -> dict:
+    """Poster images for the template picker. Built-in templates have baked posters on blog2video's web app (a few
+    have none; the picker then shows the template's colors); designer templates carry their own image."""
+    if t.get("preview_image_url") and not t.get("preview_url"):
+        return {**t, "preview_url": t["preview_image_url"]}
+    if t.get("preview_url") or not t.get("id") or str(t["id"]).startswith("crafted_"):
+        return t
+    base = f"{settings.b2v_app_url.rstrip('/')}/template-posters/{t['id']}"
+    return {**t, "preview_url": f"{base}.webp", "preview_portrait_url": f"{base}-portrait.webp"}
+
+
+@router.get("/catalog")
+def catalog(ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    """What the wizard offers this workspace: built-in and designer templates, its own ready custom templates,
+    built-in and its own styles, music, languages. Nothing another workspace made."""
+    with upstream():
+        builtin = b2v.builtin_templates()
+        try:
+            crafted = b2v.crafted_templates()
+        except b2v.B2VError:
+            crafted = []
+        mine = [{"id": f"custom_{t.b2v_template_id}", "name": t.name, "custom": True}
+                for t in b2v_access.my_templates(ctx, ready_only=True)]
+        styles = b2v_access.visible_styles(ctx)
+        music = b2v.music_tracks()
+    return {"templates": [_with_posters(t) for t in builtin if isinstance(t, dict)],
+            "crafted_templates": [_with_posters(t) for t in crafted if isinstance(t, dict)],
+            "my_templates": mine, "video_styles": styles,
+            "music": music, "languages": [{"code": c, "name": n} for c, n in LANGUAGES]}
+
+
+def _restore_missing_artifacts(ctx: Ctx) -> None:
+    """A video whose Library item is gone but which was never deleted (b2v_videos is the record) gets its item back,
+    rebuilt from the row. E.g. items removed by the Library's delete before it also removed the blog2video video."""
+    orphans = ctx.db.scalars(select(B2VVideo).where(
+        B2VVideo.workspace_id == ctx.workspace.id, B2VVideo.artifact_id.is_(None),
+        B2VVideo.b2v_video_id.is_not(None), B2VVideo.status != "deleted",
+        B2VVideo.quota_state != "refunded")).all()
+    for row in orphans:
+        status = ("ready" if row.status in video_quota.FINISHED else
+                  "failed" if row.status in video_quota.FAILED else
+                  row.status if row.status in JOB_STATUSES else STATUS_MAP.get(row.status, "generating"))
+        a = Artifact(workspace_id=ctx.workspace.id, type="video", status=status,
+                     content_json={k: v for k, v in {
+                         "provider": "blog2video", "b2v_video_id": row.b2v_video_id, "b2v_status": row.status,
+                         "title": row.title or "Video", "aspect_ratio": row.aspect_ratio,
+                         "preview_url": row.preview_url, "video_url": row.video_url}.items() if v is not None})
+        ctx.db.add(a)
+        ctx.db.flush()
+        row.artifact_id = a.id
+    if orphans:
+        ctx.db.commit()
+
+
+def _needs_title(row: B2VVideo) -> bool:
+    return not row.title or row.title == row.source_url or bool(re.match(r"https?://", row.title))
+
+
+def _set_title(ctx: Ctx, row: B2VVideo, a: Artifact | None, name: str | None) -> None:
+    """blog2video names a video after reading its source; until then we only had the link."""
+    name = (name or "").strip()[:300]
+    if not name or re.match(r"https?://", name) or row.title == name:
+        return
+    row.title = name
+    if a is not None:
+        a.content_json = {**(a.content_json or {}), "title": name}
+    ctx.db.commit()
+
+
+def _refresh_titles(ctx: Ctx, pairs: list[tuple[Artifact, B2VVideo]]) -> None:
+    """Real titles for videos still titled by their link, from blog2video's video list (one call)."""
+    todo = {row.b2v_video_id: (a, row) for a, row in pairs
+            if row.created_via == "v1" and row.b2v_video_id and _needs_title(row)}
+    if not todo or not b2v.configured():
+        return
+    try:
+        listed = b2v.request("GET", "/api/v1/videos", params={"external_user_id": str(ctx.workspace.id), "limit": 100})
+    except b2v.B2VError as e:
+        log.warning("could not refresh video titles: %s", e)
+        return
+    for item in (listed or {}).get("items") or []:
+        if item.get("video_id") in todo:
+            a, row = todo[item["video_id"]]
+            _set_title(ctx, row, a, item.get("name"))
+
+
+@router.get("")
+def list_videos(ctx: Ctx = Depends(get_ctx), limit: int = 30, offset: int = 0):
+    """The workspace's videos, newest first, with what the list rows show: title, status, source, scenes, date."""
+    _restore_missing_artifacts(ctx)
+    arts = [a for a in ctx.db.scalars(
+        select(Artifact).where(Artifact.workspace_id == ctx.workspace.id, Artifact.type == "video")
+        .order_by(Artifact.created_at.desc()).limit(min(limit, 100)).offset(offset)
+    ).all() if (a.content_json or {}).get("provider") == "blog2video"]
+    rows = {r.artifact_id: r for r in ctx.db.scalars(
+        select(B2VVideo).where(B2VVideo.artifact_id.in_([a.id for a in arts])))} if arts else {}
+    _refresh_titles(ctx, [(a, rows[a.id]) for a in arts if a.id in rows])
+    _refresh_busy(ctx, [(a, rows[a.id]) for a in arts if a.id in rows])
+    out = []
+    for a in arts:
+        row, content = rows.get(a.id), a.content_json or {}
+        out.append({**serialize_artifact(a), "source_url": row.source_url if row else None,
+                    "scenes": content.get("scenes"), "b2v_status": (row.status if row else content.get("b2v_status"))})
+    return out
+
+
+def _refresh_busy(ctx: Ctx, pairs: list[tuple[Artifact, B2VVideo]], limit: int = 10) -> None:
+    """Ask blog2video about videos still generating, rendering or in an edit job, so one that finished (or failed)
+    while nobody had it open shows its real state. A few per page; a blog2video hiccup leaves the stored status."""
+    busy = [(a, r) for a, r in pairs if a.status in BUSY_STATUSES and r.b2v_video_id is not None][:limit]
+    for a, row in busy:
+        try:
+            sync_status(ctx, a, row, b2v.status(row.b2v_video_id, row.created_via))
+        except b2v.B2VError as e:
+            log.info("status refresh for video %s skipped: %s", row.b2v_video_id, e)
+
+
+def _legacy(a: Artifact) -> dict:
+    content = a.content_json or {}
+    return {"legacy": True, "status": content.get("b2v_status"), "ready": bool(content.get("video_url")),
+            "video_url": content.get("video_url"), "preview_url": content.get("preview_url"),
+            "artifact_status": a.status, "artifact": serialize_artifact(a)}
+
+
+@router.get("/{artifact_id}/status")
+def video_status(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    a, vid, row = b2v_access.owned_video(ctx, artifact_id)
+    if row is None:
+        return _legacy(a)
+    try:
+        with upstream():
+            s = b2v.status(vid, row.created_via)
+    except HTTPException as e:
+        if e.status_code != 404:
+            raise
+        s = {"status": "failed", "error": "The video service lost this video."}
+    sync_status(ctx, a, row, s)
+    return {**s, "video_id": vid, "artifact_status": a.status}
+
+
+def preview_url(ctx: Ctx, a: Artifact, vid: int, row: B2VVideo | None = None) -> str | None:
+    """The public live-preview link (no key needed, safe for the browser). Minted once and kept."""
+    url = (row.preview_url if row else None) or (a.content_json or {}).get("preview_url")
+    if url:
+        return url
+    try:
+        url = (b2v.preview_token(vid) or {}).get("preview_url")
+    except b2v.B2VError as e:
+        log.warning("preview token for video %s failed: %s", vid, e)
+        return None
+    store(ctx, a, row, preview_url=url)
+    return url
+
+
+def _media_url(project_id: int, asset: dict | None, subdir: str, filename: str) -> str:
+    if asset and asset.get("r2_url"):
+        return asset["r2_url"]
+    return f"{settings.b2v_api_base_url.rstrip('/')}/media/projects/{project_id}/{subdir}/{filename}"
+
+
+def _enrich(project: dict) -> dict:
+    """What the scene rows show, worked out once here: each scene's audio and image links (blog2video only gives
+    file names), its layout and font sizes, and totals for the preview caption."""
+    pid = project.get("id")
+    assets = [a for a in project.get("assets") or [] if not a.get("excluded")]
+    latest: dict[tuple[str, str], dict] = {}
+    for a in sorted(assets, key=lambda a: a.get("id") or 0):  # a regenerated file is a newer asset, same name
+        latest[(a.get("asset_type"), a.get("filename"))] = a
+    total, images = 0.0, 0
+    scenes = []
+    for sc in sorted(project.get("scenes") or [], key=lambda s: s.get("order") or 0):
+        try:
+            code = json.loads(sc.get("remotion_code") or "{}")
+        except ValueError:
+            code = {}
+        custom = str(project.get("template") or "").startswith("custom_")
+        props = (code.get("layoutConfig") if custom else code.get("layoutProps")) or {}
+        audio = None
+        if sc.get("voiceover_path"):
+            name = re.split(r"[/\\]", sc["voiceover_path"])[-1]
+            asset = latest.get(("audio", name))
+            audio = _media_url(pid, asset, "audio", name) + (f"?v={asset['id']}" if asset else "")
+        pics = []
+        # Stills sit in assignedImage(s); a stock clip in assignedVideo(s). Both fill the scene's visual slot.
+        for key in ("assignedImage", "assignedImages", "image", "images", "assignedVideo", "assignedVideos"):
+            vals = props.get(key)
+            clip = key.startswith("assignedVideo")
+            for name in ([vals] if isinstance(vals, str) else vals if isinstance(vals, list) else []):
+                if isinstance(name, str) and name and not name.startswith("http"):
+                    first, second = ("video", "image") if clip else ("image", "video")
+                    asset = latest.get((first, name)) or latest.get((second, name))
+                    kind = asset.get("asset_type") if asset else first
+                    pics.append({"filename": name, "asset_id": asset.get("id") if asset else None, "kind": kind,
+                                 "url": _media_url(pid, asset, "videos" if kind == "video" else "images", name)})
+        images += len(pics)
+        total += float(sc.get("duration_seconds") or 0) + float(sc.get("extra_hold_seconds") or 0)
+        scenes.append({**sc, "audio_url": audio, "images": pics,
+                       "layout": code.get("layout") or sc.get("preferred_layout"),
+                       "title_font_size": props.get("titleFontSize"),
+                       "desc_font_size": props.get("descriptionFontSize")})
+    return {**project, "scenes": scenes,
+            "summary": {"scenes": len(scenes), "duration_seconds": round(total),
+                        "images": sum(1 for a in assets if a.get("asset_type") == "image") or images,
+                        "clips": sum(1 for a in assets if a.get("asset_type") == "video")}}
+
+
+@router.get("/{artifact_id}")
+def get_video(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    a, vid, row = b2v_access.owned_video(ctx, artifact_id)
+    if row is None:
+        return _legacy(a)
+    with upstream():
+        project = b2v.get_project(vid)
+    if row is not None:
+        _set_title(ctx, row, a, project.get("name"))
+    store(ctx, a, row, video_url=project.get("r2_video_url"), scenes=len(project.get("scenes") or []) or None)
+    return {"video_id": vid, "status": project.get("status"), "project": _enrich(project),
+            "preview_url": preview_url(ctx, a, vid, row), "video_url": project.get("r2_video_url"),
+            "artifact": serialize_artifact(a)}
+
+
+@router.delete("/{artifact_id}")
+def delete_video(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
+    """Removes it from Notestack and from blog2video."""
+    a, _, _ = b2v_access.owned_video(ctx, artifact_id)
+    remove_video(ctx, a)
+    return {"ok": True}
+
+
+def remove_video(ctx: Ctx, a: Artifact) -> None:
+    """Delete the video on blog2video, then the artifact. The b2v_videos row stays as the record that it was made
+    (status "deleted"): a lifetime allowance (Free) must not get a video back because one was deleted."""
+    row = ctx.db.scalar(select(B2VVideo).where(B2VVideo.artifact_id == a.id, B2VVideo.workspace_id == ctx.workspace.id))
+    if row is not None and row.b2v_video_id is not None and b2v.configured():
+        try:
+            b2v.delete_project(row.b2v_video_id)
+        except b2v.NotFound:
+            pass
+        except b2v.B2VError as e:
+            raise HTTPException(502, str(e)) from None
+    if row is not None:
+        row.status, row.artifact_id = "deleted", None
+    ctx.db.delete(a)
+    ctx.db.commit()
+
+
+# Script review (status awaiting_script_review): read, rewrite with AI, approve
+
+
+class DraftScene(BaseModel):
+    id: int
+    title: str = Field(max_length=255)
+    display_text: str | None = Field(None, max_length=3000)
+    narration_text: str = Field(max_length=6000)
+
+
+class ReviewPreviewIn(BaseModel):
+    title: str = Field(min_length=1, max_length=255)
+    display_text: str = Field(min_length=1, max_length=3000)
+    narration_text: str = Field("", max_length=6000)
+    draft_scenes: list[DraftScene] = Field(max_length=200)
+    revision: int = Field(0, ge=0)
+
+
+class ReviewAiIn(ReviewPreviewIn):
+    instruction: str = Field(min_length=2, max_length=1000)
+
+
+class ReviewApproveScene(DraftScene):
+    preferred_layout: str | None = Field(None, max_length=100)
+    source_fingerprint: str | None = Field(None, max_length=200)
+    accepted_ai_instructions: list[str] = Field(default_factory=list, max_length=10)
+
+
+class ReviewApproveIn(BaseModel):
+    scenes: list[ReviewApproveScene] = Field(max_length=200)
+
+
+@router.get("/{artifact_id}/script")
+def get_script(artifact_id: uuid.UUID, ctx: Ctx = Depends(get_ctx), _: None = Depends(b2v_ready)):
+    _, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    with upstream():
+        project = b2v.get_project(vid)
+    scenes = sorted(project.get("scenes") or [], key=lambda s: s.get("order", 0))
+    return {"status": project.get("status"), "scenes": [
+        {k: s.get(k) for k in ("id", "order", "title", "display_text", "narration_text", "preferred_layout")}
+        for s in scenes]}
+
+
+@router.post("/{artifact_id}/script/scenes/{scene_id}/narration-preview")
+def narration_preview(artifact_id: uuid.UUID, scene_id: int, body: ReviewPreviewIn, ctx: Ctx = Depends(get_ctx),
+                      _: None = Depends(b2v_ready)):
+    """Rewrite one scene's narration to match its edited title and text."""
+    _, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    with upstream():
+        return b2v.project_call("POST", vid, f"script-review/scenes/{scene_id}/narration-preview",
+                                json=body.model_dump(), timeout=60)
+
+
+@router.post("/{artifact_id}/script/scenes/{scene_id}/ai-preview")
+def ai_preview(artifact_id: uuid.UUID, scene_id: int, body: ReviewAiIn, ctx: Ctx = Depends(get_ctx),
+               _: None = Depends(b2v_ready)):
+    """★ Rewrite one scene from an instruction. Uses one AI edit."""
+    _, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    plan = video_limits.require_premium(ctx.db, ctx.workspace, "AI rewrites")
+    video_limits.take(ctx.db, ctx.workspace, "ai_edits", plan=plan)
+    try:
+        with upstream():
+            return b2v.project_call("POST", vid, f"script-review/scenes/{scene_id}/ai-preview",
+                                    json=body.model_dump(), timeout=60)
+    except HTTPException:
+        video_limits.give_back(ctx.db, ctx.workspace.id, "ai_edits")
+        raise
+
+
+@router.post("/{artifact_id}/script/approve")
+def approve_script(artifact_id: uuid.UUID, body: ReviewApproveIn, ctx: Ctx = Depends(get_ctx),
+                   _: None = Depends(b2v_ready)):
+    a, vid, _ = b2v_access.video_or_404(ctx, artifact_id)
+    with upstream():
+        result = b2v.project_call("POST", vid, "script-review/approve", json=body.model_dump(), timeout=60)
+    store(ctx, a, status="generating")
+    return result

backend/app/routers/voice.py

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

backend/app/services/artifacts.py

@@ -63,8 +63,11 @@ def serialize_artifact(a: Artifact, job: Job | None = None) -> dict:
         "document_id": str(a.document_id) if a.document_id else None,
         "content": content,
         "storage_key": a.storage_key,
-        "url": storage.presign_get(a.storage_key) if a.storage_key else None,
-        "download_url": storage.presign_get(a.storage_key, download_name=_download_name(a)) if a.storage_key else None,
+        # blog2video videos live on blog2video's storage (video_url once rendered)
+        "url": storage.presign_get(a.storage_key) if a.storage_key else content.get("video_url"),
+        "download_url": (storage.presign_get(a.storage_key, download_name=_download_name(a)) if a.storage_key
+                         else content.get("video_url")),
+        "provider": content.get("provider"),
         "slide_urls": [storage.presign_get(k) for k in slides],
         "created_at": a.created_at.isoformat() if a.created_at else None,
         "job": serialize_job(job) if job else None,

backend/app/services/auth_identity.py

@@ -9,6 +9,7 @@ from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from app.models import AuthProvider, Subscription, User, Workspace, WorkspaceMember
+from app.services.plans import PLANS
 
 
 class IdentityError(Exception):
@@ -65,7 +66,9 @@ def _bootstrap_workspace(db: Session, user: User) -> None:
     db.add(workspace)
     db.flush()
     db.add(WorkspaceMember(workspace_id=workspace.id, user_id=user.id, role="owner"))
-    db.add(Subscription(workspace_id=workspace.id, plan="free"))
+    free = PLANS["free"]
+    db.add(Subscription(workspace_id=workspace.id, plan="free", video_plan=free.id, video_limit=free.videos,
+                        videos_period_start=datetime.now(UTC)))
 
 
 def resolve_or_create_google_user(

backend/app/services/b2v_access.py

@@ -0,0 +1,219 @@
+"""Who owns what on our one blog2video account.
+
+blog2video's ownership checks stop at the account: any video, custom template, custom voice or style made with our
+key can be used, listed and edited with it. So every route that takes a blog2video id checks here first that it
+belongs to the current workspace (404 otherwise, so another workspace's ids are never confirmed), and every create or
+edit body has its references checked before it is forwarded (check_refs).
+"""
+
+import uuid
+
+from fastapi import HTTPException
+from sqlalchemy import select
+
+from app.auth import Ctx
+from app.models import Artifact, B2VCustomVoice, B2VStyle, B2VTemplate, B2VVideo
+from app.services import blog2video as b2v
+from app.services.notestack_voices import is_notestack_voice
+from app.services.plans import Plan, effective_plan
+from app.services.video_limits import require_premium
+
+BUILTIN_STYLES = {"auto", "explainer", "storytelling", "promotional"}
+# Custom styles made on our blog2video account itself, offered to every workspace in place of the others when they
+# exist (matched by name, the first is the default). Each sets the video length; the wizard has no length picker and
+# only says roughly how long the video comes out.
+HOUSE_STYLES = [  # (name on blog2video, video length, what the wizard says it is: about three lines)
+    ("Overview", "short", "A clear, neutral rundown of the key points. It gets straight to the main idea, one point per "
+                          "scene in plain words. Best for quick social posts and teasers. Usually under a minute long."),
+    ("Deep dive", "medium", "Sets up the context first, then works through the reasoning, examples and trade-offs, each "
+                            "scene building on the last. Best for YouTube, tutorials and full explainers. Usually 1 to "
+                            "2 minutes long."),
+]
+PREMIUM_LENGTHS = {"detailed", "more_detailed", "mdetailed"}
+
+
+def not_found(what: str = "Not found") -> HTTPException:
+    return HTTPException(404, what)
+
+
+# Videos
+
+
+def owned_video(ctx: Ctx, artifact_id: uuid.UUID) -> tuple[Artifact, int, B2VVideo | None]:
+    """The artifact, blog2video's id, and our ledger row (None for videos made before the API key).
+
+    The row is the reference: its b2v_video_id (and created_via) is what every blog2video call uses. The artifact's
+    content_json only keeps a copy for the Library, and is read only for legacy videos, which have no row."""
+    a = ctx.db.scalar(select(Artifact).where(Artifact.id == artifact_id, Artifact.workspace_id == ctx.workspace.id,
+                                             Artifact.type == "video"))
+    content = (a.content_json or {}) if a else {}
+    if not a or content.get("provider") != "blog2video":
+        raise not_found("Video not found")
+    row = ctx.db.scalar(select(B2VVideo).where(B2VVideo.artifact_id == a.id,
+                                               B2VVideo.workspace_id == ctx.workspace.id))
+    if row is not None and row.b2v_video_id is not None:
+        return a, row.b2v_video_id, row
+    if row is None and content.get("b2v_video_id"):
+        return a, int(content["b2v_video_id"]), None  # legacy
+    raise not_found("Video not found")  # the create never got an id from blog2video
+
+
+def video_or_404(ctx: Ctx, artifact_id: uuid.UUID) -> tuple[Artifact, int, B2VVideo]:
+    """A video this workspace owns and blog2video can still reach with our key."""
+    a, vid, row = owned_video(ctx, artifact_id)
+    if row is None:
+        raise HTTPException(410, {"code": "video_legacy",
+                                  "message": "This video was made before the video service changed and can not be "
+                                             "edited any more. Its links still work."})
+    return a, vid, row
+
+
+# Templates, voices, styles
+
+
+def owned_template(ctx: Ctx, template_id: int) -> B2VTemplate:
+    row = ctx.db.scalar(select(B2VTemplate).where(B2VTemplate.b2v_template_id == template_id,
+                                                  B2VTemplate.workspace_id == ctx.workspace.id))
+    if not row:
+        raise not_found("Template not found")
+    return row
+
+
+def owned_custom_voice(ctx: Ctx, custom_voice_id: int) -> B2VCustomVoice:
+    row = ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.b2v_custom_voice_id == custom_voice_id,
+                                                     B2VCustomVoice.workspace_id == ctx.workspace.id))
+    if not row:
+        raise not_found("Voice not found")
+    return row
+
+
+def owned_style(ctx: Ctx, style_id: int) -> B2VStyle:
+    row = ctx.db.scalar(select(B2VStyle).where(B2VStyle.b2v_style_id == style_id,
+                                               B2VStyle.workspace_id == ctx.workspace.id))
+    if not row:
+        raise not_found("Style not found")
+    return row
+
+
+def _custom_id(ref: str, prefix: str) -> int | None:
+    raw = ref.removeprefix(prefix)
+    return int(raw) if ref.startswith(prefix) and raw.isdigit() else None
+
+
+def crafted_ids() -> set[str]:
+    out = set()
+    for t in b2v.crafted_templates():
+        tid = t.get("id") if isinstance(t, dict) else t
+        if isinstance(tid, str) and tid.startswith("crafted_"):
+            out.add(tid)
+    return out
+
+
+def check_template(ctx: Ctx, template: str, plan: Plan) -> None:
+    if template == "default":
+        return
+    if (cid := _custom_id(template, "custom_")) is not None:
+        row = owned_template(ctx, cid)
+        if not row.ready:
+            raise HTTPException(400, "That template is still being made.")
+        return
+    if template.startswith("crafted_"):
+        # blog2video silently falls back to "default" for an unknown id, so check it exists.
+        if template not in crafted_ids():
+            raise not_found("Template not found")
+        require_premium(ctx.db, ctx.workspace, "Designer templates", plan)
+        return
+    if template not in {t.get("id") for t in b2v.builtin_templates() if isinstance(t, dict)}:
+        raise not_found("Template not found")
+
+
+def house_styles() -> list[dict]:
+    """HOUSE_STYLES found among the account's custom styles, in HOUSE_STYLES order, with the length each sets."""
+    by_name = {str(s.get("name") or "").strip().lower(): s for s in (b2v.video_styles() or {}).get("styles") or []
+               if s.get("kind") == "custom" and s.get("custom_id") is not None}
+    out = []
+    for name, length, blurb in HOUSE_STYLES:
+        if s := by_name.get(name.lower()):
+            out.append({"id": f"custom:{s['custom_id']}", "custom_id": s["custom_id"], "name": s.get("name"),
+                        "description": blurb, "kind": "house", "length": length})
+    return out
+
+
+def house_length(style: str | None) -> str | None:
+    """The video length a house style sets; None for any other style."""
+    if not style or not style.startswith("custom:"):
+        return None
+    return next((s["length"] for s in house_styles() if s["id"] == style), None)
+
+
+def check_style(ctx: Ctx, style: str) -> None:
+    if style in BUILTIN_STYLES:
+        return
+    if (sid := _custom_id(style, "custom:")) is not None:
+        if any(s["custom_id"] == sid for s in house_styles()):
+            return
+        owned_style(ctx, sid)
+        return
+    raise not_found("Video style not found")  # includes your_style, which learns from every workspace's edits
+
+
+def check_voice(ctx: Ctx, voice_id: str, plan: Plan) -> None:
+    """A built-in voice (premium if blog2video marks it paid), or one of this workspace's custom or Notestack
+    voices."""
+    prebuilt = {v.get("voice_id"): v for v in b2v.prebuilt_voices()}
+    if voice_id in prebuilt:
+        if prebuilt[voice_id].get("plan") == "paid":
+            require_premium(ctx.db, ctx.workspace, "This voice", plan)
+        return
+    if ctx.db.scalar(select(B2VCustomVoice).where(B2VCustomVoice.voice_id == voice_id,
+                                                  B2VCustomVoice.workspace_id == ctx.workspace.id)):
+        require_premium(ctx.db, ctx.workspace, "Custom voices", plan)
+        return
+    # One of this workspace's Notestack voices (clone, designed, added): same ElevenLabs account, premium like custom.
+    if is_notestack_voice(ctx.db, ctx.workspace.id, voice_id):
+        require_premium(ctx.db, ctx.workspace, "Custom voices", plan)
+        return
+    raise not_found("Voice not found")
+
+
+def check_refs(ctx: Ctx, body: dict, plan: Plan | None = None) -> Plan:
+    """Every id in a create or edit body must be this workspace's, and premium options need a paid plan."""
+    plan = plan or effective_plan(ctx.db, ctx.workspace)
+    if body.get("template"):
+        check_template(ctx, str(body["template"]), plan)
+    if body.get("video_style"):
+        check_style(ctx, str(body["video_style"]))
+    if body.get("custom_voice_id") and body.get("voice_gender") != "none":
+        check_voice(ctx, str(body["custom_voice_id"]), plan)
+    if str(body.get("video_length") or "") in PREMIUM_LENGTHS:
+        require_premium(ctx.db, ctx.workspace, "Longer videos", plan)
+    if body.get("voice_emotion"):
+        require_premium(ctx.db, ctx.workspace, "Advanced voice options", plan)
+    return plan
+
+
+# Catalog, filtered to what this workspace may see
+
+
+def visible_styles(ctx: Ctx) -> list[dict]:
+    """The house styles when the account has them; otherwise built-in styles (read-only) and this workspace's custom
+    styles. Never "Your Style", never others'."""
+    if house := house_styles():
+        return [{k: v for k, v in s.items() if k != "length"} for s in house]
+    mine = set(ctx.db.scalars(select(B2VStyle.b2v_style_id).where(B2VStyle.workspace_id == ctx.workspace.id)))
+    out = []
+    for s in (b2v.video_styles() or {}).get("styles") or []:
+        if s.get("kind") == "builtin" and s.get("id") in BUILTIN_STYLES:
+            out.append({"id": s["id"], "name": s.get("name"), "description": s.get("description"), "kind": "builtin"})
+        elif s.get("kind") == "custom" and s.get("custom_id") in mine:
+            out.append({"id": s["id"], "custom_id": s["custom_id"], "name": s.get("name"),
+                        "description": s.get("description"), "guidance": s.get("guidance"),
+                        "version": s.get("version"), "kind": "custom"})
+    return out
+
+
+def my_templates(ctx: Ctx, ready_only: bool = False) -> list[B2VTemplate]:
+    q = select(B2VTemplate).where(B2VTemplate.workspace_id == ctx.workspace.id)
+    if ready_only:
+        q = q.where(B2VTemplate.ready.is_(True))
+    return list(ctx.db.scalars(q.order_by(B2VTemplate.created_at.desc())))

backend/app/services/billing.py

@@ -13,13 +13,14 @@ from app.config import settings
 from app.models import Artifact, CalendarItem, Notebook, Source, Subscription, User, VoiceProfile, Workspace
 from app.services.plans import PLANS, Plan, effective_plan, next_plan, plan_dict
 from app.services.usage import month_usage
+from app.services.video_quota import sync_video_quota, video_usage
 
 CYCLES = {"monthly", "annual"}
 LOW_FUEL = 0.8  # meters at or above this share of the allowance start nudging
 
 METERS = {
     "audio_minutes": ("Audio overviews", "min"),
-    "video_minutes": ("Video renders", "min"),
+    "videos": ("Videos", ""),
     "launch_kits": ("Launch Kits", ""),
 }
 
@@ -90,7 +91,7 @@ def build_nudges(db: Session, workspace: Workspace, plan: Plan, meters: list[dic
         left = "Unlimited" if kits["limit"] < 0 else f"{kits['limit']}"
         out.append(_nudge(f"act-kit-{month}", "action", "Launch your latest post",
                           f"{left} Launch Kits this month, none used yet. One click turns a post into threads, "
-                          "LinkedIn posts, quote cards and a short video.", "Build a Launch Kit",
+                          "LinkedIn posts and quote cards.", "Build a Launch Kit",
                           "/app/launch-kit", priority=70))
     elif kits["limit"] > 0 and kits["used"] < kits["limit"]:
         left = kits["limit"] - kits["used"]
@@ -119,6 +120,8 @@ def build_nudges(db: Session, workspace: Workspace, plan: Plan, meters: list[dic
 def billing_status(db: Session, workspace: Workspace) -> dict:
     plan = effective_plan(db, workspace)
     used = month_usage(db, workspace.id)
+    videos = video_usage(db, workspace)
+    used["videos"] = videos["used"]
     sources = _count(db, Source, workspace.id)
     meters = _meters(plan, used, sources)
     upgrade = next_plan(plan)
@@ -134,6 +137,7 @@ def billing_status(db: Session, workspace: Workspace) -> dict:
         "period_end": sub.current_period_end.isoformat() if sub and sub.current_period_end else None,
         "meters": meters,
         "since": used["since"],
+        "videos_resets_at": videos["resets_at"],
         "nudges": build_nudges(db, workspace, plan, meters, can_upgrade),
     }
 
@@ -156,6 +160,8 @@ def apply_subscription(db: Session, workspace_id, *, plan: str, status: str, pro
     sub.provider_subscription_id = subscription_id or sub.provider_subscription_id
     sub.current_period_end = current_period_end
     db.commit()
+    if workspace:
+        sync_video_quota(db, workspace)
     if workspace and effective_plan(db, workspace).indexed_posts != before:
         resync_sources(db, workspace_id)
     return sub

backend/app/services/blog2video.py

@@ -0,0 +1,326 @@
+"""blog2video: turns a post into an editable, narrated video. Every call goes through here.
+
+NoteStack is an ordinary blog2video API customer: each request carries our account's key
+(Authorization: Bearer b2v_live_...), and everything made with it (videos, custom templates, custom voices, video
+styles) belongs to that one account. blog2video does not know our workspaces and its ownership checks stop at the
+account, so callers must check ownership first (app/services/b2v_access.py) and charge the workspace's own
+allowances (app/services/video_quota.py, app/services/video_limits.py).
+
+Some endpoints change state shared by every workspace, or hand one workspace another's data. They are refused here,
+before anything is sent (DENIED). The key never reaches the browser or the logs.
+"""
+
+import logging
+import re
+import threading
+import time
+from collections.abc import Callable
+from typing import Any
+
+import httpx
+
+from app.config import settings
+
+log = logging.getLogger(__name__)
+
+STATUS_TIMEOUT = 30  # every call without its own timeout (status polls, edits): blog2video can take well over 10s
+UPLOAD_TIMEOUT = 120
+CREATE_ATTEMPTS = 3  # a create is retried with the same Idempotency-Key, which never makes a duplicate
+CATALOG_TTL = 3600
+
+# Account-wide endpoints NoteStack must never call (the integration guide, section 11).
+DENIED: list[tuple[str, re.Pattern]] = [
+    (m, re.compile(p)) for m, p in [
+        ("POST", r"^/api/projects/?$"),  # same URL within 10 minutes returns another workspace's project
+        ("POST", r"^/api/projects/bulk/?$"),
+        ("GET", r"^/api/projects/?$"),  # every project on the account
+        ("GET", r"^/api/projects/template-availability/?$"),
+        ("*", r"^/api/voices/saved(/.*)?$"),  # one saved-voice list shared by everyone
+        ("*", r"^/api/video-styles/builtin/.*$"),  # changes a built-in style for everyone
+        ("*", r"^/api/video-styles/pin/?$"),
+        ("*", r"^/api/video-styles/selection/?$"),
+        ("*", r"^/api/video-styles/your-style/?$"),
+        ("*", r"^/api/auth/me/script-preferences/?$"),
+    ]
+]
+
+
+class B2VError(RuntimeError):
+    def __init__(self, message: str, status: int = 502, detail: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.detail = detail
+
+
+class AccountOutOfVideos(B2VError):
+    """Our blog2video account has no videos (or template slots) left. Not the user's fault; ops must buy more."""
+
+
+class NotFound(B2VError):
+    pass
+
+
+class Busy(B2VError):
+    """Another change is still running (409), or an account rate limit was hit (429)."""
+
+
+class TemplateInUse(B2VError):
+    """409 template_in_use: a video on the account still uses this custom template."""
+
+
+class BadRequest(B2VError):
+    pass
+
+
+class Upstream(B2VError):
+    """blog2video is down or slow, or rejected our key or plan (a configuration problem, not the user's)."""
+
+
+class Unreachable(Upstream):
+    """No answer at all (network error or timeout): a create may or may not have happened."""
+
+
+class Denied(B2VError):
+    """We refused to send this: the endpoint is account-wide (see DENIED)."""
+
+
+UNAVAILABLE = "Video creation is temporarily unavailable. Try again later."
+NOT_RESPONDING = "The video service is not responding. Try again in a minute."
+
+
+def configured() -> bool:
+    return bool(settings.b2v_api_base_url and settings.b2v_api_key)
+
+
+def _base() -> str:
+    return settings.b2v_api_base_url.rstrip("/")
+
+
+def denied(method: str, path: str) -> bool:
+    path = path.split("?", 1)[0]
+    return any(m in ("*", method.upper()) and p.match(path) for m, p in DENIED)
+
+
+def _body(resp: httpx.Response) -> Any:
+    try:
+        return resp.json()
+    except ValueError:
+        return resp.text[:500]
+
+
+def _error_code(body: Any) -> str | None:
+    """blog2video errors look like {"detail": {"error": "..."}} or {"detail": "..."}."""
+    if not isinstance(body, dict):
+        return None
+    detail = body.get("detail", body)
+    if isinstance(detail, dict):
+        return detail.get("error")
+    return detail if isinstance(detail, str) else None
+
+
+def _message(detail: Any, fallback: str) -> str:
+    if isinstance(detail, str) and detail.strip():
+        return detail.strip()[:300]
+    if isinstance(detail, dict) and isinstance(detail.get("message"), str):
+        return detail["message"][:300]
+    if isinstance(detail, list):  # 422s list the fields: [{"loc": [..., "url"], "msg": "..."}]
+        parts = [f"{(d.get('loc') or ['?'])[-1]}: {d.get('msg')}" for d in detail if isinstance(d, dict)]
+        if parts:
+            return "; ".join(parts)[:300]
+    return fallback
+
+
+def _raise_for(resp: httpx.Response, path: str) -> None:
+    if resp.status_code < 400:
+        return
+    body = _body(resp)
+    detail = body.get("detail", body) if isinstance(body, dict) else body
+    code = _error_code(body) or ""
+    status = resp.status_code
+    text = str(detail).lower()
+    if status == 402 or (status == 403 and "video limit reached" in text):
+        log.error("ALERT blog2video: our account is out of videos (%s): buy credits", path)
+        raise AccountOutOfVideos(UNAVAILABLE, 503, detail)
+    if status == 403 and code == "custom_template_limit":
+        log.error("ALERT blog2video: our account is out of custom template slots (%s): buy slots", path)
+        raise AccountOutOfVideos("Creating templates is temporarily unavailable. Try again later.", 503, detail)
+    if status == 401:
+        log.error("ALERT blog2video rejected our API key on %s (missing, revoked or rotated): update B2V_API_KEY",
+                  path)
+        raise Upstream(UNAVAILABLE, 503, detail)
+    if status == 403:
+        log.error("ALERT blog2video refused %s with 403 (%s): is the account still on a paid plan?", path,
+                  code or text[:120])
+        raise Upstream(UNAVAILABLE, 503, detail)
+    if 400 <= status < 500 and status not in (401, 403):
+        # What blog2video said, so a refused edit can be traced (never includes our key).
+        log.warning("blog2video %s -> %s: %s", path, status, str(detail)[:300])
+    if status == 404:
+        raise NotFound(_message(detail, "Not found"), 404, detail)
+    if status == 409 and code == "template_in_use":
+        raise TemplateInUse("A video still uses this template.", 409, detail)
+    if status == 409 or (status == 400 and "running" in text):
+        raise Busy(_message(detail, "Another change is still running, try again in a moment."), 409, detail)
+    if status == 429:
+        raise Busy(_message(detail, "The daily limit was reached. Try again later."), 429, detail)
+    if status in (400, 413, 415, 422):
+        raise BadRequest(_message(detail, str(code or "blog2video rejected the request")), 400, detail)
+    raise Upstream(NOT_RESPONDING, 502, detail)
+
+
+def _retry_after(resp: httpx.Response) -> float:
+    try:
+        return min(float(resp.headers.get("Retry-After", 1)), 5)
+    except ValueError:
+        return 1
+
+
+def request(method: str, path: str, *, json: Any = None, params: dict | None = None, data: dict | None = None,
+            files: Any = None, headers: dict | None = None, timeout: float | None = None,
+            raw: bool = False) -> Any:
+    """Call blog2video with our key. JSON by default; `data` + `files` send multipart; `raw` returns
+    (bytes, content_type) for audio and downloads. A POST with an Idempotency-Key (a create) is retried on no
+    answer, 5xx and 429, always with the same key: blog2video returns the original video, charged once."""
+    if denied(method, path):
+        log.error("refused to call account-wide blog2video endpoint %s %s", method, path)
+        raise Denied("Not available.", 404)
+    if not configured():
+        raise Upstream("Video is not set up yet.", 503)
+    url = f"{_base()}{path}"
+    timeout = timeout or STATUS_TIMEOUT
+    retryable = method == "POST" and bool(headers and headers.get("Idempotency-Key"))
+    attempts = CREATE_ATTEMPTS if retryable else 1
+    for attempt in range(1, attempts + 1):
+        last = attempt == attempts
+        started = time.monotonic()
+        try:
+            resp = httpx.request(method, url, json=json, params=params, data=data, files=files, timeout=timeout,
+                                 headers={**(headers or {}), "Authorization": f"Bearer {settings.b2v_api_key}"})
+        except httpx.HTTPError as e:
+            log.warning("blog2video %s %s failed (attempt %d): %s", method, path, attempt, type(e).__name__)
+            if last:
+                raise Unreachable(NOT_RESPONDING) from None
+            time.sleep(attempt)
+            continue
+        log.info("blog2video %s %s -> %s in %.0fms", method, path, resp.status_code,
+                 (time.monotonic() - started) * 1000)
+        if not last and (resp.status_code >= 500 or resp.status_code == 429):
+            time.sleep(_retry_after(resp) if resp.status_code == 429 else attempt)
+            continue
+        _raise_for(resp, path)
+        if raw:
+            return resp.content, resp.headers.get("content-type", "application/octet-stream")
+        return None if resp.status_code == 204 or not resp.content else _body(resp)
+    raise AssertionError("unreachable")
+
+
+# Shared catalog: the same for every workspace, cached for an hour.
+
+_cache: dict[str, tuple[float, Any]] = {}
+_cache_lock = threading.Lock()
+
+
+def cached(key: str, fetch: Callable[[], Any], ttl: float = CATALOG_TTL) -> Any:
+    with _cache_lock:
+        hit = _cache.get(key)
+        if hit and time.monotonic() - hit[0] < ttl:
+            return hit[1]
+    try:
+        value = fetch()
+    except B2VError:
+        if hit is None:
+            raise
+        # blog2video is slow or down: the last copy is better than failing the request.
+        log.warning("blog2video catalog %r could not be refreshed; using the copy from %.0fs ago",
+                    key, time.monotonic() - hit[0])
+        return hit[1]
+    with _cache_lock:
+        _cache[key] = (time.monotonic(), value)
+    return value
+
+
+def clear_cache() -> None:
+    with _cache_lock:
+        _cache.clear()
+
+
+def _catalog_timeout() -> float:
+    """Catalog lists are fetched about once an hour, so wait as long as a create would rather than fail."""
+    return settings.b2v_timeout_seconds
+
+
+def builtin_templates() -> list[dict]:
+    return cached("templates", lambda: request("GET", "/api/templates", timeout=_catalog_timeout()) or [])
+
+
+def crafted_templates() -> list[dict]:
+    return cached("crafted", lambda: request("GET", "/api/crafted-templates", timeout=_catalog_timeout()) or [])
+
+
+def prebuilt_voices() -> list[dict]:
+    """voice_id, name, preview_url, labels, description, plan ('free' | 'paid')."""
+    return cached("prebuilt", lambda: (request("GET", "/api/voices/prebuilt", timeout=_catalog_timeout()) or {})
+                  .get("voices") or [])
+
+
+def music_tracks() -> list[dict]:
+    """track_id, display_name, mood, r2_url."""
+    return cached("music", lambda: request("GET", "/api/background-music/tracks", timeout=_catalog_timeout()) or [])
+
+
+def video_styles() -> dict:
+    """Account-wide picker payload. Filter before use (b2v_access.visible_styles)."""
+    return request("GET", "/api/video-styles") or {}
+
+
+def account() -> Any:
+    """Our blog2video account: plan, videos, AI-edit allowance and credits, template slots."""
+    return request("GET", "/api/auth/me")
+
+
+# Videos
+
+def create_video(body: dict, idempotency_key: str) -> Any:
+    return request("POST", "/api/v1/videos", json=body, headers={"Idempotency-Key": idempotency_key},
+                   timeout=settings.b2v_timeout_seconds)
+
+
+def upload_project(form: dict, files: list[tuple[str, bytes, str]]) -> Any:
+    """Create a project from documents. Generation starts with generate()."""
+    return request("POST", "/api/projects/upload", data=form, timeout=UPLOAD_TIMEOUT,
+                   files=[("files", (name, content, ctype)) for name, content, ctype in files])
+
+
+def generate(project_id: int) -> Any:
+    return request("POST", f"/api/projects/{project_id}/generate", timeout=settings.b2v_timeout_seconds)
+
+
+def status(project_id: int, created_via: str = "v1") -> Any:
+    if created_via == "upload":
+        return request("GET", f"/api/projects/{project_id}/status")
+    return request("GET", f"/api/v1/videos/{project_id}/status")
+
+
+def get_project(project_id: int) -> Any:
+    """The whole project (scenes, assets). Much heavier than a status poll, so it gets the long timeout."""
+    return request("GET", f"/api/projects/{project_id}", timeout=settings.b2v_timeout_seconds)
+
+
+def delete_project(project_id: int) -> Any:
+    # blog2video removes the project's files before answering, which can take well over the 10s status timeout:
+    # timing out early reported a failure for a delete that went on to succeed.
+    return request("DELETE", f"/api/projects/{project_id}", timeout=settings.b2v_timeout_seconds)
+
+
+def upload_logo(project_id: int, filename: str, content_type: str, content: bytes) -> Any:
+    return request("POST", f"/api/projects/{project_id}/logo", files={"file": (filename, content, content_type)},
+                   timeout=UPLOAD_TIMEOUT)
+
+
+def preview_token(project_id: int) -> Any:
+    return request("POST", f"/api/embed/token/{project_id}")
+
+
+def project_call(method: str, project_id: int, sub: str, **kwargs) -> Any:
+    """Any /api/projects/{id}/... editor endpoint. Callers allowlist `sub` (app/routers/video_edit.py)."""
+    return request(method, f"/api/projects/{project_id}/{sub.lstrip('/')}", **kwargs)

backend/app/services/jobs.py

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

backend/app/services/notestack_voices.py

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

backend/app/services/plans.py

@@ -1,12 +1,22 @@
-"""Three tiers. While BILLING_ENABLED is false every workspace gets Studio limits for free."""
+"""Plans live in the `plans` table (edit a row to change limits or prices; it takes effect within a minute).
+DEFAULT_PLANS below seeds that table and is used whenever it is empty or unreachable.
+While BILLING_ENABLED is false every workspace gets Studio limits for free."""
 
-from dataclasses import asdict, dataclass
+import logging
+import threading
+import time
+from collections.abc import Iterator, Mapping
+from dataclasses import asdict, dataclass, field
 
 from fastapi import HTTPException
+from sqlalchemy import select
+from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import Session
 
 from app.config import settings
-from app.models import Subscription, Workspace
+from app.models import PlanRecord, Subscription, Workspace
+
+log = logging.getLogger(__name__)
 
 ANNUAL_DISCOUNT = 0.25  # annual billing: 25% off the monthly price
 
@@ -20,14 +30,38 @@ class Plan:
     sources: int
     indexed_posts: int
     audio_minutes: int
-    video_minutes: int
+    videos: int  # blog2video videos per month, or in total when videos_monthly is False
     launch_kits: int  # -1 = unlimited
     voice_cloning: bool
     brand_kit: bool
     features: tuple[str, ...]
+    # Premium (★) video options: long durations, paid and custom voices, voice tuning and samples, AI script
+    # rewrites, AI chat editing, avatars, the Remotion source download.
+    video_premium: bool = False
+    # Per-workspace shares of what blog2video only limits account-wide (keys in VIDEO_LIMITS; 0 = none).
+    video_limits: dict = field(default_factory=dict)
+    videos_monthly: bool = True
+
+
+# metric -> period it counts over (app/services/video_limits.py)
+VIDEO_LIMITS = {
+    "ai_edits": "month",  # scene regenerate/add, AI images, stock clips, AI chat, template AI edits, avatars
+    "templates": "all",  # custom templates: blog2video's slots are lifetime, never given back
+    "template_ai_daily": "day",  # template theme extraction from a prompt or document, code generation
+    "voice_designs_daily": "day",
+    "voice_samples_daily": "day",
+    "custom_voices": "all",  # kept voices; deleting one frees its place
+}
 
+FREE_VIDEO_LIMITS = {"ai_edits": 20, "templates": 0, "template_ai_daily": 0, "voice_designs_daily": 0,
+                     "voice_samples_daily": 0, "custom_voices": 0}
+WRITER_VIDEO_LIMITS = {"ai_edits": 300, "templates": 2, "template_ai_daily": 3, "voice_designs_daily": 5,
+                       "voice_samples_daily": 20, "custom_voices": 3}
+STUDIO_VIDEO_LIMITS = {"ai_edits": 1000, "templates": 5, "template_ai_daily": 5, "voice_designs_daily": 10,
+                       "voice_samples_daily": 40, "custom_voices": 10}
 
-PLANS: dict[str, Plan] = {
+
+DEFAULT_PLANS: dict[str, Plan] = {
     "free": Plan(
         id="free",
         name="Free",
@@ -36,7 +70,7 @@ PLANS: dict[str, Plan] = {
         sources=1,
         indexed_posts=5,
         audio_minutes=3,
-        video_minutes=1,
+        videos=1,
         launch_kits=2,
         voice_cloning=False,
         brand_kit=False,
@@ -44,9 +78,11 @@ PLANS: dict[str, Plan] = {
             "1 source, your latest 5 posts indexed",
             "Grounded research chat with citations",
             "3 min of audio overviews a month",
-            "1 min of video a month",
+            "1 video to try it",
             "2 Launch Kits a month",
         ),
+        video_limits=FREE_VIDEO_LIMITS,
+        videos_monthly=False,
     ),
     "writer": Plan(
         id="writer",
@@ -56,18 +92,20 @@ PLANS: dict[str, Plan] = {
         sources=3,
         indexed_posts=500,
         audio_minutes=60,
-        video_minutes=30,
+        videos=10,
         launch_kits=50,
         voice_cloning=True,
         brand_kit=True,
         features=(
             "3 sources, 500 indexed posts",
             "60 min of audio overviews a month",
-            "30 min of video renders a month",
+            "10 videos a month",
             "50 Launch Kits a month",
             "Voice cloning with consent",
             "Your brand colors and logo",
         ),
+        video_premium=True,
+        video_limits=WRITER_VIDEO_LIMITS,
     ),
     "studio": Plan(
         id="studio",
@@ -77,22 +115,90 @@ PLANS: dict[str, Plan] = {
         sources=10,
         indexed_posts=5000,
         audio_minutes=240,
-        video_minutes=120,
+        videos=20,
         launch_kits=-1,
         voice_cloning=True,
         brand_kit=True,
         features=(
             "10 sources, 5,000 indexed posts",
             "240 min of audio overviews a month",
-            "120 min of video renders a month",
+            "20 videos a month",
             "Unlimited Launch Kits",
             "Launchpad calendar and resurfacing",
             "Priority rendering",
         ),
+        video_premium=True,
+        video_limits=STUDIO_VIDEO_LIMITS,
     ),
 }
 
 
+CACHE_SECONDS = 60
+
+
+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),
+                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 {})})
+
+
+def _read_table() -> dict[str, Plan] | None:
+    from app.db import SessionLocal
+
+    try:
+        with SessionLocal() as db:
+            rows = db.scalars(select(PlanRecord).order_by(PlanRecord.sort_order, PlanRecord.price_monthly_usd)).all()
+            plans = {r.id: _plan_from_row(r) for r in rows}
+    except SQLAlchemyError as e:
+        log.warning("plans table unreadable, using built-in plans: %s", type(e).__name__)
+        return None
+    if plans and "free" not in plans:
+        log.error("plans table has no 'free' row, using built-in plans")
+        return None
+    return plans or None
+
+
+class PlanCatalog(Mapping[str, Plan]):
+    """PLANS: the plans table, cheapest first, cached for CACHE_SECONDS."""
+
+    def __init__(self) -> None:
+        self._plans: dict[str, Plan] | None = None
+        self._loaded_at = 0.0
+        self._lock = threading.Lock()
+
+    def _current(self) -> dict[str, Plan]:
+        now = time.monotonic()
+        if self._plans is None or now - self._loaded_at >= CACHE_SECONDS:
+            with self._lock:
+                if self._plans is None or now - self._loaded_at >= CACHE_SECONDS:
+                    self._plans = _read_table() or DEFAULT_PLANS
+                    self._loaded_at = now
+        return self._plans
+
+    def reload(self) -> None:
+        """Drop the cache so the next read sees table edits immediately."""
+        self._plans = None
+
+    def order(self) -> list[str]:
+        return list(self._current())
+
+    def __getitem__(self, plan_id: str) -> Plan:
+        return self._current()[plan_id]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._current())
+
+    def __len__(self) -> int:
+        return len(self._current())
+
+
+PLANS = PlanCatalog()
+
+
 def to_99(amount: float) -> float:
     """Nearest price ending in .99 (18.74 -> 18.99, 36.74 -> 36.99)."""
     return 0.0 if amount <= 0 else round(max(0.99, round(amount + 0.01) - 0.01), 2)
@@ -130,28 +236,39 @@ def effective_plan(db: Session, workspace: Workspace) -> Plan:
     return PLANS.get(sub.plan, PLANS["free"])
 
 
-PLAN_ORDER = ["free", "writer", "studio"]
+def plan_order() -> list[str]:
+    return PLANS.order()
 
 
 def next_plan(plan: Plan) -> Plan | None:
-    i = PLAN_ORDER.index(plan.id)
-    return PLANS[PLAN_ORDER[i + 1]] if i + 1 < len(PLAN_ORDER) else None
+    order = plan_order()
+    i = order.index(plan.id)
+    return PLANS[order[i + 1]] if i + 1 < len(order) else None
 
 
 def upgrade_for(plan: Plan, kind: str | None = None) -> str | None:
     """Cheapest plan above this one that raises the limit named by kind (or simply the next tier)."""
-    for pid in PLAN_ORDER[PLAN_ORDER.index(plan.id) + 1:]:
+    order = plan_order()
+    for pid in order[order.index(plan.id) + 1:]:
         candidate = PLANS[pid]
         if kind is None:
             return pid
-        if kind == "voice_cloning" and candidate.voice_cloning:
-            return pid
-        current, better = getattr(plan, kind, 0), getattr(candidate, kind, 0)
-        if better < 0 or (isinstance(better, int | float) and better > current):
+        current, better = plan_value(plan, kind), plan_value(candidate, kind)
+        if isinstance(better, bool):
+            if better and not current:
+                return pid
+        elif isinstance(better, int | float) and (better < 0 or better > current):
             return pid
     return None
 
 
+def plan_value(plan: Plan, kind: str):
+    """A plan's limit or flag by name; "video_limits.<metric>" reads the per-metric video limits."""
+    if kind.startswith("video_limits."):
+        return plan.video_limits.get(kind.removeprefix("video_limits."), 0)
+    return getattr(plan, kind, 0)
+
+
 def plan_limit_error(plan: Plan, kind: str, message: str) -> HTTPException:
     """402 the frontend turns into the out of fuel popup."""
     return HTTPException(402, {"code": "plan_limit", "message": message, "kind": kind,

backend/app/services/renderer.py

@@ -7,8 +7,6 @@ from app.models import Artifact, Job
 from app.services.storage import keys, storage
 
 COMPOSITIONS = {
-    "ShortVertical": "mp4",
-    "ExplainerLong": "mp4",
     "AudiogramSquare": "mp4",
     "QuoteCard": "png",
     "CarouselSlide": "png",

backend/app/services/stripe_billing.py

@@ -30,6 +30,7 @@ from sqlalchemy.orm import Session
 
 from app.config import settings
 from app.models import BillingEvent, Subscription, User, Workspace
+from app.services import video_quota
 from app.services.plans import PLANS, Plan, annual_prices
 
 log = logging.getLogger(__name__)
@@ -150,6 +151,9 @@ def sync_subscription(db: Session, workspace_id: uuid.UUID, stripe_sub) -> Subsc
     sub.plan = plan_id if (plan_id in PLANS and status in LIVE) else "free"
     sub.current_period_end = _ts(period_end)
     db.commit()
+    workspace = db.get(Workspace, workspace_id)
+    if workspace:
+        video_quota.sync_video_quota(db, workspace)
     return sub
 
 
@@ -336,6 +340,11 @@ def handle_event(db: Session, event) -> str:
         ws = _workspace_for(db, stripe_sub, customer_id=_get(obj, "customer"))
         if ws and stripe_sub is not None:
             sync_subscription(db, ws, stripe_sub)
+        # A new billing period (or a new paid plan) starts a fresh video allowance. `first` keeps a retried
+        # delivery of the same event from wiping videos made since.
+        if first and ws and kind == "invoice.paid" and \
+                _get(obj, "billing_reason") in {"subscription_cycle", "subscription_create"}:
+            video_quota.reset_videos(db, ws)
         if first and kind in {"invoice.payment_action_required", "invoice.payment_failed"}:
             # The first invoice of a Checkout is handled on the Checkout page itself.
             if _get(obj, "billing_reason") != "subscription_create":

backend/app/services/usage.py

@@ -7,6 +7,7 @@ from sqlalchemy.orm import Session
 
 from app.models import Artifact, UsageEvent, Workspace
 from app.services.plans import Plan, effective_plan, plan_limit_error
+from app.services.video_quota import video_usage
 
 
 def month_start(now: datetime | None = None) -> datetime:
@@ -32,7 +33,6 @@ def month_usage(db: Session, workspace_id) -> dict:
     ) or 0
     return {
         "audio_minutes": round(total("tts", "seconds") / 60, 1),
-        "video_minutes": round(total("video", "seconds") / 60, 1),
         "launch_kits": kits,
         "llm_tokens": int(total("llm", "tokens")),
         "since": since.isoformat(),
@@ -42,10 +42,13 @@ def month_usage(db: Session, workspace_id) -> dict:
 def usage_report(db: Session, workspace: Workspace) -> dict:
     plan = effective_plan(db, workspace)
     used = month_usage(db, workspace.id)
+    videos = video_usage(db, workspace)
+    used["videos"] = videos["used"]
     return {
         "plan": plan.id,
         "used": used,
-        "limits": {"audio_minutes": plan.audio_minutes, "video_minutes": plan.video_minutes,
+        "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},
     }
 
@@ -54,8 +57,7 @@ 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, "video_minutes": plan.video_minutes,
-             "launch_kits": plan.launch_kits}[kind]
+    limit = {"audio_minutes": plan.audio_minutes, "launch_kits": plan.launch_kits}[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/services/video_focus.py

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

backend/app/services/video_limits.py

@@ -0,0 +1,93 @@
+"""Per-workspace shares of what blog2video only limits account-wide: AI edits, custom templates, template AI
+operations, voice designs, voice samples, custom voices (plans.VIDEO_LIMITS), plus premium (★) video options.
+
+blog2video checks every limit against our own (Pro) account, so every workspace passes its checks. These counters
+stop a workspace before it uses up everyone's share. Videos themselves are counted in video_quota.py.
+
+A take is one conditional UPDATE (used + n <= limit), so two requests can not both take the last unit.
+"""
+
+import uuid
+from datetime import UTC, datetime
+
+from sqlalchemy import case, select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from app.models import UsageCounter, Workspace
+from app.services.plans import VIDEO_LIMITS, Plan, effective_plan, plan_limit_error
+
+LABELS = {
+    "ai_edits": ("AI edits", "this month"),
+    "templates": ("custom templates", "in total"),
+    "template_ai_daily": ("AI template steps", "today"),
+    "voice_designs_daily": ("voice designs", "today"),
+    "voice_samples_daily": ("voice samples", "today"),
+    "custom_voices": ("custom voices", "at a time"),
+}
+
+
+def period_key(metric: str, now: datetime | None = None) -> str:
+    now = now or datetime.now(UTC)
+    kind = VIDEO_LIMITS[metric]
+    return now.strftime("%Y-%m-%d") if kind == "day" else now.strftime("%Y-%m") if kind == "month" else "all"
+
+
+def _ensure_row(db: Session, workspace_id: uuid.UUID, period: str, metric: str) -> None:
+    key = {"workspace_id": workspace_id, "period": period, "metric": metric}
+    if db.get(UsageCounter, key) is not None:
+        return
+    db.add(UsageCounter(**key, used=0))
+    try:
+        db.commit()
+    except IntegrityError:  # a concurrent request made it first
+        db.rollback()
+
+
+def used(db: Session, workspace_id: uuid.UUID, metric: str) -> int:
+    row = db.get(UsageCounter, {"workspace_id": workspace_id, "period": period_key(metric), "metric": metric})
+    return row.used if row else 0
+
+
+def take(db: Session, workspace: Workspace, metric: str, n: int = 1, plan: Plan | None = None) -> None:
+    """Use n units of metric, or raise the 402 that opens the upgrade popup."""
+    plan = plan or effective_plan(db, workspace)
+    limit = int(plan.video_limits.get(metric, 0))
+    period = period_key(metric)
+    _ensure_row(db, workspace.id, period, metric)
+    where = [UsageCounter.workspace_id == workspace.id, UsageCounter.period == period, UsageCounter.metric == metric]
+    if limit >= 0:  # -1 = unlimited, still counted
+        where.append(UsageCounter.used + n <= limit)
+    taken = db.execute(update(UsageCounter).where(*where).values(used=UsageCounter.used + n)).rowcount
+    db.commit()
+    if taken != 1:
+        label, when = LABELS[metric]
+        message = (f"Your plan does not include {label}." if limit == 0
+                   else f"You have used all {limit} {label} {when}.")
+        raise plan_limit_error(plan, f"video_limits.{metric}", message)
+
+
+def give_back(db: Session, workspace_id: uuid.UUID, metric: str, n: int = 1) -> None:
+    """Undo a take whose blog2video call failed (or a custom voice that was deleted)."""
+    db.execute(update(UsageCounter)
+               .where(UsageCounter.workspace_id == workspace_id, UsageCounter.period == period_key(metric),
+                      UsageCounter.metric == metric)
+               .values(used=case((UsageCounter.used > n, UsageCounter.used - n), else_=0)))
+    db.commit()
+
+
+def require_premium(db: Session, workspace: Workspace, what: str, plan: Plan | None = None) -> Plan:
+    plan = plan or effective_plan(db, workspace)
+    if not plan.video_premium:
+        raise plan_limit_error(plan, "video_premium", f"{what} comes with a paid plan.")
+    return plan
+
+
+def report(db: Session, workspace: Workspace) -> dict:
+    """What the wizard shows: premium or not, and each counter's used / limit."""
+    plan = effective_plan(db, workspace)
+    rows = {(r.period, r.metric): r.used for r in db.scalars(
+        select(UsageCounter).where(UsageCounter.workspace_id == workspace.id))}
+    return {"premium": plan.video_premium,
+            "limits": {m: {"used": rows.get((period_key(m), m), 0), "limit": int(plan.video_limits.get(m, 0))}
+                       for m in VIDEO_LIMITS}}

backend/app/services/video_quota.py

@@ -0,0 +1,239 @@
+"""Video allowance, kept on the workspace's subscriptions row and enforced only by us.
+
+blog2video charges every video to our own account; it does not know our workspaces. So we:
+- reserve one video (videos_used + 1, only while below video_limit) before asking blog2video for it;
+- refund it exactly once if the create is refused or generation fails (the b2v_videos row records which);
+- keep video_plan and video_limit equal to the effective plan, and set videos_used back to 0 each month on plans
+  with a monthly allowance: on Stripe renewal (invoice.paid, see stripe_billing.handle_event), and monthly for
+  workspaces with no renewal to wait for (billing disabled, annual plans between renewals).
+- Free's allowance is a lifetime total (plan.videos_monthly False): never reset. When a workspace drops to such a
+  plan, videos_used becomes its lifetime count of videos that were not refunded.
+
+videos_used is only ever written with a single SQL UPDATE here, never through the ORM, so a sync can not
+overwrite a concurrent reserve or refund.
+"""
+
+import calendar
+import logging
+import uuid
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
+
+from sqlalchemy import case, func, select, update
+from sqlalchemy.orm import Session
+
+from app.config import settings
+from app.db import SessionLocal
+from app.models import Artifact, B2VVideo, Subscription, Workspace
+from app.services import blog2video as b2v
+from app.services.plans import PLANS, effective_plan
+
+log = logging.getLogger(__name__)
+
+LIVE = {"active", "trialing", "past_due"}
+RENEWAL_WINDOW = timedelta(days=45)  # a Stripe renewal this close to the period start does the reset instead
+FAILED = {"failed", "error"}
+FINISHED = {"generated", "done"}
+SWEEP_AFTER = timedelta(minutes=30)  # the sweep only looks at videos older than this (users who closed the tab)
+
+
+def add_month(when: datetime) -> datetime:
+    year, month = (when.year + 1, 1) if when.month == 12 else (when.year, when.month + 1)
+    return when.replace(year=year, month=month, day=min(when.day, calendar.monthrange(year, month)[1]))
+
+
+def _aware(when: datetime | None) -> datetime | None:
+    return when.replace(tzinfo=UTC) if when and when.tzinfo is None else when
+
+
+def _row(db: Session, workspace_id: uuid.UUID) -> Subscription:
+    sub = db.scalar(select(Subscription).where(Subscription.workspace_id == workspace_id))
+    if not sub:
+        sub = Subscription(workspace_id=workspace_id, plan="free", status="active")
+        db.add(sub)
+        db.flush()
+    return sub
+
+
+def sync_video_quota(db: Session, workspace: Workspace) -> Subscription:
+    """Make video_plan and video_limit match the workspace's effective plan. Cheap when nothing changed."""
+    plan = effective_plan(db, workspace)
+    sub = _row(db, workspace.id)
+    changed = False
+    if sub.video_plan != plan.id and not plan.videos_monthly:
+        # Onto a lifetime allowance: everything made so far counts (a Writer who made 10 can't make more on Free).
+        made = db.scalar(select(func.count(B2VVideo.id)).where(B2VVideo.workspace_id == workspace.id,
+                                                               B2VVideo.quota_state != "refunded")) or 0
+        db.execute(update(Subscription).where(Subscription.id == sub.id).values(videos_used=made))
+        changed = True
+    if sub.video_plan != plan.id or sub.video_limit != plan.videos:
+        sub.video_plan, sub.video_limit = plan.id, plan.videos
+        changed = True
+    if sub.videos_period_start is None:
+        sub.videos_period_start = datetime.now(UTC)
+        changed = True
+    if changed:
+        db.commit()
+    return sub
+
+
+def _renews_by_stripe(sub: Subscription) -> bool:
+    start, end = _aware(sub.videos_period_start), _aware(sub.current_period_end)
+    return bool(sub.provider_subscription_id and sub.status in LIVE and start and end
+                and end <= start + RENEWAL_WINDOW)
+
+
+def monthly(sub: Subscription) -> bool:
+    plan = PLANS.get(sub.video_plan)
+    return plan.videos_monthly if plan else True
+
+
+def resets_at(sub: Subscription) -> datetime | None:
+    start = _aware(sub.videos_period_start)
+    if not start or not monthly(sub):
+        return None
+    return _aware(sub.current_period_end) if _renews_by_stripe(sub) else add_month(start)
+
+
+def video_usage(db: Session, workspace: Workspace) -> dict:
+    sub = sync_video_quota(db, workspace)
+    db.refresh(sub)  # videos_used changes under us (reserves and refunds from other requests)
+    reset = resets_at(sub)
+    start = _aware(sub.videos_period_start)
+    return {"used": sub.videos_used, "limit": sub.video_limit, "plan": sub.video_plan,
+            "period_start": start.isoformat() if start else None, "resets_at": reset.isoformat() if reset else None}
+
+
+def reset_videos(db: Session, workspace_id: uuid.UUID, at: datetime | None = None) -> None:
+    db.execute(update(Subscription).where(Subscription.workspace_id == workspace_id)
+               .values(videos_used=0, videos_period_start=at or datetime.now(UTC)))
+    db.commit()
+
+
+def reset_due_video_periods(session_factory: Callable[[], Session] = SessionLocal) -> int:
+    """Monthly reset for workspaces a Stripe renewal will not reset in time. Runs from the worker's PERIODIC list."""
+    now = datetime.now(UTC)
+    count = 0
+    with session_factory() as db:
+        for sub in db.scalars(select(Subscription)):
+            start = _aware(sub.videos_period_start)
+            if start is None or _renews_by_stripe(sub) or not monthly(sub):
+                continue
+            if add_month(start) <= now:
+                reset_videos(db, sub.workspace_id, now)
+                count += 1
+    return count
+
+
+def reserve(db: Session, workspace_id: uuid.UUID) -> bool:
+    """Take one video from the allowance, atomically: two requests can not both take the last one.
+    False = none left (do not call blog2video)."""
+    taken = db.execute(update(Subscription)
+                       .where(Subscription.workspace_id == workspace_id,
+                              Subscription.videos_used < Subscription.video_limit)
+                       .values(videos_used=Subscription.videos_used + 1)).rowcount
+    db.commit()
+    return taken == 1
+
+
+def unreserve(db: Session, workspace_id: uuid.UUID) -> None:
+    """Give back a reservation that never got a b2v_videos row."""
+    db.execute(update(Subscription).where(Subscription.workspace_id == workspace_id)
+               .values(videos_used=case((Subscription.videos_used > 0, Subscription.videos_used - 1), else_=0)))
+    db.commit()
+
+
+def refund(db: Session, row: B2VVideo, status: str | None = None) -> bool:
+    """Give the workspace its video back, exactly once per row, however many callers race here, and never once
+    it finished generating ('kept'). True if this call did the refund."""
+    values = {"quota_state": "refunded", "updated_at": datetime.now(UTC)}
+    if status:
+        values["status"] = status
+    won = db.execute(update(B2VVideo).where(B2VVideo.id == row.id, B2VVideo.quota_state == "charged")
+                     .values(**values)).rowcount == 1
+    if won:
+        db.execute(update(Subscription).where(Subscription.workspace_id == row.workspace_id)
+                   .values(videos_used=case((Subscription.videos_used > 0, Subscription.videos_used - 1),
+                                            else_=0)))
+    db.commit()
+    db.refresh(row)
+    return won
+
+
+def record_status(db: Session, row: B2VVideo, status: str) -> None:
+    """Remember blog2video's latest status, refunding when it says the video failed. Once generation finished the
+    charge is kept (quota_state 'kept'): a later failed edit does not give the video back."""
+    if status in FAILED:
+        refund(db, row, "failed")
+    elif status and row.status != status:
+        values = {"status": status, "updated_at": datetime.now(UTC)}
+        if status in FINISHED:
+            values["quota_state"] = case((B2VVideo.quota_state == "charged", "kept"), else_=B2VVideo.quota_state)
+        db.execute(update(B2VVideo).where(B2VVideo.id == row.id).values(**values))
+        db.commit()
+        db.refresh(row)
+
+
+def sweep_failed_videos(session_factory: Callable[[], Session] = SessionLocal) -> int:
+    """Refund videos that failed while nobody was polling (the user closed the tab). Runs from PERIODIC."""
+    if not b2v.configured():
+        return 0
+    cutoff = datetime.now(UTC) - SWEEP_AFTER
+    refunded = 0
+    with session_factory() as db:
+        rows = db.scalars(select(B2VVideo).where(B2VVideo.quota_state == "charged",
+                                                 B2VVideo.status.not_in(FINISHED),
+                                                 B2VVideo.created_at < cutoff)).all()
+        for row in rows:
+            if row.b2v_video_id is None:
+                # The create never got an answer and the request died before refunding.
+                refunded += refund(db, row, "failed")
+                continue
+            try:
+                s = b2v.status(row.b2v_video_id, row.created_via)
+            except b2v.NotFound:
+                s = {"status": "failed", "error": "Video not found"}
+            except b2v.B2VError as e:
+                log.warning("video sweep: status of %s failed: %s", row.b2v_video_id, e)
+                continue
+            raw = str(s.get("status") or "")
+            if s.get("error") and raw not in FAILED:
+                raw = "failed"
+            if raw in FAILED:
+                refunded += refund(db, row, "failed")
+                if row.artifact_id and (a := db.get(Artifact, row.artifact_id)):
+                    a.status = "failed"
+                    a.content_json = {**(a.content_json or {}), "b2v_status": raw, "error": s.get("error")}
+                    db.commit()
+            elif raw:
+                record_status(db, row, raw)
+    return refunded
+
+
+AI_EDITS_ALERT_BELOW = 200
+TEMPLATE_SLOTS_ALERT_BELOW = 3
+
+
+def check_capacity() -> dict | None:
+    """Alert when our blog2video account runs low: our workspaces' limits added up can exceed it. Hourly."""
+    if not b2v.configured():
+        return None
+    try:
+        account = b2v.account() or {}
+    except b2v.B2VError as e:
+        log.error("ALERT blog2video capacity check failed: %s", e)
+        return None
+    low = []
+    limit, used = account.get("video_limit"), account.get("videos_used_this_period")
+    if not account.get("can_create_video") or (
+            limit is not None and used is not None and limit - used < settings.b2v_capacity_alert_below):
+        low.append(f"videos {used}/{limit} used")
+    ai = (account.get("ai_edit_allowance_remaining") or 0) + (account.get("ai_edit_credits") or 0)
+    if ai < AI_EDITS_ALERT_BELOW:
+        low.append(f"{ai} AI edits left")
+    slots, made = account.get("custom_template_limit"), account.get("custom_templates_created")
+    if slots is not None and made is not None and slots - made < TEMPLATE_SLOTS_ALERT_BELOW:
+        low.append(f"template slots {made}/{slots} used")
+    if low:
+        log.error("ALERT blog2video account (plan %s) is running low: %s", account.get("plan"), "; ".join(low))
+    return account

backend/app/support/corpus.py

@@ -61,10 +61,13 @@ def _parse(path: Path) -> Doc:
 
 def _plans_doc() -> Doc:
     """Built from services/plans.py so prices and limits can never drift from what the app enforces."""
-    from app.services.plans import PLAN_ORDER, PLANS, annual_prices
+    from app.services.plans import PLANS, annual_prices, plan_order
 
-    lines = ["# Plans", "Notestack has three plans: Free, Writer and Studio. Prices are in US dollars."]
-    for pid in PLAN_ORDER:
+    order = plan_order()  # the plans table's (editable without a deploy), so the names and count come from it too
+    names = [PLANS[pid].name for pid in order]
+    listed = ", ".join(names[:-1]) + f" and {names[-1]}" if len(names) > 1 else "".join(names)
+    lines = ["# Plans", f"Notestack has {len(names)} plans: {listed}. Prices are in US dollars."]
+    for pid in order:
         p = PLANS[pid]
         price = "free" if not p.price_monthly_usd else f"${p.price_monthly_usd:g} a month"
         if p.price_monthly_usd:
@@ -76,7 +79,7 @@ def _plans_doc() -> Doc:
             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.video_minutes} minutes of video a month, {kits} Launch Kits a month. "
+            f"{p.videos} videos {'a month' if p.videos_monthly else 'in total'}, {kits} Launch Kits 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) + ".",
         ]

backend/app/worker.py

@@ -31,6 +31,7 @@ from app.db import SessionLocal, engine
 from app.models import (
     Artifact,
     Chat,
+    Document,
     Job,
     Message,
     Source,
@@ -48,10 +49,18 @@ from app.pipeline import generate, launchkit, media
 from app.pipeline.generate import NothingToDo
 from app.pipeline.ingest import FeedNotFound, entry_from_upload, extract_article, ingest_source, store_entries
 from app.pipeline.memory import learn_from_message
-from app.services import launchpad, tts
+from app.services import launchpad, tts, video_quota
 from app.services.email import email_service
 from app.services.email_verification import purge_old_codes
-from app.services.jobs import claim_next, create_job, record_usage, retry_or_fail, stale_jobs, update_job
+from app.services.jobs import (
+    claim_next,
+    create_job,
+    pending_job,
+    record_usage,
+    retry_or_fail,
+    stale_jobs,
+    update_job,
+)
 from app.services.plans import effective_plan
 from app.services.renderer import PermanentJobError, request_render
 from app.services.storage import keys, storage
@@ -71,11 +80,6 @@ HANDED_OFF = object()  # the job continues elsewhere (renderer) and reports back
 # Handlers: (db, job) -> Done | HANDED_OFF. Raise to trigger a retry.
 
 
-def _pending(db: Session, workspace_id: uuid.UUID, kind: str) -> bool:
-    return db.scalar(select(Job.id).where(Job.workspace_id == workspace_id, Job.kind == kind,
-                                          Job.status.in_(("queued", "running"))).limit(1)) is not None
-
-
 def _after_import(db: Session, job: Job, workspace_id: uuid.UUID, changed: list[str]) -> None:
     """New or changed posts are mapped into the topic constellation and scored for resurfacing, and the
     first import builds the writing voice, so none of these need a button press."""
@@ -83,10 +87,10 @@ def _after_import(db: Session, job: Job, workspace_id: uuid.UUID, changed: list[
         return
     create_job(db, workspace_id, "topics", {"document_ids": changed}, max_attempts=2)
     create_job(db, workspace_id, "ideas", {"document_ids": changed}, max_attempts=2)
-    if not _pending(db, workspace_id, "resurface_scan"):
+    if not pending_job(db, workspace_id, "resurface_scan"):
         create_job(db, workspace_id, "resurface_scan", {}, max_attempts=2)
     vp = db.scalar(select(VoiceProfile).where(VoiceProfile.workspace_id == workspace_id))
-    if not (vp and vp.profile_json) and not _pending(db, workspace_id, "voice_profile"):
+    if not (vp and vp.profile_json) and not pending_job(db, workspace_id, "voice_profile"):
         create_job(db, workspace_id, "voice_profile", {"document_ids": []}, max_attempts=2)
 
 
@@ -276,7 +280,7 @@ HANDLERS: dict[str, Callable[[Session, Job], object]] = {
     "summary": _artifact_handler(generate.summarize_notebook, "Summary ready"),
     "mind_map": _artifact_handler(generate.build_mind_map, "Mind Constellation ready"),
     "audio_overview": _artifact_handler(media.audio_overview, "Audio overview ready"),
-    "video": _artifact_handler(media.make_video, "Video 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"),
     "carousel": _artifact_handler(media.render_carousel, "Carousel ready"),
     "launch_kit": _artifact_handler(launchkit.build_launch_kit, "Launch Kit ready"),
@@ -357,6 +361,19 @@ def single_flight(name: str):
                 conn.commit()
 
 
+def topics_backfill(session_factory: Callable[[], Session] = SessionLocal) -> None:
+    """Every indexed post gets topics: one whose tagging failed (the model timed out, rate limited, answered nothing)
+    or that came before posts were tagged on import is asked for again here, one topics job per workspace that has
+    some, unless one is already queued. A post that keeps failing stops being asked (generate.MAX_TAG_FAILURES)."""
+    if not settings.llm_api_key:
+        return
+    with session_factory() as db:
+        rows = db.execute(select(Document.workspace_id, Document.metadata_json).where(Document.path.is_not(None)))
+        for workspace_id in {ws for ws, meta in rows if generate.needs_topics(meta)}:
+            if not pending_job(db, workspace_id, "topics"):
+                create_job(db, workspace_id, "topics", {}, max_attempts=2)
+
+
 def update_email_batch(session_factory: Callable[[], Session] = SessionLocal) -> None:
     """Sends one daily batch per scheduled campaign at its send hour (UTC)."""
     now = datetime.now(UTC)
@@ -413,7 +430,11 @@ PERIODIC = [
     Periodic("publish_due", 30, launchpad.publish_due),
     Periodic("sync_engagement", 3600, launchpad.sync_engagement),
     Periodic("update_email_batch", 300, update_email_batch),
+    Periodic("topics_backfill", 900, topics_backfill),
     Periodic("daily_cleanup", 24 * 3600, daily_cleanup),
+    Periodic("video_period_reset", 3600, video_quota.reset_due_video_periods),
+    Periodic("video_refund_sweep", 600, video_quota.sweep_failed_videos),
+    Periodic("video_capacity_check", 3600, video_quota.check_capacity),
 ]
 
 

backend/requirements.txt

@@ -13,6 +13,7 @@ requests==2.*
 boto3==1.35.*
 resend==2.*
 httpx==0.28.*
+python-multipart==0.0.*
 dspy==2.6.*
 rank-bm25==0.2.*
 feedparser==6.*