LETS GOOOOOOOOOOOOOOOOOOOOOOOOO

backend/app/routers/billing.py

@@ -1,12 +1,21 @@
-from fastapi import APIRouter, Depends, HTTPException
+from typing import Literal
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel
 
 from app.auth import Ctx, get_ctx
 from app.config import settings
-from app.services.plans import PLANS, effective_plan, plan_dict
+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
 
 router = APIRouter(prefix="/api/billing", tags=["billing"])
 
 
+class CheckoutIn(BaseModel):
+    plan: Literal["writer", "studio"]
+    cycle: Literal["monthly", "annual"] = "monthly"
+
+
 @router.get("/plans")
 def list_plans():
     return {"billing_enabled": settings.billing_enabled, "plans": [plan_dict(p) for p in PLANS.values()]}
@@ -18,15 +27,33 @@ def my_plan(ctx: Ctx = Depends(get_ctx)):
     return {"billing_enabled": settings.billing_enabled, "plan": plan_dict(plan)}
 
 
+@router.get("/status")
+def status(ctx: Ctx = Depends(get_ctx)):
+    """Plan, meters and nudges for the upgrade popup, the sidebar fuel gauge and the nudge dock."""
+    return billing_status(ctx.db, ctx.workspace)
+
+
 @router.post("/checkout")
-def checkout(ctx: Ctx = Depends(get_ctx)):
+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."})
-    raise HTTPException(501, "Checkout provider not wired yet")
+    current = effective_plan(ctx.db, ctx.workspace)
+    if PLAN_ORDER.index(body.plan) <= 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)}
+
+
+@router.post("/portal")
+def portal(ctx: Ctx = Depends(get_ctx)):
+    if not settings.billing_enabled:
+        raise HTTPException(409, {"code": "billing_disabled", "message": "Billing is not available yet."})
+    return {"url": create_portal_url(ctx.db, ctx.workspace)}
 
 
 @router.post("/webhook")
-def webhook():
+async def webhook(request: Request):
+    """TODO(stripe): verify the Stripe-Signature header against STRIPE_WEBHOOK_SECRET, then map events to
+    services.billing.apply_subscription (workspace id from client_reference_id, plan from metadata)."""
     if not settings.billing_enabled:
         return {"ignored": True}
     raise HTTPException(501, "Webhook not wired yet")

backend/app/routers/sources.py

@@ -10,7 +10,7 @@ from app.corpus import INDEX, Corpus, CorpusError
 from app.models import Document, Job, NotebookDocument, Source, Upload
 from app.pipeline.ingest import IMPORTS_FEED, FeedNotFound, discover_feed, imports_source, rebuild_index
 from app.services.jobs import create_job, serialize_job
-from app.services.plans import effective_plan
+from app.services.plans import effective_plan, plan_limit_error
 from app.services.storage import storage
 
 router = APIRouter(prefix="/api/sources", tags=["sources"])
@@ -73,7 +73,7 @@ async def create_source(body: SourceIn, ctx: Ctx = Depends(get_ctx)):
         .where(Source.workspace_id == ctx.workspace.id, Source.feed_url != IMPORTS_FEED)
     )
     if count >= plan.sources:
-        raise HTTPException(402, {"code": "plan_limit", "message": f"Your plan includes {plan.sources} sources."})
+        raise plan_limit_error(plan, "sources", f"Your plan includes {plan.sources} sources.")
     source = Source(workspace_id=ctx.workspace.id, feed_url=found.feed_url, platform=found.platform,
                     site_url=found.site_url, title=found.title)
     ctx.db.add(source)

backend/app/routers/voice.py

@@ -12,7 +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.plans import effective_plan
+from app.services.plans import effective_plan, plan_limit_error
 from app.services.storage import storage
 
 router = APIRouter(prefix="/api/voice", tags=["voice"])
@@ -246,8 +246,9 @@ async def quota(ctx: Ctx = Depends(get_ctx)):
 
 @router.post("/consent")
 def give_consent(body: ConsentIn, request: Request, ctx: Ctx = Depends(get_ctx)):
-    if not effective_plan(ctx.db, ctx.workspace).voice_cloning:
-        raise HTTPException(402, {"code": "plan_limit", "message": "Voice cloning is on the Writer and Studio plans."})
+    plan = effective_plan(ctx.db, ctx.workspace)
+    if not plan.voice_cloning:
+        raise plan_limit_error(plan, "voice_cloning", "Voice cloning is on the Writer and Studio plans.")
     if not body.agreed or body.consent_text.strip() != CONSENT_TEXT:
         raise HTTPException(400, "Please read and accept the consent statement.")
     if not settings.elevenlabs_api_key:

backend/app/services/billing.py

@@ -0,0 +1,180 @@
+"""Upgrade flow: plan status with meters, nudges, and the seams where the payment provider plugs in.
+
+Stripe goes in create_checkout_url, create_portal_url and the webhook route; everything around it
+(meters, nudges, subscription bookkeeping, 402 payloads) is provider agnostic.
+"""
+
+from datetime import UTC, datetime
+
+from fastapi import HTTPException
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from app.config import settings
+from app.models import Artifact, CalendarItem, Notebook, Source, Subscription, User, VoiceProfile, Workspace
+from app.services.plans import PLANS, Plan, effective_plan, next_plan, plan_dict
+from app.services.usage import month_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"),
+    "launch_kits": ("Launch Kits", ""),
+}
+
+
+def _meters(plan: Plan, used: dict, sources: int) -> list[dict]:
+    rows = []
+    for key, (label, unit) in METERS.items():
+        limit = getattr(plan, key)
+        rows.append({"key": key, "label": label, "unit": unit, "used": used[key], "limit": limit,
+                     "pct": 0 if limit < 0 else round(min(1.0, used[key] / max(limit, 1)), 3)})
+    rows.append({"key": "sources", "label": "Sources", "unit": "", "used": sources, "limit": plan.sources,
+                 "pct": round(min(1.0, sources / max(plan.sources, 1)), 3)})
+    return rows
+
+
+def _count(db: Session, model, workspace_id, *where) -> int:
+    return db.scalar(select(func.count()).select_from(model).where(model.workspace_id == workspace_id, *where)) or 0
+
+
+def _nudge(nid: str, tone: str, title: str, body: str, cta: str, to: str | None = None, priority: int = 50) -> dict:
+    """tone: limit (out of or low on fuel), upgrade (locked perk), action (do more with what you have).
+    to is an app route, or None when the CTA opens the upgrade popup."""
+    return {"id": nid, "tone": tone, "title": title, "body": body, "cta": cta, "to": to, "priority": priority}
+
+
+def build_nudges(db: Session, workspace: Workspace, plan: Plan, meters: list[dict], can_upgrade: bool) -> list[dict]:
+    ws = workspace.id
+    out: list[dict] = []
+    month = datetime.now(UTC).strftime("%Y-%m")
+
+    if can_upgrade:
+        for m in meters:
+            if m["limit"] < 0 or m["key"] == "sources":
+                continue
+            label = m["label"].lower()
+            if m["pct"] >= 1:
+                out.append(_nudge(f"empty-{m['key']}-{month}", "limit", f"Out of {label} this month",
+                                  f"You have used all {m['limit']} {m['unit'] or label}. Upgrade to keep launching.",
+                                  "Refuel now", priority=100))
+            elif m["pct"] >= LOW_FUEL:
+                left = round(m["limit"] - m["used"], 1)
+                out.append(_nudge(f"low-{m['key']}-{month}", "limit", f"Running low on {label}",
+                                  f"Only {left:g} {m['unit'] or 'left'} left this month. Upgrade before you stall mid launch.",
+                                  "See plans", priority=90))
+        if not plan.voice_cloning:
+            out.append(_nudge("perk-voice", "upgrade", "Narrate in your own voice",
+                              "Writer unlocks voice cloning, so every audio overview sounds like you.",
+                              "Unlock voice", priority=40))
+        if not plan.brand_kit:
+            out.append(_nudge("perk-brand", "upgrade", "Put your brand on every render",
+                              "Your colors and logo on videos, quote cards and carousels.", "Unlock brand kit", priority=30))
+
+    sources = _count(db, Source, ws)
+    if sources == 0:
+        out.append(_nudge("act-source", "action", "Connect your archive",
+                          "Paste your Substack or blog URL and Notestack reads every post.", "Connect a source",
+                          "/app/sources", priority=95))
+        return sorted(out, key=lambda n: -n["priority"])
+
+    if _count(db, Notebook, ws) == 0:
+        out.append(_nudge("act-notebook", "action", "Open your first notebook",
+                          "Ask your archive anything and get answers with citations to your own posts.",
+                          "Create a notebook", "/app/notebooks", priority=80))
+    kits = next(m for m in meters if m["key"] == "launch_kits")
+    if kits["used"] == 0:
+        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",
+                          "/app/launch-kit", priority=70))
+    elif kits["limit"] > 0 and kits["used"] < kits["limit"]:
+        left = kits["limit"] - kits["used"]
+        out.append(_nudge(f"act-kit-left-{month}-{kits['used']}", "action",
+                          f"{left} Launch Kit{'s' if left != 1 else ''} left this month",
+                          "They reset on the 1st. Pick an older post and give it a second orbit.",
+                          "Use one now", "/app/launch-kit", priority=45))
+    if _count(db, Artifact, ws, Artifact.type == "audio_overview") == 0:
+        out.append(_nudge("act-audio", "action", "Hear your archive",
+                          "Make a two host audio overview of any notebook in about a minute.", "Make audio",
+                          "/app/studio", priority=55))
+    if not db.scalar(select(VoiceProfile.id).where(VoiceProfile.workspace_id == ws)):
+        out.append(_nudge("act-voice", "action", "Teach Notestack your voice",
+                          "A voice profile keeps every draft sounding like you wrote it.", "Build voice profile",
+                          "/app/voice", priority=50))
+    if _count(db, CalendarItem, ws) == 0:
+        out.append(_nudge("act-launchpad", "action", "Fill your launch window",
+                          "Schedule this week's posts on the Launchpad and let them go out on their own.",
+                          "Open Launchpad", "/app/launchpad", priority=35))
+    out.append(_nudge(f"act-resurface-{month}", "action", "Old posts, new orbit",
+                      "Resurfacing finds evergreen posts worth sharing again this month.", "Find evergreen posts",
+                      "/app/resurface", priority=20))
+    return sorted(out, key=lambda n: -n["priority"])
+
+
+def billing_status(db: Session, workspace: Workspace) -> dict:
+    plan = effective_plan(db, workspace)
+    used = month_usage(db, workspace.id)
+    sources = _count(db, Source, workspace.id)
+    meters = _meters(plan, used, sources)
+    upgrade = next_plan(plan)
+    can_upgrade = settings.billing_enabled and upgrade is not None
+    sub = db.query(Subscription).filter_by(workspace_id=workspace.id).one_or_none()
+    return {
+        "billing_enabled": settings.billing_enabled,
+        "plan": plan_dict(plan),
+        "plans": [plan_dict(p) for p in PLANS.values()],
+        "next_plan": upgrade.id if upgrade else None,
+        "can_upgrade": can_upgrade,
+        "has_billing_account": bool(sub and sub.provider_customer_id),
+        "period_end": sub.current_period_end.isoformat() if sub and sub.current_period_end else None,
+        "meters": meters,
+        "since": used["since"],
+        "nudges": build_nudges(db, workspace, plan, meters, can_upgrade),
+    }
+
+
+def apply_subscription(db: Session, workspace_id, *, plan: str, status: str, provider: str = "stripe",
+                       customer_id: str | None = None, subscription_id: str | None = None,
+                       current_period_end: datetime | None = None) -> Subscription:
+    """Upsert the workspace subscription. Call this from the webhook for checkout.session.completed,
+    customer.subscription.updated and customer.subscription.deleted (status 'canceled' drops to Free)."""
+    if plan not in PLANS:
+        raise ValueError(f"Unknown plan {plan}")
+    sub = db.query(Subscription).filter_by(workspace_id=workspace_id).one_or_none()
+    if not sub:
+        sub = Subscription(workspace_id=workspace_id)
+        db.add(sub)
+    sub.plan, sub.status, sub.provider = plan, status, provider
+    sub.provider_customer_id = customer_id or sub.provider_customer_id
+    sub.provider_subscription_id = subscription_id or sub.provider_subscription_id
+    sub.current_period_end = current_period_end
+    db.commit()
+    return sub
+
+
+def return_urls() -> tuple[str, str]:
+    """(success_url, cancel_url) for the hosted checkout page."""
+    base = settings.frontend_url.rstrip("/")
+    return f"{base}/app?checkout=success", f"{base}/app?checkout=cancel"
+
+
+def create_checkout_url(db: Session, user: User, workspace: Workspace, plan: Plan, cycle: str) -> str:
+    """Return the hosted checkout URL for plan on the monthly or annual cycle.
+
+    TODO(stripe): create a Checkout Session in subscription mode with the price for (plan.id, cycle),
+    customer_email=user.email, client_reference_id=str(workspace.id), metadata={"plan": plan.id},
+    success_url/cancel_url from return_urls(), and return session.url.
+    """
+    raise HTTPException(501, {"code": "checkout_not_wired", "message": "Checkout is almost ready. Check back soon."})
+
+
+def create_portal_url(db: Session, workspace: Workspace) -> str:
+    """Return the customer portal URL for managing or cancelling a subscription.
+
+    TODO(stripe): billing_portal.Session.create(customer=sub.provider_customer_id, return_url=.../app/settings).
+    """
+    raise HTTPException(501, {"code": "portal_not_wired", "message": "Billing management is almost ready."})

backend/app/services/plans.py

@@ -2,6 +2,7 @@
 
 from dataclasses import asdict, dataclass
 
+from fastapi import HTTPException
 from sqlalchemy.orm import Session
 
 from app.config import settings
@@ -126,3 +127,31 @@ def effective_plan(db: Session, workspace: Workspace) -> Plan:
     if not sub or sub.status not in {"active", "trialing"}:
         return PLANS["free"]
     return PLANS.get(sub.plan, PLANS["free"])
+
+
+PLAN_ORDER = ["free", "writer", "studio"]
+
+
+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
+
+
+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:]:
+        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):
+            return pid
+    return None
+
+
+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,
+                               "plan": plan.id, "upgrade_to": upgrade_for(plan, kind)})

backend/app/services/usage.py

@@ -2,12 +2,11 @@
 
 from datetime import UTC, datetime
 
-from fastapi import HTTPException
 from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
 from app.models import Artifact, UsageEvent, Workspace
-from app.services.plans import Plan, effective_plan
+from app.services.plans import Plan, effective_plan, plan_limit_error
 
 
 def month_start(now: datetime | None = None) -> datetime:
@@ -59,6 +58,5 @@ def check_limit(db: Session, workspace: Workspace, kind: str, amount: float = 1)
              "launch_kits": plan.launch_kits}[kind]
     if limit >= 0 and used[kind] + amount > limit:
         label = kind.replace("_", " ")
-        raise HTTPException(402, {"code": "plan_limit",
-                                  "message": f"This would go over your {limit} {label} this month."})
+        raise plan_limit_error(plan, kind, f"This would go over your {limit} {label} this month.")
     return plan

backend/tests/test_billing.py

@@ -0,0 +1,77 @@
+"""Upgrade flow: status meters, nudges, checkout guards and the 402 payload behind the out of fuel popup."""
+
+import pytest
+
+from app.config import settings
+from app.models import Artifact, Notebook, Workspace
+from app.services.billing import apply_subscription
+from tests.conftest import last_code
+
+
+@pytest.fixture()
+def auth(client):
+    client.post("/api/auth/email/register/start", json={"email": "ada@example.com", "password": "stardust-42"})
+    r = client.post("/api/auth/email/register/verify", json={"email": "ada@example.com", "code": last_code()})
+    return {"Authorization": f"Bearer {r.json()['access_token']}"}
+
+
+@pytest.fixture()
+def billing_on(monkeypatch):
+    monkeypatch.setattr(settings, "billing_enabled", True)
+
+
+def test_status_without_billing_has_no_upgrade_nudges(client, auth):
+    body = client.get("/api/billing/status", headers=auth).json()
+    assert body["plan"]["id"] == "studio" and body["can_upgrade"] is False
+    assert {m["key"] for m in body["meters"]} == {"audio_minutes", "video_minutes", "launch_kits", "sources"}
+    assert all(n["tone"] == "action" for n in body["nudges"])
+    assert body["nudges"][0]["id"] == "act-source"
+
+
+def test_free_plan_nudges_and_out_of_fuel_402(client, auth, billing_on, db_session):
+    ws = db_session.query(Workspace).one()
+    for _ in range(2):
+        db_session.add(Artifact(workspace_id=ws.id, type="launch_kit", status="ready"))
+    db_session.commit()
+
+    body = client.get("/api/billing/status", headers=auth).json()
+    assert body["plan"]["id"] == "free" and body["can_upgrade"] and body["next_plan"] == "writer"
+    kits = next(m for m in body["meters"] if m["key"] == "launch_kits")
+    assert kits["used"] == 2 and kits["pct"] == 1
+    ids = [n["id"] for n in body["nudges"]]
+    assert ids[0].startswith("empty-launch_kits") and "perk-voice" in ids
+    assert "—" not in str(body)
+
+    nb = Notebook(workspace_id=ws.id, title="Pricing")
+    db_session.add(nb)
+    db_session.commit()
+    r = client.post("/api/artifacts/generate", headers=auth,
+                    json={"type": "audio_overview", "notebook_id": str(nb.id), "minutes": 6})
+    detail = r.json()["detail"]
+    assert r.status_code == 402 and detail["kind"] == "audio_minutes" and detail["upgrade_to"] == "writer"
+
+
+def test_checkout_guards(client, auth, billing_on, db_session):
+    assert client.post("/api/billing/checkout", headers=auth, json={"plan": "writer"}).status_code == 501
+    assert client.post("/api/billing/checkout", headers=auth, json={"plan": "free"}).status_code == 422
+    ws = db_session.query(Workspace).one()
+    apply_subscription(db_session, ws.id, plan="studio", status="active", customer_id="cus_1")
+    r = client.post("/api/billing/checkout", headers=auth, json={"plan": "writer", "cycle": "annual"})
+    assert r.status_code == 409 and r.json()["detail"]["code"] == "already_on_plan"
+    body = client.get("/api/billing/status", headers=auth).json()
+    assert body["plan"]["id"] == "studio" and body["has_billing_account"] and not body["can_upgrade"]
+
+
+def test_checkout_disabled_without_billing(client, auth):
+    r = client.post("/api/billing/checkout", headers=auth, json={"plan": "writer"})
+    assert r.status_code == 409 and r.json()["detail"]["code"] == "billing_disabled"
+
+
+def test_plan_limit_error_names_the_upgrade():
+    from app.services.plans import PLANS, plan_limit_error, upgrade_for
+
+    assert upgrade_for(PLANS["free"], "voice_cloning") == "writer"
+    assert upgrade_for(PLANS["writer"], "launch_kits") == "studio"
+    assert upgrade_for(PLANS["studio"], "audio_minutes") is None
+    detail = plan_limit_error(PLANS["free"], "audio_minutes", "x").detail
+    assert detail["code"] == "plan_limit" and detail["upgrade_to"] == "writer" and detail["kind"] == "audio_minutes"

frontend/src/pages/Landing.tsx

@@ -19,7 +19,7 @@ import {
 
 export const PENDING_SOURCE_KEY = "ns_pending_source";
 // Bump after re-rendering public/demo.mp4 so browsers and the CDN fetch the new file.
-const DEMO_VERSION = 2;
+const DEMO_VERSION = 3;
 
 const FEATURES = [
   {

renderer/public/demo-vo/durations.json

@@ -1,10 +1,10 @@
 {
-  "warp": 3.74,
-  "paste": 8.1,
-  "orbit": 6.3,
-  "research": 4.29,
-  "audio": 3.74,
-  "launchkit": 6.53,
-  "launchpad": 3.22,
-  "outro": 2.48
+  "warp": 3.69,
+  "paste": 8.34,
+  "orbit": 5.96,
+  "research": 4.39,
+  "audio": 4.57,
+  "launchkit": 5.83,
+  "launchpad": 3.14,
+  "outro": 2.56
 }

renderer/public/launch-vo/durations.json

@@ -1,14 +1,14 @@
 {
-  "intro": 5.36,
-  "launch": 2.85,
-  "sources": 8.0,
-  "research": 4.94,
-  "map": 5.96,
-  "voice": 4.52,
-  "audio": 3.45,
-  "video": 6.61,
-  "launchkit": 6.38,
-  "launchpad": 5.65,
-  "resurface": 3.82,
-  "outro": 5.07
+  "intro": 5.78,
+  "launch": 3.03,
+  "sources": 6.14,
+  "research": 4.16,
+  "map": 6.12,
+  "voice": 4.57,
+  "audio": 3.69,
+  "video": 4.44,
+  "launchkit": 4.7,
+  "launchpad": 3.32,
+  "resurface": 4.23,
+  "outro": 5.17
 }

renderer/scripts/make_demo_music.py

@@ -0,0 +1,175 @@
+"""Ambient space score for the landing demo: warm pads, a bell arpeggio, a soft sub, long reverb.
+Pure additive synthesis, no noise sources. Writes renderer/public/demo-vo/music.wav (stereo, 44.1 kHz)."""
+
+import wave
+from pathlib import Path
+
+import numpy as np
+
+SR = 44100
+TOTAL = 47.5
+OUT = Path(__file__).resolve().parents[1] / "public" / "demo-vo" / "music.wav"
+
+n = int(SR * TOTAL)
+t = np.arange(n) / SR
+left = np.zeros(n)
+right = np.zeros(n)
+
+
+def hz(midi: float) -> float:
+    return 440.0 * 2 ** ((midi - 69) / 12)
+
+
+def env(start: float, dur: float, attack: float, release: float) -> np.ndarray:
+    """Smooth (raised cosine) attack and release, zero outside the note."""
+    e = np.zeros(n)
+    i0, i1 = int(start * SR), min(n, int((start + dur + release) * SR))
+    if i0 >= n:
+        return e
+    tt = t[i0:i1] - start
+    a = np.clip(tt / attack, 0, 1)
+    a = 0.5 - 0.5 * np.cos(np.pi * a)
+    r = np.clip((start + dur + release - t[i0:i1]) / release, 0, 1)
+    r = 0.5 - 0.5 * np.cos(np.pi * r)
+    e[i0:i1] = a * r
+    return e
+
+
+def pad_voice(freq: float, e: np.ndarray, brightness: np.ndarray, pan: float, gain: float) -> None:
+    """Soft saw-like tone: a few harmonics with rolloff, two detuned copies for width, slow vibrato."""
+    idx = np.nonzero(e)[0]
+    if not len(idx):
+        return
+    sl = slice(idx[0], idx[-1] + 1)
+    tt = t[sl]
+    vib = 1 + 0.0015 * np.sin(2 * np.pi * 0.21 * tt + freq)
+    tone = np.zeros(len(tt))
+    for cents, ph in ((-7, 0.0), (7, 1.3)):
+        f = freq * 2 ** (cents / 1200) * vib
+        phase = 2 * np.pi * np.cumsum(f) / SR + ph
+        for h in range(1, 7):
+            tone += np.sin(h * phase) * (brightness[sl] ** (h - 1)) / h**1.4
+    tone *= e[sl] * gain
+    left[sl] += tone * (1 - pan)
+    right[sl] += tone * (1 + pan)
+
+
+def bell(freq: float, start: float, gain: float, pan: float) -> None:
+    """Glassy bell: fundamental plus an inharmonic partial, fast decay."""
+    i0 = int(start * SR)
+    if i0 >= n:
+        return
+    length = min(n - i0, int(2.4 * SR))
+    tt = np.arange(length) / SR
+    decay = np.exp(-tt * 2.2)
+    tone = np.sin(2 * np.pi * freq * tt) + 0.35 * np.sin(2 * np.pi * freq * 2.76 * tt) * np.exp(-tt * 5)
+    tone += 0.12 * np.sin(2 * np.pi * freq * 5.4 * tt) * np.exp(-tt * 9)
+    attack = np.clip(tt / 0.004, 0, 1)
+    tone *= decay * attack * gain
+    left[i0:i0 + length] += tone * (1 - pan)
+    right[i0:i0 + length] += tone * (1 + pan)
+
+
+# Progression in D (lydian colour), ~5.2 s per chord, ending on a wide resolved chord for the outro.
+CHORDS = [
+    (0.0, [50, 57, 61, 64, 69]),     # Dmaj9 (no 3rd low)   D A C# E A
+    (5.2, [47, 54, 57, 61, 66]),     # Bm11 feel            B F# A C# F#
+    (10.4, [43, 50, 54, 57, 62]),    # Gmaj7 add9           G D F# A D
+    (15.6, [45, 52, 56, 59, 64]),    # A6/9 feel            A E G# B E
+    (20.8, [50, 57, 61, 64, 68]),    # Dmaj7#11             D A C# E G#
+    (26.0, [47, 54, 57, 62, 66]),    # Bm9                  B F# A D F#
+    (31.2, [43, 50, 55, 59, 64]),    # G6/9                 G D G B E
+    (36.4, [50, 57, 62, 64, 69]),    # Dsus2 add6 outro     D A D E A
+]
+CHORD_LEN = 5.2
+
+# Filter brightness rises slowly through the piece and blooms at the outro.
+brightness = 0.28 + 0.14 * np.clip(t / TOTAL, 0, 1) + 0.1 * np.clip((t - 36) / 4, 0, 1)
+brightness *= 1 + 0.08 * np.sin(2 * np.pi * 0.05 * t)
+
+for start, notes in CHORDS:
+    last = start == CHORDS[-1][0]
+    dur = (TOTAL - start - 3.0) if last else CHORD_LEN
+    e = env(start, dur, attack=1.8, release=2.6 if not last else 3.0)
+    for i, midi in enumerate(notes):
+        pad_voice(hz(midi), e, brightness, pan=(i - 2) * 0.22, gain=0.055 if i else 0.07)
+    # Sub bass: root an octave down, pure sine, gentle.
+    root = hz(notes[0] - 12)
+    idx = np.nonzero(e)[0]
+    sl = slice(idx[0], idx[-1] + 1)
+    sub = np.sin(2 * np.pi * root * t[sl]) * e[sl] * 0.11
+    left[sl] += sub
+    right[sl] += sub
+
+# Bell arpeggio from the second scene on: eighth notes at 88 bpm, up and down the chord an octave up.
+step = 60 / 88 / 2
+rng = np.random.default_rng(3)
+beat = 3.4
+k = 0
+while beat < TOTAL - 3.5:
+    chord = [c for c in CHORDS if c[0] <= beat][-1][1]
+    pattern = chord[1:] + chord[-2:0:-1]
+    midi = pattern[k % len(pattern)] + 12
+    accent = 1.0 if k % 4 == 0 else 0.7
+    thin = 0.55 if 20 < beat < 26 else 1.0  # breathe during the audio overview scene
+    if rng.random() > 0.12:  # a few rests so it does not feel mechanical
+        bell(hz(midi), beat, gain=0.045 * accent * thin, pan=0.5 * np.sin(k * 0.9))
+    beat += step
+    k += 1
+
+# Ping pong delay on everything (dotted eighth), dark feedback.
+delay = int(SR * step * 1.5)
+fb = 0.3
+dl, dr = np.zeros(n), np.zeros(n)
+for i in range(3):
+    shift = delay * (i + 1)
+    g = fb ** (i + 1)
+    src_l, src_r = (right, left) if i % 2 == 0 else (left, right)
+    dl[shift:] += src_l[:-shift] * g
+    dr[shift:] += src_r[:-shift] * g
+left += dl * 0.5
+right += dr * 0.5
+
+# Long reverb: convolution with a smooth decaying impulse (built from low passed, decaying partials,
+# not white noise, so it stays silky).
+ir_len = int(SR * 3.2)
+it = np.arange(ir_len) / SR
+ir_l = np.zeros(ir_len)
+ir_r = np.zeros(ir_len)
+for f in rng.uniform(180, 2400, 90):
+    ph = rng.uniform(0, 2 * np.pi, 2)
+    d = np.exp(-it * rng.uniform(1.1, 2.2))
+    ir_l += np.sin(2 * np.pi * f * it + ph[0]) * d
+    ir_r += np.sin(2 * np.pi * f * it + ph[1]) * d
+ir_l /= np.max(np.abs(ir_l))
+ir_r /= np.max(np.abs(ir_r))
+
+
+def convolve(x: np.ndarray, ir: np.ndarray) -> np.ndarray:
+    size = 1 << int(np.ceil(np.log2(len(x) + len(ir))))
+    y = np.fft.irfft(np.fft.rfft(x, size) * np.fft.rfft(ir, size), size)
+    return y[: len(x)]
+
+
+wet_l = convolve(left, ir_l)
+wet_r = convolve(right, ir_r)
+wet_l /= np.max(np.abs(wet_l)) + 1e-9
+wet_r /= np.max(np.abs(wet_r)) + 1e-9
+dry = max(np.max(np.abs(left)), np.max(np.abs(right)))
+mix_l = left / dry * 0.75 + wet_l * 0.45
+mix_r = right / dry * 0.75 + wet_r * 0.45
+
+# Master: fade in, fade out, gentle soft clip, normalize.
+master = np.minimum(1, t / 2.5) * np.minimum(1, (TOTAL - t) / 3.0)
+mix_l *= master
+mix_r *= master
+peak = max(np.max(np.abs(mix_l)), np.max(np.abs(mix_r)))
+mix_l = np.tanh(mix_l / peak * 1.1) * 0.8
+mix_r = np.tanh(mix_r / peak * 1.1) * 0.8
+stereo = np.stack([mix_l, mix_r], axis=1)
+with wave.open(str(OUT), "wb") as w:
+    w.setnchannels(2)
+    w.setsampwidth(2)
+    w.setframerate(SR)
+    w.writeframes((stereo * 32767).astype("<i2").tobytes())
+print("music ok", OUT)

renderer/scripts/make_demo_vo.py

@@ -0,0 +1,42 @@
+"""Narration for the landing page demo (Nora Vale, Mission Control). Writes public/demo-vo/*.mp3 + durations.json.
+
+The screens show the product; the voice says what it feels like. Then copy the printed durations
+into VO_SECONDS in src/compositions/LandingDemo.tsx (and lengthen a scene if its line no longer fits).
+make_demo_music.py writes the 47.5 s score; rerun it with a larger TOTAL if the demo grows past that.
+
+    cd backend && PYTHONPATH=. .venv/Scripts/python ../renderer/scripts/make_demo_vo.py
+"""
+
+import json
+import uuid
+from pathlib import Path
+
+from app.services import tts
+
+OUT = Path(__file__).resolve().parents[1] / "public" / "demo-vo"
+OUT.mkdir(parents=True, exist_ok=True)
+
+LINES = {
+    "warp": "Captain's log. Your knowledge... is now in orbit.",
+    "paste": "Just point us at your writing. Any blog, any site, any folder of notes. Then sit back.",
+    "orbit": "Watch years of work come home. Every idea you've had, finally within reach.",
+    "research": "Ask, and hear your own best thinking answer back. With proof.",
+    "audio": "Hear your ideas as a conversation. Like meeting your work for the first time.",
+    "launchkit": "No more blank page. Next week's posts are already here, and they sound like you.",
+    "launchpad": "Press schedule, and feel the weight lift off.",
+    "outro": "Notestack. Clear skies ahead.",
+}
+
+voice_id = next(v["voice_id"] for v in tts.list_voices() if v["name"].startswith("Nora Vale"))
+vs = tts.VoiceSettings(stability=0.55, similarity_boost=0.8, style=0.3, speed=0.93)
+ws = uuid.UUID(int=0)
+keys = list(LINES)
+durations = {}
+for i, key in enumerate(keys):
+    prev_text = LINES[keys[i - 1]] if i else None
+    next_text = LINES[keys[i + 1]] if i + 1 < len(keys) else None
+    clip = tts.synthesize(ws, LINES[key], voice_id, vs, prev_text, next_text)
+    (OUT / f"{key}.mp3").write_bytes(clip)
+    durations[key] = round(tts.mp3_seconds(clip), 2)
+(OUT / "durations.json").write_text(json.dumps(durations, indent=2))
+print(json.dumps(durations))

renderer/scripts/make_launch_vo.py

@@ -1,5 +1,7 @@
 """Narration for the launch trailer (Nora Vale, Mission Control). Writes public/launch-vo/*.mp3 + durations.json.
 
+The screens show what each feature does; the voice carries what it feels like to use it.
+
 Run from backend/ (uses its ElevenLabs client and .env), then run make_launch_music.py:
     cd backend && PYTHONPATH=. .venv/Scripts/python ../renderer/scripts/make_launch_vo.py
 """
@@ -14,23 +16,23 @@ OUT = Path(__file__).resolve().parents[1] / "public" / "launch-vo"
 OUT.mkdir(parents=True, exist_ok=True)
 
 LINES = {
-    "intro": "Every writer carries a universe of ideas. Most of it... still uncharted.",
-    "launch": "So we built a ship. Let's go exploring.",
-    "sources": "First stop: your sources. Any blog, newsletter, website, or markdown file, pulled into orbit.",
-    "research": "Ask your archive anything. Every answer is traced to the exact lines you wrote.",
-    "map": "Chart the constellations in your thinking. See what's rising, and what has gone dark.",
-    "voice": "Teach it your voice, so everything it makes still sounds like you.",
-    "audio": "Turn any notebook into a two host audio overview.",
-    "video": "Shorts, explainers, audiograms and quote cards, all rendered from your own words.",
-    "launchkit": "One post becomes a thread, a LinkedIn post, notes, an SEO pack and a carousel.",
-    "launchpad": "Schedule everything, and post straight to X, LinkedIn and Bluesky.",
-    "resurface": "And your best old posts? We bring them back into orbit.",
+    "intro": "You have written more than you remember. Whole worlds of ideas... still uncharted.",
+    "launch": "Take a breath. We're going exploring.",
+    "sources": "Watch years of your writing drift back into view. Nothing lost. Nothing forgotten.",
+    "research": "Ask a question, and hear your own best thinking answer back.",
+    "map": "See the shape of your mind. The ideas you keep coming home to, and the ones still waiting.",
+    "voice": "Everything it makes sounds like you. On your best day.",
+    "audio": "Hear your ideas come alive, as a conversation.",
+    "video": "Watch your words move, glow, and find new eyes.",
+    "launchkit": "One post. A whole week of posts. And never a blank page.",
+    "launchpad": "Press schedule, and feel the weight lift off.",
+    "resurface": "And the gems you forgot you wrote? They find their way back to you.",
     "outro": "Notestack A.I. The galaxies of your untapped potential. Coming soon.",
 }
 
 voice_id = next(v["voice_id"] for v in tts.list_voices() if v["name"].startswith("Nora Vale"))
-# A touch more energy than the landing demo: this one is a trailer.
-vs = tts.VoiceSettings(stability=0.5, similarity_boost=0.8, style=0.35, speed=0.95)
+# Warm and unhurried: this is about a feeling, not a feature list.
+vs = tts.VoiceSettings(stability=0.5, similarity_boost=0.8, style=0.4, speed=0.93)
 ws = uuid.UUID(int=0)
 keys = list(LINES)
 durations = {}

renderer/src/compositions/LandingDemo.tsx

@@ -1,5 +1,5 @@
 import type { CSSProperties, ReactNode } from "react";
-import { AbsoluteFill, Audio as SoundTrack, Easing, interpolate, random, Sequence, spring, staticFile, useCurrentFrame, useVideoConfig } from "remotion";
+import { AbsoluteFill, Audio as SoundTrack, Easing, Img, interpolate, random, Sequence, spring, staticFile, useCurrentFrame, useVideoConfig } from "remotion";
 import { theme } from "../theme";
 
 /** Landing page product demo: a trip through the Notestack galaxy. 1920x1080, 30 fps, ~32 s.
@@ -16,7 +16,7 @@ const SCENES = [
   { id: "paste", len: 9.4, vo: 0.4 },
   { id: "orbit", len: 7.6, vo: 0.4 },
   { id: "research", len: 5.6, vo: 0.4 },
-  { id: "audio", len: 5.1, vo: 0.4 },
+  { id: "audio", len: 5.8, vo: 0.4 },
   { id: "launchkit", len: 7.8, vo: 0.4 },
   { id: "launchpad", len: 4.6, vo: 0.4 },
   { id: "outro", len: 4.2, vo: 0.5 },
@@ -25,7 +25,7 @@ const XFADE = 0.5; // seconds of overlap between scenes
 
 // Narration clip lengths (public/demo-vo/durations.json) so the music can duck under the voice.
 const VO_SECONDS: Record<(typeof SCENES)[number]["id"], number> = {
-  warp: 3.74, paste: 8.1, orbit: 6.3, research: 4.29, audio: 3.74, launchkit: 6.53, launchpad: 3.22, outro: 2.48,
+  warp: 3.69, paste: 8.34, orbit: 5.96, research: 4.39, audio: 4.57, launchkit: 5.83, launchpad: 3.14, outro: 2.56,
 };
 
 /** Frame ranges where the narrator is speaking, in composition time. */
@@ -563,9 +563,8 @@ function Outro() {
     <AbsoluteFill>
       <WarpField speed={interpolate(frame, [0, 60, 114], [0.5, 2, 12])} streak={interpolate(frame, [70, 114], [0, 1], { extrapolateLeft: "clamp" })} />
       <AbsoluteFill style={{ justifyContent: "center", alignItems: "center", textAlign: "center", gap: 30 }}>
-        <div style={{ width: 120, height: 120, borderRadius: 30, background: theme.white, display: "grid", placeItems: "center", opacity: s, transform: `scale(${s})`, boxShadow: `0 0 80px ${BLUE}` }}>
-          <div style={{ width: 44, height: 44, borderRadius: "50%", background: theme.black, boxShadow: `18px -18px 0 -10px ${theme.black}` }} />
-        </div>
+        {/* The navbar mark (frontend/public/logo.svg, copied to public/logo.svg). */}
+        <Img src={staticFile("logo.svg")} width={128} height={128} style={{ borderRadius: 30, opacity: s, transform: `scale(${s})`, boxShadow: `0 0 80px ${BLUE}` }} />
         <h1 style={{ margin: 0, fontFamily: theme.display, fontSize: 120, color: theme.white, opacity: s, textShadow: `0 0 40px ${BLUE}` }}>Notestack</h1>
         <p style={{ margin: 0, fontFamily: theme.body, fontSize: 40, color: "rgba(255,255,255,0.8)", opacity: cta }}>Your knowledge, in orbit.</p>
         <p style={{ margin: 0, padding: "18px 40px", borderRadius: 999, background: BLUE, color: theme.white, fontFamily: theme.body, fontWeight: 600, fontSize: 32, opacity: cta, boxShadow: `0 0 40px ${BLUE}` }}>

renderer/src/compositions/LaunchTrailer.tsx

@@ -544,11 +544,11 @@ function Intro() {
         <Galaxy seed="far-4" x={260} y={200} size={60} tilt={0.7} />
       </div>
       <AbsoluteFill style={{ justifyContent: "center", alignItems: "center", textAlign: "center", gap: 28 }}>
-        <h1 style={{ margin: 0, fontFamily: theme.display, fontWeight: 600, fontSize: 96, color: WHITE, opacity: a, transform: `translateY(${(1 - a) * 30}px)` }}>
-          Every writer carries a universe.
+        <h1 style={{ margin: 0, fontFamily: theme.display, fontWeight: 600, fontSize: 80, color: WHITE, opacity: a, transform: `translateY(${(1 - a) * 30}px)` }}>
+          You have written more than you remember.
         </h1>
         <h2 style={{ margin: 0, fontFamily: theme.display, fontWeight: 500, fontSize: 64, color: "rgba(255,255,255,0.75)", opacity: b, transform: `translateY(${(1 - b) * 24}px)` }}>
-          Most of it is <span style={{ color: WHITE, textShadow: `0 0 30px ${BLUE}, 0 0 70px ${BLUE}` }}>still uncharted.</span>
+          Whole worlds of ideas, <span style={{ color: WHITE, textShadow: `0 0 30px ${BLUE}, 0 0 70px ${BLUE}` }}>still uncharted.</span>
         </h2>
         <p style={{ margin: "30px 0 0", fontFamily: theme.mono, fontSize: 24, letterSpacing: 8, color: BLUE, opacity: c }}>A JOURNEY OF KNOWLEDGE</p>
       </AbsoluteFill>

renderer/src/compositions/launchTimeline.ts

@@ -1,20 +1,20 @@
 // Generated by make_launch_music.py from public/launch-vo/durations.json. Do not edit by hand.
 // 120 bpm; every scene starts on a bar line so cuts land on the beat.
 export const LAUNCH_BPM = 120;
-export const LAUNCH_SECONDS = 92.0;
+export const LAUNCH_SECONDS = 84.0;
 export const LAUNCH_SCENES = [
-  { id: "intro", start: 0.0, len: 8.0, vo: 1.0, voLen: 5.36 },
-  { id: "launch", start: 8.0, len: 4.0, vo: 0.35, voLen: 2.85 },
-  { id: "sources", start: 12.0, len: 10.0, vo: 0.35, voLen: 8.0 },
-  { id: "research", start: 22.0, len: 6.0, vo: 0.35, voLen: 4.94 },
-  { id: "map", start: 28.0, len: 8.0, vo: 0.35, voLen: 5.96 },
-  { id: "voice", start: 36.0, len: 6.0, vo: 0.35, voLen: 4.52 },
-  { id: "audio", start: 42.0, len: 6.0, vo: 0.35, voLen: 3.45 },
-  { id: "video", start: 48.0, len: 8.0, vo: 0.35, voLen: 6.61 },
-  { id: "launchkit", start: 56.0, len: 8.0, vo: 0.35, voLen: 6.38 },
-  { id: "launchpad", start: 64.0, len: 8.0, vo: 0.35, voLen: 5.65 },
-  { id: "resurface", start: 72.0, len: 6.0, vo: 0.35, voLen: 3.82 },
-  { id: "montage", start: 78.0, len: 4.0, vo: null, voLen: null },
-  { id: "outro", start: 82.0, len: 10.0, vo: 1.2, voLen: 5.07 },
+  { id: "intro", start: 0.0, len: 8.0, vo: 1.0, voLen: 5.78 },
+  { id: "launch", start: 8.0, len: 4.0, vo: 0.35, voLen: 3.03 },
+  { id: "sources", start: 12.0, len: 8.0, vo: 0.35, voLen: 6.14 },
+  { id: "research", start: 20.0, len: 6.0, vo: 0.35, voLen: 4.16 },
+  { id: "map", start: 26.0, len: 8.0, vo: 0.35, voLen: 6.12 },
+  { id: "voice", start: 34.0, len: 6.0, vo: 0.35, voLen: 4.57 },
+  { id: "audio", start: 40.0, len: 6.0, vo: 0.35, voLen: 3.69 },
+  { id: "video", start: 46.0, len: 6.0, vo: 0.35, voLen: 4.44 },
+  { id: "launchkit", start: 52.0, len: 6.0, vo: 0.35, voLen: 4.7 },
+  { id: "launchpad", start: 58.0, len: 6.0, vo: 0.35, voLen: 3.32 },
+  { id: "resurface", start: 64.0, len: 6.0, vo: 0.35, voLen: 4.23 },
+  { id: "montage", start: 70.0, len: 4.0, vo: null, voLen: null },
+  { id: "outro", start: 74.0, len: 10.0, vo: 1.2, voLen: 5.17 },
 ] as const;
 export type LaunchSceneId = (typeof LAUNCH_SCENES)[number]["id"];