Merge pull request #9 from FireBird-Technologies/develop

.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=16000
-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=

.github/workflows/ci.yml

@@ -17,9 +17,9 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with: { python-version: "3.12", cache: pip }
-      - run: pip install -r requirements-dev.txt
+      - run: pip install -r requirements.txt
       - run: ruff check app tests
-      - run: pytest -q
+      # - run: pytest -q
 
   frontend:
     runs-on: ubuntu-latest

.gitignore

@@ -20,3 +20,7 @@ renderer/build/
 
 # Local object storage (used when no R2 is configured)
 .storage/
+
+# Local-only notes, not for the repo
+docs-local/
+docs/

Dockerfile

@@ -0,0 +1,25 @@
+# Hugging Face Spaces image (the Space builds this root Dockerfile from the whole repo).
+# One container, non-root uid 1000, port 7860; the worker runs inside the API process.
+# Local docker-compose builds backend/Dockerfile instead.
+FROM python:3.12-slim
+
+RUN useradd -m -u 1000 user
+WORKDIR /app
+ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 \
+    ENV=production \
+    RUN_WORKER_IN_API=true \
+    CORPUS_CACHE_DIR=/app/.corpus-cache \
+    LOCAL_STORAGE_DIR=/app/.storage
+
+# Chromium draws an infographic's PNG for its Download button (and the fonts the pages use)
+RUN apt-get update && apt-get install -y --no-install-recommends chromium fonts-liberation \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY --chown=user backend/ .
+RUN rm -f .env
+USER user
+
+EXPOSE 7860
+CMD ["sh", "-c", "alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 7860 --proxy-headers --forwarded-allow-ips='*'"]

README.md

@@ -1,3 +1,13 @@
+---
+title: NoteStack Test
+emoji: 📚
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
 <p align="center">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="marketing/logo/notestack-logo.svg">
@@ -39,10 +49,10 @@ archive, stays in sync with it, cites the exact lines behind every answer, and t
 | Citations | Exact line ranges, verified before you see them | Passage level citations |
 | Not in your sources | Says so; unverifiable claims are dropped | Grounded, passage citations |
 | Audio | Two hosts on ElevenLabs voices, or your consented voice clone | Two host overviews, Google voices |
-| Video | 9:16 shorts, 16:9 explainers, 1:1 audiograms, quote cards, in your brand | Video overviews |
+| Video | 9:16 shorts, 16:9 explainers, 1:1 audiograms, quote cards | Video overviews |
 | Publishing | Launch Kits (threads, LinkedIn, Notes, Bluesky, SEO, carousels) and auto posting | Not a publishing tool |
 | Your voice | Voice profile learned from your posts, used in every draft | General purpose writing |
-| Seeing your archive | Topic constellation with rising and dormant topics, evergreen resurfacing | Mind maps per notebook |
+| Seeing your archive | Topic constellation with rising and dormant topics, evergreen resurfacing | Idea Constellations per notebook |
 
 The full comparison lives at [notestack.ai/notebooklm-alternative](https://notestack.ai/notebooklm-alternative).
 
@@ -71,7 +81,7 @@ docker compose up --build
 Without Docker (one API process does everything):
 
 ```bash
-cd backend && python -m venv .venv && .venv/Scripts/pip install -r requirements-dev.txt
+cd backend && python -m venv .venv && .venv/Scripts/pip install -r requirements.txt
 alembic upgrade head && uvicorn app.main:app --reload     # SQLite at backend/notestack.db
 cd frontend && npm install && npm run dev
 cd renderer && npm install && npm start                    # only needed for videos, quote cards, carousels
@@ -83,9 +93,19 @@ cd renderer && npm install && npm start                    # only needed for vid
 - With no R2 settings, files live on local disk under `backend/.storage` and are served through
   signed `/api/storage/local/...` URLs (range requests supported for audio and video seeking).
 - Audio needs `ELEVENLABS_API_KEY`; everything text based needs `LLM_API_KEY`.
-- Launchpad: Bluesky connects with an app password. X and LinkedIn need developer apps; the
-  redirect URIs are listed in `.env.example` and on the Launchpad page. Substack Notes has no API,
-  so those posts (and any post without a connected account) arrive as an email reminder at send time.
+- Launchpad: posts (text, images, videos from your Library; not audio) go to X and LinkedIn at their
+  scheduled time through a `publish_post` job. Set up the developer apps and keys as described in
+  `backend/.env.example`:
+  - `X_CLIENT_ID` / `X_CLIENT_SECRET`: the X app's **OAuth 2.0 Client ID and Client Secret** (Read and write,
+    Web App, callback `{API_URL}/api/social/x/callback`, scopes incl. `media.write`).
+  - `LINKEDIN_CLIENT_ID` / `LINKEDIN_CLIENT_SECRET`: products "Sign In with LinkedIn using OpenID Connect" and
+    "Share on LinkedIn", redirect `{API_URL}/api/social/linkedin/callback`.
+  - `API_URL` must be reachable from the internet for the callbacks (an https tunnel locally).
+  X and LinkedIn posts need a connected account. X tokens are refreshed automatically; LinkedIn connections
+  last about 60 days. If a connection goes down (expired, revoked on the platform, or disconnected here) its
+  scheduled posts are **paused** and never attempted; reconnecting the same account resumes the ones still
+  ahead, and missed ones wait for a new time. Bluesky connects with an app password; Substack Notes has no API,
+  so those posts arrive as an email reminder at send time.
 
 ## What is in the app
 
@@ -101,7 +121,7 @@ cd renderer && npm install && npm start                    # only needed for vid
 | Launchpad | Calendar and agenda, auto posting to X, LinkedIn and Bluesky, email reminders, tracked links, engagement |
 | Archive | Every generated artifact with filters, players, downloads, retry and delete |
 | Resurfacing | Evergreen scores and reshare angles for old posts, on this day, straight into a kit or the calendar |
-| Settings | Profile, workspace, brand kit, privacy, plan usage meters, connections, sign out everywhere, delete |
+| Settings | Profile, workspace, privacy, plan usage meters, connections, sign out everywhere, delete |
 
 ## Key choices
 

backend/.env.example

@@ -0,0 +1,34 @@
+# Launchpad: posting to X and LinkedIn (copy what you need into .env)
+
+# Where the app and the API are reached. Both platforms send people back to
+# {API_URL}/api/social/{x,linkedin}/callback after they connect an account, so API_URL must be reachable from the
+# internet (when running locally, an https tunnel such as ngrok: API_URL=https://<id>.ngrok-free.app).
+FRONTEND_URL=http://localhost:5173
+API_URL=http://localhost:8000
+
+# X: developer.x.com > your app > Keys and tokens > "OAuth 2.0 Client ID and Client Secret"
+#   (not the API Key / Bearer Token). Then User authentication settings:
+#   App permissions: Read and write. Type of app: Web App (confidential client).
+#   Callback URI: {API_URL}/api/social/x/callback
+#   Scopes asked for: tweet.read tweet.write users.read offline.access media.write
+#   (media.write posts images and videos; accounts connected before it was added are asked to reconnect)
+# X is switched off for now (LinkedIn only). Set to true to bring it back.
+X_ENABLED=false
+X_CLIENT_ID=
+X_CLIENT_SECRET=
+
+# LinkedIn: linkedin.com/developers > your app > Auth > "Client ID" and "Primary Client Secret"
+#   Products: "Sign In with LinkedIn using OpenID Connect" and "Share on LinkedIn".
+#   Auth > Authorized redirect URLs: {API_URL}/api/social/linkedin/callback
+#   Scopes asked for: openid profile w_member_social
+#   LinkedIn tokens last about 60 days; then the account shows Reconnect.
+LINKEDIN_CLIENT_ID=
+LINKEDIN_CLIENT_SECRET=
+
+# Connections: X tokens are refreshed automatically (every 10 minutes the worker checks them, and every 6 hours asks
+# each platform whether the connection still works). When a connection goes down, its scheduled posts are paused and
+# never attempted; reconnecting the same account resumes the ones still ahead.
+
+# Encrypts the stored social tokens (a Fernet key). Empty: derived from JWT_SECRET.
+# Make one with: python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
+SOCIAL_TOKEN_KEY=

backend/0

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

backend/Dockerfile

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

backend/alembic/versions/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,74 @@
+"""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),
+        )
+    # Columns a later migration drops (brand_kit) are not in a table 0001 built from today's models: seed what exists.
+    have = {c["name"] for c in sa.inspect(bind).get_columns("plans")}
+    seed = [{k: v for k, v in p.items() if k in have} for p in SEED]
+    types = {"features": sa.JSON(), "voice_cloning": sa.Boolean(), "brand_kit": sa.Boolean(),
+             "created_at": sa.DateTime(timezone=True), "updated_at": sa.DateTime(timezone=True)}
+    plans = sa.table("plans", *(sa.column(k, types.get(k)) for k in [*seed[0], "created_at", "updated_at"]))
+    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/0013_workspace_memory.py

@@ -0,0 +1,32 @@
+"""workspace_memory: one row of standing notes per workspace, stored as JSON
+
+Revision ID: 0013_workspace_memory
+Revises: 0012_artifact_status_len
+Create Date: 2026-09-30
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0013_workspace_memory"
+down_revision = "0012_artifact_status_len"
+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 "workspace_memory" in sa.inspect(op.get_bind()).get_table_names():
+        return
+    op.create_table(
+        "workspace_memory",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("facts", sa.JSON(), nullable=False, server_default="{}"),
+    )
+    op.create_index("ix_workspace_memory_workspace_id", "workspace_memory", ["workspace_id"], unique=True)
+
+
+def downgrade() -> None:
+    op.drop_table("workspace_memory")

backend/alembic/versions/0014_chat_citations.py

@@ -0,0 +1,30 @@
+"""citations.kind: a citation can point at an earlier chat (no document) as well as a post
+
+Revision ID: 0014_chat_citations
+Revises: 0013_workspace_memory
+Create Date: 2026-10-01
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0014_chat_citations"
+down_revision = "0013_workspace_memory"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the column.
+    columns = {c["name"]: c for c in sa.inspect(op.get_bind()).get_columns("citations")}
+    with op.batch_alter_table("citations") as b:
+        if "kind" not in columns:
+            b.add_column(sa.Column("kind", sa.String(10), nullable=False, server_default="post"))
+        if not columns["document_id"]["nullable"]:
+            b.alter_column("document_id", existing_type=sa.Uuid(), nullable=True)
+
+
+def downgrade() -> None:
+    op.execute("DELETE FROM citations WHERE document_id IS NULL")  # a chat citation has no document to point at
+    with op.batch_alter_table("citations") as b:
+        b.alter_column("document_id", existing_type=sa.Uuid(), nullable=False)
+        b.drop_column("kind")

backend/alembic/versions/0015_message_feedback.py

@@ -0,0 +1,48 @@
+"""message_feedback: thumbs up/down on chat answers, plus messages.recall_json (how the answer was produced)
+
+Revision ID: 0015_message_feedback
+Revises: 0014_chat_citations
+Create Date: 2026-10-02
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0015_message_feedback"
+down_revision = "0014_chat_citations"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have these.
+    insp = sa.inspect(op.get_bind())
+    if "recall_json" not in {c["name"] for c in insp.get_columns("messages")}:
+        with op.batch_alter_table("messages") as b:
+            b.add_column(sa.Column("recall_json", sa.JSON(), nullable=True))
+    if "message_feedback" in insp.get_table_names():
+        return
+    op.create_table(
+        "message_feedback",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("notebook_id", sa.Uuid(), sa.ForeignKey("notebooks.id", ondelete="SET NULL")),
+        sa.Column("chat_id", sa.Uuid(), sa.ForeignKey("chats.id", ondelete="SET NULL")),
+        sa.Column("message_id", sa.Uuid(), sa.ForeignKey("messages.id", ondelete="SET NULL")),
+        sa.Column("rating", sa.Integer(), nullable=False),
+        sa.Column("reasons", sa.JSON(), nullable=False),
+        sa.Column("comment", sa.Text()),
+        sa.Column("question", sa.Text(), nullable=False),
+        sa.Column("answer", sa.Text(), nullable=False),
+        sa.Column("sources", sa.JSON(), nullable=False),
+        sa.Column("recall", sa.JSON(), nullable=False),
+    )
+    op.create_index("ix_message_feedback_workspace_id", "message_feedback", ["workspace_id"])
+    op.create_index("ix_message_feedback_message_id", "message_feedback", ["message_id"], unique=True)
+
+
+def downgrade() -> None:
+    op.drop_table("message_feedback")
+    with op.batch_alter_table("messages") as b:
+        b.drop_column("recall_json")

backend/alembic/versions/0016_support_chat.py

@@ -0,0 +1,50 @@
+"""support_chat: conversations and messages for the in app help bot
+
+Revision ID: 0016_support_chat
+Revises: 0015_message_feedback
+Create Date: 2026-10-06
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0016_support_chat"
+down_revision = "0015_message_feedback"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have these.
+    if "support_conversations" in sa.inspect(op.get_bind()).get_table_names():
+        return
+    op.create_table(
+        "support_conversations",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("user_id", sa.Uuid(), sa.ForeignKey("users.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("title", sa.String(200)),
+        sa.Column("summary", sa.Text(), nullable=False, server_default=""),
+        sa.Column("session_state", sa.JSON(), nullable=False),
+        sa.Column("escalation_count", sa.Integer(), nullable=False, server_default="0"),
+    )
+    op.create_index("ix_support_conversations_user_id", "support_conversations", ["user_id"])
+    op.create_table(
+        "support_messages",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column(
+            "conversation_id", sa.Uuid(), sa.ForeignKey("support_conversations.id", ondelete="CASCADE"), nullable=False
+        ),
+        sa.Column("role", sa.String(20), nullable=False),
+        sa.Column("content", sa.Text(), nullable=False),
+        sa.Column("page_path", sa.String(300)),
+        sa.Column("cited_docs", sa.JSON()),
+    )
+    op.create_index("ix_support_messages_conversation_id", "support_messages", ["conversation_id"])
+
+
+def downgrade() -> None:
+    op.drop_table("support_messages")
+    op.drop_table("support_conversations")

backend/alembic/versions/0017_reports_limit.py

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

backend/alembic/versions/0018_report_sharing.py

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

backend/alembic/versions/0019_infographics_limit.py

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

backend/alembic/versions/0020_calendar_kit.py

@@ -0,0 +1,35 @@
+"""calendar_items.kit_id: the Launch Kit a scheduled post was written from, kept apart from its attachment
+
+Revision ID: 0020_calendar_kit
+Revises: 0019_infographics_limit
+Create Date: 2026-10-06
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0020_calendar_kit"
+down_revision = "0019_infographics_limit"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 0001 builds from the live models, so a fresh database may already have the column.
+    if "kit_id" not in {c["name"] for c in sa.inspect(op.get_bind()).get_columns("calendar_items")}:
+        with op.batch_alter_table("calendar_items") as batch:
+            batch.add_column(sa.Column("kit_id", sa.Uuid(), nullable=True))
+            batch.create_foreign_key("fk_calendar_items_kit_id", "artifacts", ["kit_id"], ["id"], ondelete="SET NULL")
+    # Posts that carried a Launch Kit as their "attachment": the kit is where they came from, not an attachment.
+    op.execute("UPDATE calendar_items SET kit_id = artifact_id, artifact_id = NULL "
+               "WHERE artifact_id IN (SELECT id FROM artifacts WHERE type = 'launch_kit')")
+
+
+def downgrade() -> None:
+    op.execute("UPDATE calendar_items SET artifact_id = kit_id WHERE artifact_id IS NULL AND kit_id IS NOT NULL")
+    # The foreign key is named here, or by the database when 0001 made the column from the models.
+    fks = [fk["name"] for fk in sa.inspect(op.get_bind()).get_foreign_keys("calendar_items")
+           if fk["constrained_columns"] == ["kit_id"] and fk.get("name")]
+    with op.batch_alter_table("calendar_items") as batch:
+        for name in fks:
+            batch.drop_constraint(name, type_="foreignkey")
+        batch.drop_column("kit_id")

backend/alembic/versions/0021_artifact_feedback.py

@@ -0,0 +1,40 @@
+"""artifact_feedback: thumbs up/down on generated reports, quizzes, flashcards and infographics
+
+Revision ID: 0021_artifact_feedback
+Revises: 0020_calendar_kit
+Create Date: 2026-10-08
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0021_artifact_feedback"
+down_revision = "0020_calendar_kit"
+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 "artifact_feedback" in sa.inspect(op.get_bind()).get_table_names():
+        return
+    op.create_table(
+        "artifact_feedback",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("artifact_id", sa.Uuid(), sa.ForeignKey("artifacts.id", ondelete="SET NULL")),
+        sa.Column("user_id", sa.Uuid(), sa.ForeignKey("users.id", ondelete="SET NULL")),
+        sa.Column("artifact_type", sa.String(30), nullable=False),
+        sa.Column("rating", sa.Integer(), nullable=False),
+        sa.Column("reasons", sa.JSON(), nullable=False),
+        sa.Column("comment", sa.Text()),
+        sa.Column("snapshot", sa.JSON(), nullable=False),
+        sa.UniqueConstraint("artifact_id", "user_id"),
+    )
+    op.create_index("ix_artifact_feedback_workspace_id", "artifact_feedback", ["workspace_id"])
+    op.create_index("ix_artifact_feedback_artifact_id", "artifact_feedback", ["artifact_id"])
+
+
+def downgrade() -> None:
+    op.drop_table("artifact_feedback")

backend/alembic/versions/0022_report_template_cache.py

@@ -0,0 +1,34 @@
+"""report_template_cache: suggested report templates kept, so the Create report dialog is instant
+
+Revision ID: 0022_report_template_cache
+Revises: 0021_artifact_feedback
+Create Date: 2026-10-08
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0022_report_template_cache"
+down_revision = "0021_artifact_feedback"
+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 "report_template_cache" in sa.inspect(op.get_bind()).get_table_names():
+        return
+    op.create_table(
+        "report_template_cache",
+        sa.Column("id", sa.Uuid(), primary_key=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("workspace_id", sa.Uuid(), sa.ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False),
+        sa.Column("key", sa.String(64), nullable=False),
+        sa.Column("templates", sa.JSON(), nullable=False),
+        sa.UniqueConstraint("workspace_id", "key"),
+    )
+    op.create_index("ix_report_template_cache_workspace_id", "report_template_cache", ["workspace_id"])
+
+
+def downgrade() -> None:
+    op.drop_table("report_template_cache")

backend/alembic/versions/0023_drop_brand_kit.py

@@ -0,0 +1,31 @@
+"""drop_brand_kit: the brand kit (workspace colors and logo, and the plan flag for it) is gone
+
+Revision ID: 0023_drop_brand_kit
+Revises: 0022_report_template_cache
+Create Date: 2026-10-08
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0023_drop_brand_kit"
+down_revision = "0022_report_template_cache"
+branch_labels = None
+depends_on = None
+
+
+def _has(table: str, column: str) -> bool:
+    return column in {c["name"] for c in sa.inspect(op.get_bind()).get_columns(table)}
+
+
+def upgrade() -> None:
+    for table, column in (("plans", "brand_kit"), ("workspaces", "brand_json")):
+        if _has(table, column):
+            with op.batch_alter_table(table) as batch:
+                batch.drop_column(column)
+
+
+def downgrade() -> None:
+    if not _has("plans", "brand_kit"):
+        op.add_column("plans", sa.Column("brand_kit", sa.Boolean(), nullable=False, server_default=sa.false()))
+    if not _has("workspaces", "brand_json"):
+        op.add_column("workspaces", sa.Column("brand_json", sa.JSON(), nullable=True))

backend/alembic/versions/0024_plan_limits.py

@@ -0,0 +1,49 @@
+"""plan_limits: posts indexed across every source, Free allowances that are totals, new Writer and Studio numbers
+
+Revision ID: 0024_plan_limits
+Revises: 0023_drop_brand_kit
+Create Date: 2026-10-08
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0024_plan_limits"
+down_revision = "0023_drop_brand_kit"
+branch_labels = None
+depends_on = None
+
+PLANS = {
+    "free": dict(sources=-1, indexed_posts=5, audio_minutes=-1, audio_overviews=1, videos=2, launch_kits=2, reports=2,
+                 infographics=2, videos_monthly=False, features=[
+                     "Up to 5 posts indexed, from any source", "Grounded research chat with citations",
+                     "1 audio overview, any length", "2 videos", "2 Launch Kits", "2 infographics", "2 reports a month"]),
+    "writer": dict(sources=-1, indexed_posts=100, audio_minutes=60, audio_overviews=-1, videos=10, launch_kits=20,
+                   reports=30, infographics=30, features=[
+                       "Up to 100 posts indexed, from any source", "60 min of audio overviews a month", "10 videos a month",
+                       "20 Launch Kits a month", "30 reports a month", "30 infographics a month",
+                       "Voice cloning with consent"]),
+    "studio": dict(sources=-1, indexed_posts=250, audio_minutes=240, audio_overviews=-1, videos=20, launch_kits=50,
+                   reports=-1, infographics=-1, features=[
+                       "Up to 250 posts indexed, from any source", "240 min of audio overviews a month",
+                       "20 videos a month", "50 Launch Kits a month", "Unlimited reports", "Unlimited infographics",
+                       "Launchpad calendar and resurfacing", "Priority rendering"]),
+}
+
+
+def upgrade() -> None:
+    columns = {c["name"] for c in sa.inspect(op.get_bind()).get_columns("plans")}
+    if "audio_overviews" not in columns:
+        op.add_column("plans", sa.Column("audio_overviews", sa.Integer(), nullable=False, server_default="-1"))
+    plans = sa.table("plans", sa.column("id", sa.String), sa.column("sources", sa.Integer),
+                     sa.column("indexed_posts", sa.Integer), sa.column("audio_minutes", sa.Integer),
+                     sa.column("audio_overviews", sa.Integer), sa.column("videos", sa.Integer),
+                     sa.column("launch_kits", sa.Integer), sa.column("reports", sa.Integer),
+                     sa.column("infographics", sa.Integer), sa.column("videos_monthly", sa.Boolean),
+                     sa.column("features", sa.JSON))
+    for plan_id, values in PLANS.items():
+        op.execute(plans.update().where(plans.c.id == plan_id).values(**values))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("plans") as batch:
+        batch.drop_column("audio_overviews")

backend/alembic/versions/0025_drop_video_premium.py

@@ -0,0 +1,24 @@
+"""drop_video_premium: the premium video options are gone, so is the plan flag for them
+
+Revision ID: 0025_drop_video_premium
+Revises: 0024_plan_limits
+Create Date: 2026-10-08
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0025_drop_video_premium"
+down_revision = "0024_plan_limits"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    if "video_premium" in {c["name"] for c in sa.inspect(op.get_bind()).get_columns("plans")}:
+        with op.batch_alter_table("plans") as batch:
+            batch.drop_column("video_premium")
+
+
+def downgrade() -> None:
+    if "video_premium" not in {c["name"] for c in sa.inspect(op.get_bind()).get_columns("plans")}:
+        op.add_column("plans", sa.Column("video_premium", sa.Boolean(), nullable=False, server_default=sa.false()))

backend/alembic/versions/0026_plan_copy.py

@@ -0,0 +1,40 @@
+"""plan_copy: Free gets 1 video; Writer and Studio audio copy is relative to Free
+
+Revision ID: 0026_plan_copy
+Revises: 0025_drop_video_premium
+Create Date: 2026-10-08
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "0026_plan_copy"
+down_revision = "0025_drop_video_premium"
+branch_labels = None
+depends_on = None
+
+SWAPS = {
+    "free": {"2 videos": "1 video"},
+    "writer": {"60 min of audio overviews a month": "10x more audio overviews than Free (60 min a month)"},
+    "studio": {"240 min of audio overviews a month": "40x more audio overviews than Free (240 min a month)"},
+}
+
+
+def _swap(rows: dict) -> None:
+    plans = sa.table("plans", sa.column("id", sa.String), sa.column("videos", sa.Integer), sa.column("features", sa.JSON))
+    bind = op.get_bind()
+    for plan_id, swaps in rows.items():
+        features = bind.execute(sa.select(plans.c.features).where(plans.c.id == plan_id)).scalar()
+        if features is None:
+            continue
+        values = {"features": [swaps.get(f, f) for f in features]}
+        if plan_id == "free":
+            values["videos"] = 1 if "1 video" in swaps.values() else 2
+        op.execute(plans.update().where(plans.c.id == plan_id).values(**values))
+
+
+def upgrade() -> None:
+    _swap(SWAPS)
+
+
+def downgrade() -> None:
+    _swap({k: {v: o for o, v in d.items()} for k, d in SWAPS.items()})

backend/app/chat_memory/__init__.py

@@ -0,0 +1,5 @@
+"""Chat memory: a notebook's chats kept as topic files in R2, so a chat can pick up where it left off and a writer can
+ask about something said earlier. See docs/CHAT_RECALL_IMPLEMENTATION.md.
+
+The database keeps every message. This package keeps what was learned from them: a summary, keywords and a few
+exact quotes per topic. Only the background job writes these files (organize.py)."""

backend/app/chat_memory/context.py

@@ -0,0 +1,260 @@
+"""The read path of chat memory: before an answer, decide how much of the chat's memory the research agent needs and
+build it as one small text block.
+
+Everything the answer step needs from the database is loaded up front by `load_chat_memory` (in the request, with its
+session), so the research agent runs in its thread with plain data and no database access.
+
+How much memory a message needs is the `memory` decision made by triage:
+  none     a fresh question about the posts: nothing extra
+  lookup   a follow up on a topic: that topic's summary and its last few rounds word for word
+  replay   "what exactly did you say": the topic's saved exact words, and the chat tools to go further
+  compose  a reference to earlier conversations in general: the notebook's topic list, and the chat tools"""
+
+import logging
+import uuid
+from dataclasses import dataclass, field
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.chat_memory import files
+from app.chat_memory.files import Topic, TopicsFile
+from app.chat_memory.organize import after_through, chat_corpus, ordered_messages, read_topic, read_topics_file
+from app.config import settings
+from app.corpus import Corpus
+from app.models import Message
+
+log = logging.getLogger(__name__)
+
+MEMORY_LEVELS = ("none", "lookup", "replay", "compose")
+BACKLOG_MESSAGES = 6  # unprocessed messages older than the history window that are added back
+INDEX_PREVIEW_LINES = 20
+TURN_CHARS = 500
+
+# Jev choices (see pipeline/research.py triage_with_jev)
+JEV_MEMORY = {
+    "none": {
+        "what": "A new question about the writer's posts that makes sense on its own, with no reference to anything "
+                "said earlier in the conversation",
+        "examples": ["What have I written about pricing?", "Summarize my post on habits"],
+    },
+    "lookup": {
+        "what": "A follow up that continues a topic from earlier in this chat and needs to know what was discussed",
+        "examples": ["Which of those benchmarks is best?", "Say more about the second point", "Go on"],
+    },
+    "replay": {
+        "what": "Asks what the assistant or the writer said earlier in this chat, or points at a specific earlier "
+                "answer or instruction",
+        "examples": ["What exactly did you say about MMLU?", "You listed three options earlier, what were they?",
+                     "Use the format I asked for before"],
+    },
+    "compose": {
+        "what": "Refers to an earlier conversation or an earlier time, not just the current topic",
+        "examples": ["What did I ask about pricing last week?", "In another chat we talked about churn",
+                     "Did I ever ask about Obama?"],
+    },
+}
+JEV_MEMORY_QUESTION = "How much memory of earlier conversation does the latest message need?"
+JEV_TOPIC_NONE = {"what": "A new subject that is none of the topics above, or a plain question about the posts"}
+
+
+def topic_question(tf: TopicsFile) -> dict | None:
+    """The Jev question that picks which topic of this chat a message belongs to."""
+    shown = sorted(tf.entries, key=lambda e: e.last, reverse=True)[:settings.chat_memory_topics_shown]
+    if not shown:
+        return None
+    criteria = {e.slug: {"what": f"{e.label}: {e.gist}. Words used: {e.keywords}"} for e in shown}
+    criteria["none"] = JEV_TOPIC_NONE
+    return {"instructions": "Which earlier topic of this conversation does the latest message belong to?",
+            "criteria": criteria}
+
+
+def topics_digest(tf: TopicsFile) -> str:
+    """A few lines for the triage model: the topics of this chat and when each was last active."""
+    shown = sorted(tf.entries, key=lambda e: e.last, reverse=True)[:settings.chat_memory_topics_shown]
+    return "\n".join(f"{e.slug} | {e.label} | last active {e.last} | {e.gist}" for e in shown) or "(none)"
+
+
+@dataclass
+class Said:
+    role: str  # writer | assistant
+    text: str
+    date: str
+
+
+@dataclass
+class ChatMemory:
+    """Everything the read path needs, loaded in advance."""
+
+    corpus: Corpus
+    chat_id: str
+    tf: TopicsFile
+    topics: dict[str, Topic] = field(default_factory=dict)
+    messages: dict[str, Said] = field(default_factory=dict)  # by message id
+    backlog: list[Said] = field(default_factory=list)  # processed late: older than the history window, oldest first
+    index_preview: str = ""
+
+    @property
+    def has_anything(self) -> bool:
+        return bool(self.tf.entries or self.index_preview)
+
+    def latest(self) -> str | None:
+        return max(self.tf.entries, key=lambda e: e.last).slug if self.tf.entries else None
+
+
+def load_chat_memory(db: Session, workspace_id: uuid.UUID, notebook_id: uuid.UUID, chat_id: uuid.UUID,
+                     history_ids: set[str], corpus: Corpus | None = None) -> ChatMemory | None:
+    """None when the read path is off, there is nothing remembered yet, or anything goes wrong: the chat then works as
+    it always has, from the last few messages."""
+    if not settings.chat_memory_read:
+        return None
+    try:
+        corpus = corpus or chat_corpus(workspace_id, notebook_id)
+        corpus.sync()
+        mem = ChatMemory(corpus=corpus, chat_id=str(chat_id), tf=read_topics_file(corpus, chat_id))
+        if corpus.exists(files.INDEX):
+            mem.index_preview = "\n".join(corpus.read_lines(files.INDEX)[:INDEX_PREVIEW_LINES])
+        if not mem.has_anything:
+            return None
+        shown = sorted(mem.tf.entries, key=lambda e: e.last, reverse=True)[:settings.chat_memory_topics_shown]
+        for e in shown:
+            topic = read_topic(corpus, chat_id, e.slug)
+            if topic:
+                mem.topics[e.slug] = topic
+        ids = {uuid.UUID(i) for t in mem.topics.values() for i in t.recent if _is_uuid(i)}
+        if ids:
+            for m in db.scalars(select(Message).where(Message.id.in_(ids), Message.chat_id == chat_id)):
+                mem.messages[str(m.id)] = _said(m)
+        # Messages the job has not filed yet that the history window no longer covers (the job is far behind).
+        pending = [m for m in after_through(ordered_messages(db, chat_id), mem.tf.through)
+                   if str(m.id) not in history_ids]
+        mem.backlog = [_said(m) for m in pending[-BACKLOG_MESSAGES:]]
+        return mem
+    except Exception:
+        log.warning("Chat memory could not be loaded, continuing without it", exc_info=True)
+        return None
+
+
+def _is_uuid(value: str) -> bool:
+    try:
+        uuid.UUID(value)
+        return True
+    except ValueError:
+        return False
+
+
+def _said(m: Message) -> Said:
+    text = m.content if m.role == "user" else files.strip_markers(m.content)
+    return Said("writer" if m.role == "user" else "assistant", text, m.created_at.date().isoformat())
+
+
+def _turns(items: list[Said]) -> str:
+    return "\n".join(f"{s.role.capitalize()} ({s.date}): {files.squeeze(s.text, TURN_CHARS)}" for s in items)
+
+
+def line_refs(mem: ChatMemory, t: Topic) -> tuple[str, dict[str, int], int]:
+    """(the topic file's path as the agent sees it, line of each saved quote's first text line, line of the summary
+    text), so the block can say where every line lives and the agent can cite it."""
+    path = f"chats/{mem.chat_id}/{t.slug}.md"
+    quotes: dict[str, int] = {}
+    summary = 0
+    try:
+        for n, line in enumerate(mem.corpus.read_lines(files.topic_path(mem.chat_id, t.slug)), start=1):
+            if line.strip() == "## Summary":
+                summary = n + 2
+            for q in t.verbatim:
+                if line.startswith(f"[{q.message_id} "):
+                    quotes[q.message_id] = n + 1
+    except Exception:
+        log.warning("Could not read line numbers of %s", path, exc_info=True)
+    return path, quotes, summary
+
+
+def build_context(mem: ChatMemory, topic: str, memory: str) -> tuple[str, bool]:
+    """(the text block for the research agent, whether to give it the chat tools). An empty block means nothing."""
+    if memory not in ("lookup", "replay", "compose"):
+        return "", False
+    tools = memory in ("replay", "compose")
+    t = mem.topics.get(topic) or mem.topics.get(mem.latest() or "")
+    parts: list[str] = []
+    if memory in ("lookup", "replay") and t is not None:
+        path, quote_lines, summary_line = line_refs(mem, t)
+        parts.append(f"Topic: {t.label} (first {t.first}, last discussed {t.last}, {t.rounds} rounds). "
+                     "Context only, never evidence about the posts. To cite what was said earlier, use the file and "
+                     "line given in brackets.")
+        if memory == "replay" and t.verbatim:
+            parts.append("Exact words kept from this topic:\n" + "\n".join(
+                f"[{q.role}, {q.date}, {path}:{quote_lines.get(q.message_id, 1)}] "
+                f"{files.squeeze(q.text, files.MAX_VERBATIM_CHARS)}" for q in t.verbatim))
+        parts.append(f"Summary [{path}:{summary_line or 1}]: {t.summary}")
+        recent = [mem.messages[i] for i in t.recent if i in mem.messages][-settings.chat_memory_recent_rounds * 2:]
+        if memory == "lookup" and recent:
+            parts.append("Latest messages in this topic, word for word:\n" + _turns(recent))
+    elif memory in ("lookup", "replay") and not mem.backlog:
+        return "", tools  # no topic to load: replay still gets the tools to look around
+    if memory == "compose" or (tools and t is None):
+        parts.append("Earlier conversations in this notebook (use the chat tools to read them):\n"
+                     + (mem.index_preview or "(none yet)"))
+    if mem.backlog and memory in ("lookup", "replay"):
+        parts.append("Messages not yet filed under a topic:\n" + _turns(mem.backlog))
+    block = "\n\n".join(p for p in parts if p.strip())
+    if len(block) > settings.chat_memory_context_chars:
+        block = files.squeeze(block, settings.chat_memory_context_chars)
+    return block, tools
+
+
+def memory_decision(mem: ChatMemory | None, topic: str, memory: str, notes: str, with_tools: bool) -> str:
+    """A plain account, for the server log, of what chat memory did for one message: whether it was read, which topic
+    file the summary came from, and what of it went to the agent. Answers "which summary was passed, and from where"."""
+    lines = [context_banner(mem, topic, memory, notes),
+             f"CHAT_MEMORY_READ: {'on' if settings.chat_memory_read else 'OFF'}"]
+    if not settings.chat_memory_read:
+        lines.append("result: chat memory is not read. Only the last 8 messages are passed. Summaries are still being "
+                     "written to R2, but nothing is loaded from them. Set CHAT_MEMORY_READ=true and restart.")
+        return "\n".join(lines)
+    if mem is None:
+        lines.append("result: nothing loaded. This notebook has no chat memory yet, or loading it failed (look for a "
+                     "'Chat memory could not be loaded' warning above).")
+        return "\n".join(lines)
+    lines.append(f"loaded for this notebook: {len(mem.tf.entries)} topic(s) in this chat, "
+                 f"{len(mem.topics)} topic file(s) read, notebook index {'present' if mem.index_preview else 'empty'}")
+    lines.append(f"triage chose: topic={topic or '-'} memory={memory}")
+    t = mem.topics.get(topic) or mem.topics.get(mem.latest() or "")
+    if memory == "none" or (not notes and not with_tools):
+        lines.append("result: no summary passed (triage decided this message needs no memory of earlier chat).")
+        return "\n".join(lines)
+    if t is not None and memory in ("lookup", "replay"):
+        rel = files.topic_path(mem.chat_id, t.slug)
+        lines.append(f"summary source: {mem.corpus._key(rel)} (R2, read through the local cache)")
+        lines.append(f"  topic '{t.label}': {t.rounds} round(s), last discussed {t.last}, "
+                     f"summary {len(t.summary)} chars, {len(t.verbatim)} saved exact quote(s)")
+        passed = ["summary"]
+        recent = min(len(t.recent), settings.chat_memory_recent_rounds * 2)
+        passed.append(f"{len(t.verbatim)} exact quote(s)" if memory == "replay"
+                      else f"last {recent} messages of the topic (database)")
+        if mem.backlog:
+            passed.append(f"{len(mem.backlog)} message(s) not yet filed (database)")
+        lines.append("passed to the agent: " + " + ".join(passed))
+    elif memory == "compose":
+        lines.append("passed to the agent: the notebook's list of earlier topics (INDEX.md from R2) and the chat tools")
+    lines.append(f"chat tools given to the agent: {'yes' if with_tools else 'no'}")
+    return "\n".join(lines)
+
+
+def context_banner(mem: ChatMemory | None, topic: str, memory: str, notes: str) -> str:
+    """One line, for the server log, that says which summary was passed as context and whether the chat switched topic.
+    `mem.tf.current` is the topic the chat was just on, so a different topic now means the writer switched."""
+    if not settings.chat_memory_read:
+        return "=== NO SUMMARY PASSED as context: CHAT_MEMORY_READ is off ==="
+    if mem is None:
+        return "=== NO SUMMARY PASSED as context: this notebook has no chat memory yet (or it could not be loaded) ==="
+    if memory == "compose":
+        return "=== NO SINGLE SUMMARY: the notebook's list of earlier topics was passed as context ==="
+    t = mem.topics.get(topic) or mem.topics.get(mem.latest() or "")
+    if memory == "none" or t is None or not notes:
+        return "=== NO SUMMARY PASSED as context: this message needs no memory of earlier chat ==="
+    before = mem.topics.get(mem.tf.current)
+    if before is not None and before.slug != t.slug:
+        return (f"=== SUMMARY SWITCHED from '{before.label}' to '{t.label}': "
+                f"the summary of '{t.label}' was passed as context ({memory}) ===")
+    return f"=== SUMMARY CONTINUES on '{t.label}': the summary of '{t.label}' was passed as context ({memory}) ==="

backend/app/chat_memory/files.py

@@ -0,0 +1,237 @@
+"""The file formats of chat memory, as pure functions: render and parse.
+
+Layout, relative to the notebook's chat area (R2 `ws/{workspace}/chats/{notebook}/`):
+
+    INDEX.md                    one line per topic across every chat of the notebook
+    {chat_id}/TOPICS.md         this chat's topic list and the `through` pointer
+    {chat_id}/{slug}.md         one file per topic: summary, then exact quotes
+
+Every parser tolerates a missing or hand edited file by returning something empty, so one bad file never breaks a
+chat."""
+
+import re
+import uuid
+from dataclasses import dataclass, field
+
+from app.corpus import slugify
+
+TOPICS = "TOPICS.md"
+INDEX = "INDEX.md"
+MAX_TOPICS = 30  # lines kept in TOPICS.md; the least recently active are dropped from the list, never from the database
+MAX_VERBATIM = 10
+MAX_VERBATIM_CHARS = 1200
+MAX_RECENT = 8  # message ids kept per topic: the last four rounds
+MAX_KEYWORDS = 20
+
+SMALL_TALK = re.compile(
+    r"^\s*(hi|hey|hello|yo|hiya|good (morning|afternoon|evening)|thanks|thank you|thx|ty|cheers|ok(ay)?|"
+    r"cool|great|nice|awesome|perfect|got it|sounds good|bye|goodbye|see you|lol|haha)[\s!.,:)]*$",
+    re.IGNORECASE,
+)
+_MARKER = re.compile(r"\[(\d+)\]")
+_VERBATIM_HEAD = re.compile(r"^\[([0-9a-fA-F-]{36}) (writer|assistant) (\d{4}-\d{2}-\d{2})\]$")
+
+
+def chat_path(chat_id: uuid.UUID | str, name: str) -> str:
+    return f"{chat_id}/{name}"
+
+
+def topic_path(chat_id: uuid.UUID | str, slug: str) -> str:
+    return chat_path(chat_id, f"{slug}.md")
+
+
+def topic_slug(label: str) -> str:
+    return slugify(label, max_len=48)
+
+
+def one_line(text: str, limit: int = 200) -> str:
+    """A value that sits on one `a | b | c` line: no newlines, no pipes."""
+    return re.sub(r"\s+", " ", text.replace("|", "/")).strip()[:limit]
+
+
+def squeeze(text: str, limit: int) -> str:
+    """Shorten a long message by keeping its start and end, cut on word boundaries."""
+    text = text.strip()
+    if len(text) <= limit:
+        return text
+    half = limit // 2
+    head, tail = text[:half], text[-half:]
+    head = head.rsplit(" ", 1)[0] if " " in head else head
+    tail = tail.split(" ", 1)[1] if " " in tail else tail
+    return f"{head.rstrip()} ... {tail.lstrip()}"
+
+
+def strip_markers(text: str) -> str:
+    return re.sub(r"[ \t]+([.,;:!?])", r"\1", _MARKER.sub("", text))
+
+
+def clean_keywords(words: list[str]) -> list[str]:
+    seen: dict[str, None] = {}
+    for w in words:
+        w = one_line(str(w), 40).lower().replace(",", " ").strip()
+        if w and w not in seen:
+            seen[w] = None
+    return list(seen)[:MAX_KEYWORDS]
+
+
+def _front_matter(text: str) -> tuple[dict[str, str], str]:
+    """(key: value pairs, the rest) of a file that starts with a --- block."""
+    lines = text.splitlines()
+    if not lines or lines[0].strip() != "---":
+        return {}, text
+    meta: dict[str, str] = {}
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            return meta, "\n".join(lines[i + 1:])
+        if ":" in line:
+            key, _, value = line.partition(":")
+            meta[key.strip()] = value.strip()
+    return {}, text  # never closed: treat the file as unreadable front matter
+
+
+# TOPICS.md
+
+
+@dataclass
+class TopicEntry:
+    slug: str
+    label: str
+    last: str  # YYYY-MM-DD of the last round
+    rounds: int
+    keywords: str  # comma separated
+    gist: str
+
+
+@dataclass
+class TopicsFile:
+    chat_id: str = ""
+    through: str = ""  # id of the last message processed, "" before the first run
+    current: str = ""  # slug of the topic the newest filed round went to: what the chat was just talking about
+    updated: str = ""
+    entries: list[TopicEntry] = field(default_factory=list)
+
+    def get(self, slug: str) -> TopicEntry | None:
+        return next((e for e in self.entries if e.slug == slug), None)
+
+    @property
+    def slugs(self) -> set[str]:
+        return {e.slug for e in self.entries}
+
+
+def render_topics(tf: TopicsFile) -> str:
+    entries = sorted(tf.entries, key=lambda e: e.last, reverse=True)[:MAX_TOPICS]
+    lines = ["---", f"chat: {tf.chat_id}", f"through: {tf.through or 'none'}", f"current: {tf.current or 'none'}",
+             f"updated: {tf.updated}", "---"]
+    for e in entries:
+        lines.append(f"- {e.slug} | {one_line(e.label, 80)} | {e.last} | {e.rounds} rounds | "
+                     f"{one_line(e.keywords, 200)} | {one_line(e.gist, 200)}")
+    return "\n".join(lines) + "\n"
+
+
+def parse_topics(text: str) -> TopicsFile:
+    meta, body = _front_matter(text or "")
+    through = meta.get("through", "")
+    current = meta.get("current", "")
+    tf = TopicsFile(chat_id=meta.get("chat", ""), through="" if through in ("", "none") else through,
+                    current="" if current in ("", "none") else current, updated=meta.get("updated", ""))
+    for line in body.splitlines():
+        if not line.startswith("- "):
+            continue
+        parts = [p.strip() for p in line[2:].split("|")]
+        if len(parts) < 6:
+            continue
+        rounds = re.match(r"\d+", parts[3])
+        tf.entries.append(TopicEntry(slug=parts[0], label=parts[1], last=parts[2],
+                                     rounds=int(rounds.group()) if rounds else 0,
+                                     keywords=parts[4], gist="|".join(parts[5:])))
+    return tf
+
+
+# {slug}.md
+
+
+@dataclass
+class Quote:
+    message_id: str
+    role: str  # writer | assistant
+    date: str
+    text: str
+
+
+@dataclass
+class Topic:
+    label: str
+    slug: str
+    chat_id: str
+    first: str = ""
+    last: str = ""
+    rounds: int = 0
+    keywords: list[str] = field(default_factory=list)
+    gist: str = ""
+    recent: list[str] = field(default_factory=list)  # message ids, oldest first
+    last_message: str = ""  # the newest message filed here: a rerun after a crash skips rounds up to it
+    summary: str = ""
+    verbatim: list[Quote] = field(default_factory=list)
+
+
+def clean_summary(text: str, limit: int) -> str:
+    """The summary sits under a `## Summary` heading, so a heading inside it would break the file's sections."""
+    text = "\n".join(re.sub(r"^#+\s*", "", ln) for ln in (text or "").strip().splitlines())
+    return squeeze(text, limit) if len(text) > limit else text
+
+
+def render_topic(t: Topic) -> str:
+    lines = ["---", f"topic: {one_line(t.label, 80)}", f"slug: {t.slug}", f"chat: {t.chat_id}", f"first: {t.first}",
+             f"last: {t.last}", f"rounds: {t.rounds}", f"keywords: {', '.join(t.keywords)}",
+             f"gist: {one_line(t.gist, 200)}", f"recent: {', '.join(t.recent)}", f"last_message: {t.last_message}",
+             "---", "", "## Summary", "",
+             t.summary.strip(), "", "## Verbatim", ""]
+    for q in t.verbatim:
+        lines.append(f"[{q.message_id} {q.role} {q.date}]")
+        lines += [f"> {ln}" if ln else ">" for ln in q.text.splitlines()]
+        lines.append("")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def parse_topic(text: str) -> Topic | None:
+    meta, body = _front_matter(text or "")
+    if not meta.get("slug"):
+        return None
+    t = Topic(label=meta.get("topic", meta["slug"]), slug=meta["slug"], chat_id=meta.get("chat", ""),
+              first=meta.get("first", ""), last=meta.get("last", ""),
+              keywords=[k.strip() for k in meta.get("keywords", "").split(",") if k.strip()],
+              gist=meta.get("gist", ""), recent=[r.strip() for r in meta.get("recent", "").split(",") if r.strip()],
+              last_message=meta.get("last_message", ""))
+    rounds = re.match(r"\d+", meta.get("rounds", ""))
+    t.rounds = int(rounds.group()) if rounds else 0
+    section, summary, current = "", [], None
+    for line in body.splitlines():
+        if line.startswith("## "):
+            section = line[3:].strip().lower()
+            current = None
+            continue
+        if section == "summary":
+            summary.append(line)
+        elif section == "verbatim":
+            head = _VERBATIM_HEAD.match(line)
+            if head:
+                current = Quote(head.group(1), head.group(2), head.group(3), "")
+                t.verbatim.append(current)
+            elif current is not None and line.startswith(">"):
+                current.text += ("\n" if current.text else "") + line[1:].removeprefix(" ")
+    t.summary = "\n".join(summary).strip()
+    return t
+
+
+# INDEX.md (notebook level)
+
+
+def index_line(chat_id: str, entry: TopicEntry) -> str:
+    return (f"{entry.last} | {topic_path(chat_id, entry.slug)} | {one_line(entry.label, 80)} | "
+            f"{one_line(entry.keywords, 200)} | {one_line(entry.gist, 200)}")
+
+
+def render_index(per_chat: dict[str, list[TopicEntry]]) -> str:
+    """Newest first, one line per topic. Rebuilt from every chat's TOPICS.md, never edited in place."""
+    rows = [(e.last, index_line(chat, e)) for chat, entries in per_chat.items() for e in entries]
+    return "\n".join(line for _, line in sorted(rows, key=lambda r: r[0], reverse=True)) + ("\n" if rows else "")

backend/app/chat_memory/logs.py

@@ -0,0 +1,19 @@
+"""Server log switches for chat memory.
+
+Two loggers, because they hold different things:
+  notestack.chat_memory   what the summary job did: which chat, how many rounds, which R2 keys it wrote and how big. No
+                          writer text, so it is always on.
+  notestack.chat_context  what the research agent is given on each message, and the text of new summaries. That is
+                          writers' text, so it is on in development, or when CHAT_CONTEXT_LOG=true."""
+
+import logging
+
+from app.config import settings
+
+job_log = logging.getLogger("notestack.chat_memory")
+context_log = logging.getLogger("notestack.chat_context")
+
+
+def text_enabled() -> bool:
+    """Whether logs may contain writers' text: CHAT_CONTEXT_LOG if set, else on only in development."""
+    return settings.chat_context_log if settings.chat_context_log is not None else settings.env == "development"

backend/app/chat_memory/organize.py

@@ -0,0 +1,528 @@
+"""The write path of chat memory: after an answer, a background job files the new rounds of a chat under topics and
+updates each topic's summary, keywords and exact quotes.
+
+The database stays the source of truth for what was said. The model only chooses: which topic a round belongs to,
+what to write in a summary, and which messages (by short labels like m4) are worth keeping. Code does the rest: it
+maps labels back to real messages, copies the quotes out of the database word for word, validates everything the
+model returned, and writes the files in an order that makes a crash harmless (topic files, then the notebook index,
+then TOPICS.md with the `through` pointer last)."""
+
+import logging
+import re
+import uuid
+from dataclasses import dataclass, field
+from datetime import timedelta
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.chat_memory import files
+from app.chat_memory.files import INDEX, TOPICS, Quote, Topic, TopicEntry, TopicsFile
+from app.chat_memory.logs import context_log, job_log, text_enabled
+from app.config import settings
+from app.corpus import Corpus, CorpusError
+from app.llm import run
+from app.llm.provider import fast_lm
+from app.llm.signatures import OrganizeChat
+from app.models import Chat, Job, Message, Notebook
+from app.services.jobs import create_job, utcnow
+
+log = logging.getLogger(__name__)
+
+WRITER_CHARS = 600  # per message sent to the model
+ASSISTANT_CHARS = 900
+SUMMARIES_SHOWN = 12  # topics whose current summary is shown to the model
+SUMMARY_SHOWN_CHARS = 700
+FALLBACK_TOPIC = "General chat"
+# A new topic whose words overlap an existing topic's this much is the same topic, so its rounds join that one.
+MERGE_OVERLAP = 0.5  # shared words as a share of the smaller of the two word sets
+MERGE_MIN_SHARED = 4  # and at least this many shared words, so two short lists cannot match by luck
+REFUSAL_OPENING = "I only answer from the posts in this notebook"  # canned off-topic reply, rows saved before kinds
+
+
+def chat_corpus(workspace_id: uuid.UUID, notebook_id: uuid.UUID, store=None, cache_dir: str | None = None) -> Corpus:
+    """The notebook's chat area: its own manifest, disk cache and R2 prefix `ws/{workspace}/chats/{notebook}/`."""
+    return Corpus(workspace_id, store=store, cache_dir=cache_dir, area=f"chats/{notebook_id}")
+
+
+# Rounds
+
+
+@dataclass
+class Round:
+    label: str  # r1, r2, ...
+    writer: Message | None
+    assistant: Message | None
+
+    @property
+    def messages(self) -> list[Message]:
+        return [m for m in (self.writer, self.assistant) if m is not None]
+
+
+def ordered_messages(db: Session, chat_id: uuid.UUID) -> list[Message]:
+    """Oldest first. On a timestamp tie the writer's message comes before the reply ("user" sorts after "assistant")."""
+    return list(db.scalars(select(Message).where(Message.chat_id == chat_id)
+                           .order_by(Message.created_at, Message.role.desc())))
+
+
+def after_through(messages: list[Message], through: str) -> list[Message]:
+    if not through:
+        return messages
+    for i, m in enumerate(messages):
+        if str(m.id) == through:
+            return messages[i + 1:]
+    return messages  # the pointer names a message that is gone: start over rather than lose the chat
+
+
+def pair_rounds(messages: list[Message]) -> list[Round]:
+    """A writer message with the assistant message after it. A trailing writer message with no reply yet is left
+    for the next run, so its answer is filed together with it."""
+    rounds: list[Round] = []
+    i = 0
+    while i < len(messages):
+        m = messages[i]
+        if m.role == "user":
+            nxt = messages[i + 1] if i + 1 < len(messages) else None
+            if nxt is not None and nxt.role == "assistant":
+                rounds.append(Round("", m, nxt))
+                i += 2
+                continue
+            if nxt is None:
+                break  # waiting for the answer
+            rounds.append(Round("", m, None))
+        else:
+            rounds.append(Round("", None, m))
+        i += 1
+    for n, r in enumerate(rounds, start=1):
+        r.label = f"r{n}"
+    return rounds
+
+
+def _post_paths(m: Message) -> list[str]:
+    return sorted({c.path for c in m.citations if getattr(c, "kind", "post") == "post"})
+
+
+def render_rounds(rounds: list[Round]) -> tuple[str, dict[str, Message]]:
+    """The prompt text for the rounds, and the table from short labels (m1, m2) back to real messages. The model
+    never sees or writes a real id."""
+    labels: dict[str, Message] = {}
+    out: list[str] = []
+    n = 0
+    for r in rounds:
+        out.append(r.label)
+        for m in r.messages:
+            n += 1
+            label = f"m{n}"
+            labels[label] = m
+            if m.role == "user":
+                out.append(f"{label} Writer: {files.squeeze(m.content, WRITER_CHARS)}")
+            else:
+                out.append(f"{label} Assistant: {files.squeeze(files.strip_markers(m.content), ASSISTANT_CHARS)}")
+                posts = _post_paths(m)
+                if posts:
+                    out.append(f"    (posts used: {', '.join(posts)})")
+        out.append("")
+    return "\n".join(out).strip(), labels
+
+
+# Reading the current state
+
+
+def read_topics_file(corpus: Corpus, chat_id: uuid.UUID | str) -> TopicsFile:
+    path = files.chat_path(chat_id, TOPICS)
+    try:
+        if corpus.exists(path):
+            tf = files.parse_topics("\n".join(corpus.read_lines(path)))
+            tf.chat_id = tf.chat_id or str(chat_id)
+            return tf
+    except (CorpusError, OSError):
+        log.warning("Unreadable %s, starting that chat's topics over", path, exc_info=True)
+    return TopicsFile(chat_id=str(chat_id))
+
+
+def read_topic(corpus: Corpus, chat_id: uuid.UUID | str, slug: str) -> Topic | None:
+    path = files.topic_path(chat_id, slug)
+    try:
+        return files.parse_topic("\n".join(corpus.read_lines(path))) if corpus.exists(path) else None
+    except (CorpusError, OSError):
+        return None
+
+
+def topics_prompt(corpus: Corpus, chat_id: uuid.UUID | str, tf: TopicsFile) -> tuple[str, set[str]]:
+    """The topics so far for the model, and which of them had their summary shown."""
+    if not tf.entries:
+        return "(none)", set()
+    entries = sorted(tf.entries, key=lambda e: e.last, reverse=True)
+    lines = [f"{e.slug} | {e.label} | {e.gist} | {e.keywords}" for e in entries]
+    shown: set[str] = set()
+    blocks: list[str] = []
+    for e in entries[:SUMMARIES_SHOWN]:
+        topic = read_topic(corpus, chat_id, e.slug)
+        if topic and topic.summary:
+            shown.add(e.slug)
+            blocks.append(f"Summary of {e.slug}: {files.squeeze(topic.summary, SUMMARY_SHOWN_CHARS)}")
+    return "\n".join(lines + [""] + blocks), shown
+
+
+# Reading the model's answer
+
+
+@dataclass
+class Plan:
+    """What the model decided, checked against reality: slug -> rounds, plus the update for each slug."""
+
+    rounds: dict[str, list[Round]] = field(default_factory=dict)
+    labels: dict[str, str] = field(default_factory=dict)  # slug -> label for topics that are new
+    updates: dict[str, dict] = field(default_factory=dict)
+    extend: set[str] = field(default_factory=set)  # existing topics a new topic was merged into: extend, not replace
+    merged: dict[str, str] = field(default_factory=dict)  # new slug -> the existing slug it was folded into
+
+
+def _resolve(raw: str, known: dict[str, str], plan: Plan) -> str | None:
+    """A slug for the model's topic string, or None for SKIP. `known` maps slug -> label for existing topics."""
+    raw = (raw or "").strip()
+    if not raw or raw.upper() == "SKIP":
+        return None
+    if raw.upper().startswith("NEW:"):
+        label = raw[4:].strip() or FALLBACK_TOPIC
+    elif raw in known or raw in plan.labels:
+        return raw
+    else:
+        label = raw.replace("-", " ").strip() or FALLBACK_TOPIC
+    slug = files.topic_slug(label)
+    if slug not in known:
+        plan.labels.setdefault(slug, label[:80])
+    return slug
+
+
+# Answers that were not about the writer's posts: the question was turned down, answered from the app's help text, or
+# was small talk. They say nothing about the posts, and filing them adds a topic every later message has to be weighed
+# against. `kind` is saved with every answer (recall_json) by the chat endpoint.
+NOT_ABOUT_THE_POSTS = {"off_topic", "about_app", "chitchat", "error"}  # error: the "please send that again" reply
+
+
+def is_off_topic(r: Round) -> bool:
+    """True when the assistant's answer was not about the posts (see NOT_ABOUT_THE_POSTS), so the round is not filed."""
+    a = r.assistant
+    if a is None:
+        return False
+    kind = (a.recall_json or {}).get("kind")
+    if kind:
+        return kind in NOT_ABOUT_THE_POSTS
+    return not a.citations and a.content.strip().startswith(REFUSAL_OPENING)  # an answer saved before kinds existed
+
+
+_STOPWORDS = {"the", "and", "for", "with", "from", "that", "this", "what", "how", "about", "post", "posts", "chat",
+              "writer", "assistant", "question", "answer", "per", "its", "are", "was", "has", "have"}
+
+
+def _tokens(text: str) -> set[str]:
+    """Lower case words, with a plural s dropped, so "agents" and "agent" count as one word."""
+    words = re.findall(r"[a-z0-9]+", text.lower())
+    return {w[:-1] if len(w) > 4 and w.endswith("s") else w for w in words if len(w) >= 3 and w not in _STOPWORDS}
+
+
+def merge_close_topics(plan: Plan, tf: TopicsFile) -> None:
+    """Fold a brand new topic into an existing one when their keywords mostly agree. The model reads a short topic
+    list and tends to open a fresh topic for a follow up that really continues an old one, which splits one subject
+    across several files. Different questions on a related theme (few shared words) stay apart."""
+    for slug in [s for s in plan.labels if s in plan.rounds and not tf.get(s)]:
+        update = plan.updates.get(slug) or {}
+        mine = _tokens(f"{plan.labels[slug]} {' '.join(str(k) for k in update.get('keywords') or [])}")
+        best: tuple[float, int, str] | None = None
+        for e in tf.entries:
+            theirs = _tokens(f"{e.label} {e.keywords}")
+            shared = len(mine & theirs)
+            score = shared / max(min(len(mine), len(theirs)), 1)
+            if shared >= MERGE_MIN_SHARED and score >= MERGE_OVERLAP and (best is None or score > best[0]):
+                best = (score, shared, e.slug)
+        if best is None:
+            continue
+        target = best[2]
+        plan.rounds.setdefault(target, []).extend(plan.rounds.pop(slug))
+        plan.rounds[target].sort(key=lambda r: int(r.label[1:]))
+        plan.labels.pop(slug, None)
+        plan.updates.pop(slug, None)
+        plan.merged[slug] = target
+        there = plan.updates.get(target)
+        if there is None:
+            # The model wrote this summary for the new topic alone: it is added to the old one, and the old gist stays.
+            plan.updates[target] = {k: v for k, v in update.items() if k not in {"topic", "gist"}} | {"topic": target}
+            plan.extend.add(target)
+        else:  # the model also updated the old topic in this run: join the two updates
+            there["summary"] = f"{there.get('summary', '')} {update.get('summary', '')}".strip()
+            there["keywords"] = list(there.get("keywords") or []) + list(update.get("keywords") or [])
+            there["keep"] = list(there.get("keep") or []) + list(update.get("keep") or [])
+        job_log.info("chat memory: new topic '%s' overlaps '%s' (%d shared words, %.0f%%), so its rounds were filed "
+                     "there instead", slug, target, best[1], best[0] * 100)
+
+
+def _is_small_talk(r: Round) -> bool:
+    """SKIP is for greetings and thanks only. The model is asked that, but a real follow up it skipped is not lost."""
+    return r.writer is not None and bool(files.SMALL_TALK.match(r.writer.content))
+
+
+def build_plan(out: dict, batch: list[Round], labels: dict[str, Message], tf: TopicsFile) -> Plan:
+    plan = Plan()
+    known = {e.slug: e.label for e in tf.entries}
+    by_label = {r.label: r for r in batch}
+    chosen: dict[str, str | None] = {}  # round label -> slug, or None for SKIP
+    for a in out.get("assignments") or []:
+        label = str(a.get("round", "")).strip()
+        if label in by_label and label not in chosen:
+            chosen[label] = _resolve(a.get("topic", ""), known, plan)
+    previous = max(tf.entries, key=lambda e: e.last).slug if tf.entries else None
+    for r in batch:  # a round the model forgot, or skipped though it is a real question, is filed with the one before
+        if r.label not in chosen or (chosen[r.label] is None and not _is_small_talk(r)):
+            chosen[r.label] = previous or _resolve(f"NEW:{FALLBACK_TOPIC}", known, plan)
+        if chosen[r.label] is not None:
+            previous = chosen[r.label]
+            plan.rounds.setdefault(chosen[r.label], []).append(r)
+    for u in out.get("updates") or []:
+        slug = _resolve(u.get("topic", ""), known, plan)
+        if slug is not None and slug in plan.rounds:  # an update for a topic that got no rounds is ignored
+            plan.updates[slug] = u
+    for rs in plan.rounds.values():
+        rs.sort(key=lambda r: int(r.label[1:]))
+    merge_close_topics(plan, tf)
+    return plan
+
+
+def _date(m: Message) -> str:
+    return m.created_at.date().isoformat() if m.created_at else utcnow().date().isoformat()
+
+
+def _quote(m: Message) -> Quote:
+    text = m.content if m.role == "user" else files.strip_markers(m.content)
+    text = text.strip()
+    if len(text) > files.MAX_VERBATIM_CHARS:
+        text = text[:files.MAX_VERBATIM_CHARS].rstrip() + " [...]"
+    return Quote(str(m.id), "writer" if m.role == "user" else "assistant", _date(m), text)
+
+
+def apply_plan(plan: Plan, existing: dict[str, Topic], shown: set[str], chat_id: str,
+               labels: dict[str, Message], position: dict[str, int]) -> dict[str, Topic]:
+    """The new state of every topic that got rounds. Quotes are copied from the database here, by code.
+
+    `position` maps a message id to its place in the chat. A topic file remembers the newest message filed in it, so
+    after a crash that left topic files written but the pointer unmoved, the rerun skips the rounds already counted
+    instead of counting them twice."""
+    result: dict[str, Topic] = {}
+    for slug, rounds in plan.rounds.items():
+        topic = existing.get(slug) or Topic(label=plan.labels.get(slug, slug.replace("-", " ")), slug=slug,
+                                            chat_id=chat_id)
+        done_to = position.get(topic.last_message, -1)
+        fresh = [r for r in rounds if position[str(r.messages[-1].id)] > done_to]
+        msgs = [m for r in rounds for m in r.messages]
+        dates = sorted(_date(m) for m in msgs)
+        topic.first = min(filter(None, [topic.first, dates[0]]))
+        topic.last = max(filter(None, [topic.last, dates[-1]]))
+        topic.rounds += len(fresh)
+        topic.recent = (topic.recent + [str(m.id) for r in fresh for m in r.messages])[-files.MAX_RECENT:]
+        topic.last_message = str(max((r.messages[-1] for r in rounds), key=lambda m: position[str(m.id)]).id)
+        update = plan.updates.get(slug) or {}
+        new_summary = files.clean_summary(update.get("summary", ""), settings.chat_memory_summary_chars)
+        if not new_summary:
+            if not topic.summary:  # a new topic the model gave no summary for: say what was asked
+                first = next((m.content for m in msgs if m.role == "user"), msgs[0].content)
+                new_summary = f"The writer asked: {files.squeeze(first, 240)}"
+        elif topic.summary and slug not in shown:  # the model never saw the old summary, so extend instead of replace
+            new_summary = files.clean_summary(f"{topic.summary} {new_summary}", settings.chat_memory_summary_chars)
+        topic.summary = new_summary or topic.summary
+        topic.gist = files.one_line(update.get("gist", "") or topic.gist or topic.label)
+        topic.keywords = files.clean_keywords(list(update.get("keywords") or []) + topic.keywords)
+        allowed = {id(m): m for m in msgs}
+        wanted: list[Message] = []
+        for label in update.get("keep") or []:
+            m = labels.get(str(label).strip())
+            if m is not None and id(m) in allowed and m not in wanted:  # only messages from this topic's rounds
+                wanted.append(m)
+        topic.verbatim = _merge_quotes(topic.verbatim, [_quote(m) for m in wanted])
+        result[slug] = topic
+    return result
+
+
+def _merge_quotes(old: list[Quote], new: list[Quote]) -> list[Quote]:
+    new_ids = {q.message_id for q in new}
+    merged = [q for q in old if q.message_id not in new_ids] + new
+    while len(merged) > files.MAX_VERBATIM:
+        drop = next((i for i, q in enumerate(merged) if q.message_id not in new_ids), 0)
+        merged.pop(drop)
+    return merged
+
+
+def entry_for(t: Topic) -> TopicEntry:
+    return TopicEntry(slug=t.slug, label=t.label, last=t.last, rounds=t.rounds, keywords=", ".join(t.keywords),
+                      gist=t.gist)
+
+
+# The job
+
+
+def _lock_notebook(db: Session, notebook_id: uuid.UUID) -> None:
+    """Hold the notebook row (FOR UPDATE on Postgres) while writing, so two chats of one notebook cannot overwrite
+    each other's manifest or the notebook index. Released by the next commit. Held only for the file writes, never
+    for the model call."""
+    db.scalar(select(Notebook.id).where(Notebook.id == notebook_id).with_for_update())
+
+
+def other_chats(corpus: Corpus, manifest: dict[str, str], chat_id: str) -> dict[str, list[TopicEntry]]:
+    out: dict[str, list[TopicEntry]] = {}
+    for rel in manifest:
+        chat, _, name = rel.partition("/")
+        if name == TOPICS and chat != chat_id:
+            out[chat] = read_topics_file(corpus, chat).entries
+    return out
+
+
+def organize_chat(db: Session, job: Job | None, chat: Chat, corpus: Corpus | None = None,
+                  requeue: bool = True) -> dict:
+    """File the chat's new rounds under topics. Safe to run twice: the result depends only on the database and the
+    `through` pointer, and the pointer moves last."""
+    corpus = corpus or chat_corpus(chat.workspace_id, chat.notebook_id)
+    chat_id = str(chat.id)
+    corpus.sync()
+    tf = read_topics_file(corpus, chat_id)
+    start_through = tf.through
+    ordered = ordered_messages(db, chat.id)
+    rounds = pair_rounds(after_through(ordered, start_through))
+    if not rounds:
+        job_log.info("chat memory: chat %s has nothing new to file (through=%s)", chat_id[:8], start_through[:8] or "-")
+        return {"rounds": 0, "topics": 0, "more": False}
+    batch = rounds[:max(settings.chat_memory_max_rounds_per_job, 1)]
+    more = len(rounds) > len(batch)
+    job_log.info("chat memory: filing %d of %d waiting round(s) of chat %s (notebook %s), through=%s, "
+                 "%d topic(s) so far", len(batch), len(rounds), chat_id[:8], str(chat.notebook_id)[:8],
+                 start_through[:8] or "-", len(tf.entries))
+
+    # Rounds that were not about the posts (turned down, app help, small talk) are never filed, so they reach neither
+    # the model nor R2. They still count as handled: the pointer moves past them below.
+    work = [r for r in batch if not is_off_topic(r)]
+    if len(work) < len(batch):
+        job_log.info("chat memory: %d round(s) of chat %s were not about the posts (kind %s) and are not filed",
+                     len(batch) - len(work), chat_id[:8], "/".join(sorted(NOT_ABOUT_THE_POSTS)))
+    topics_text, shown = topics_prompt(corpus, chat_id, tf)
+    rounds_text, labels = render_rounds(work)
+    out = run.predict(OrganizeChat, db=db, workspace_id=chat.workspace_id, job=job, lm=fast_lm(),
+                      topics=topics_text, rounds=rounds_text) if work else {}
+    plan = build_plan(out, work, labels, tf)
+    shown -= plan.extend  # a merged-in summary covers only the new rounds, so it is added to the old one
+    # Only topics listed in TOPICS.md are real. A topic file that is not listed was left by a run that crashed before
+    # the pointer moved, so it is rebuilt from scratch instead of being extended.
+    existing = {slug: t for slug in plan.rounds if tf.get(slug) and (t := read_topic(corpus, chat_id, slug))}
+    position = {str(m.id): i for i, m in enumerate(ordered)}
+    old_chars = {slug: len(t.summary) for slug, t in existing.items()}  # apply_plan edits these topics in place
+    topics = apply_plan(plan, existing, shown, chat_id, labels, position)
+    previous = tf.current
+    for r in batch:  # in order: a change of topic between one round and the next is a switch
+        slug = next((s for s, rs in plan.rounds.items() if r in rs), None)
+        if slug is None:
+            continue
+        if previous and slug != previous:
+            known = topics.get(previous) or tf.get(previous)  # filed in this batch, or listed from an earlier one
+            job_log.info("=== TOPIC SWITCHED while filing chat %s: '%s' -> '%s' (round %s) ===", chat_id[:8],
+                         known.label if known else previous, topics[slug].label, r.label)
+        previous = slug
+    tf.current = previous or tf.current
+    job_log.info("chat memory: model %s filed the rounds as %s", fast_lm().model,
+                 {slug: [r.label for r in rs] for slug, rs in plan.rounds.items()} or "no topic (small talk only)")
+    for slug, topic in topics.items():
+        job_log.info("=== SUMMARY %s: topic '%s' (%s) %s -> %d chars ===", "CHANGED" if slug in existing else "CREATED",
+                     topic.label, slug, f"{old_chars[slug]}" if slug in existing else "new", len(topic.summary))
+        job_log.info("chat memory: summary %s for topic '%s' (%s): %d round(s), summary %d chars, %d exact quote(s), "
+                     "%d keyword(s)", "UPDATED" if slug in existing else "CREATED", topic.label, slug, topic.rounds,
+                     len(topic.summary), len(topic.verbatim), len(topic.keywords))
+        if text_enabled():
+            context_log.info("chat memory: new summary of '%s':\n%s\nkeywords: %s", topic.label, topic.summary,
+                             ", ".join(topic.keywords))
+
+    for slug, topic in topics.items():
+        tf.entries = [e for e in tf.entries if e.slug != slug] + [entry_for(topic)]
+    tf.through = str(batch[-1].messages[-1].id)
+    tf.updated = utcnow().isoformat()
+
+    _lock_notebook(db, chat.notebook_id)
+    manifest = corpus.sync()  # inside the lock: other chats' latest files, and a compare and set on `through`
+    if read_topics_file(corpus, chat_id).through != start_through:
+        db.rollback()
+        job_log.warning("chat memory: chat %s skipped: another run moved the pointer while this one was working",
+                        chat_id[:8])
+        return {"rounds": 0, "topics": 0, "more": False, "skipped": "another run moved the pointer"}
+    per_chat = other_chats(corpus, manifest, chat_id)
+    per_chat[chat_id] = tf.entries
+    # Order matters: topic files and the index first, the pointer last. A crash before the last write leaves the old
+    # pointer, so the next run files the same rounds again and writes the same files.
+    topic_files = {files.topic_path(chat_id, s): files.render_topic(t) for s, t in topics.items()}
+    index_text, topics_text = files.render_index(per_chat), files.render_topics(tf)
+    corpus.write_files({**topic_files, INDEX: index_text})
+    corpus.write_files({files.chat_path(chat_id, TOPICS): topics_text})
+    for rel, body in [*topic_files.items(), (INDEX, index_text), (files.chat_path(chat_id, TOPICS), topics_text)]:
+        job_log.info("chat memory: wrote to R2: %s (%d bytes)", corpus._key(rel), len(body.encode()))
+    job_log.info("chat memory: chat %s through pointer moved %s -> %s", chat_id[:8], start_through[:8] or "-",
+                 tf.through[:8])
+    db.commit()
+    if more and requeue:
+        create_job(db, chat.workspace_id, "chat_memory", {"chat_id": chat_id}, max_attempts=2,
+                   run_after=utcnow() + timedelta(seconds=1))
+    return {"rounds": len(batch), "topics": len(topics), "more": more}
+
+
+def forget_chat(workspace_id: uuid.UUID, notebook_id: uuid.UUID, chat_id: uuid.UUID, db: Session | None = None,
+                corpus: Corpus | None = None) -> int:
+    """Remove a deleted chat's files and its lines in the notebook index. Returns the number of files removed."""
+    corpus = corpus or chat_corpus(workspace_id, notebook_id)
+    if db is not None:
+        _lock_notebook(db, notebook_id)
+    manifest = corpus.sync()
+    gone = {rel for rel in manifest if rel.startswith(f"{chat_id}/")}
+    if not gone:
+        return 0
+    per_chat = other_chats(corpus, manifest, str(chat_id))
+    corpus.write_files({INDEX: files.render_index(per_chat)}, remove=gone)
+    job_log.info("chat memory: removed %d file(s) of chat %s from R2 and rebuilt %s", len(gone), str(chat_id)[:8],
+                 corpus._key(INDEX))
+    if db is not None:
+        db.commit()
+    return len(gone)
+
+
+def queue_chat_memory(db: Session, workspace_id: uuid.UUID, chat_id: uuid.UUID) -> Job | None:
+    """Queue one memory job for the chat unless one is already waiting. A job that is already running does not count:
+    it may have read the messages before the newest answer was saved."""
+    if not (settings.chat_memory_enabled and settings.llm_api_key):
+        return None
+    waiting = db.scalars(select(Job).where(Job.workspace_id == workspace_id, Job.kind == "chat_memory",
+                                           Job.status == "queued")).all()
+    if any((j.params or {}).get("chat_id") == str(chat_id) for j in waiting):
+        return None
+    return create_job(db, workspace_id, "chat_memory", {"chat_id": str(chat_id)}, max_attempts=2,
+                      run_after=utcnow() + timedelta(seconds=settings.chat_memory_delay_seconds))
+
+
+def rebuild_chat(db: Session, job: Job | None, chat: Chat, corpus: Corpus | None = None) -> dict:
+    """Throw away a chat's memory and build it again from its messages: for a lost or damaged R2 area, or after the
+    prompt changes. Costs one model call per batch of rounds."""
+    corpus = corpus or chat_corpus(chat.workspace_id, chat.notebook_id)
+    forget_chat(chat.workspace_id, chat.notebook_id, chat.id, db, corpus)
+    total = {"rounds": 0, "topics": 0}
+    while True:
+        done = organize_chat(db, job, chat, corpus, requeue=False)
+        total["rounds"] += done["rounds"]
+        total["topics"] = max(total["topics"], done["topics"])
+        if not done["more"]:
+            return total
+
+
+def forget_orphans(db: Session, workspace_id: uuid.UUID, notebook_id: uuid.UUID, corpus: Corpus | None = None) -> int:
+    """Remove memory for chats that no longer exist (a deletion whose cleanup failed, or a database restore). Returns
+    the number of chat folders removed."""
+    corpus = corpus or chat_corpus(workspace_id, notebook_id)
+    folders = {rel.partition("/")[0] for rel in corpus.sync() if "/" in rel}
+    live = {str(i) for i in db.scalars(select(Chat.id).where(Chat.notebook_id == notebook_id))}
+    orphans = sorted(folders - live)
+    for folder in orphans:
+        try:
+            forget_chat(workspace_id, notebook_id, uuid.UUID(folder), db, corpus)
+        except ValueError:  # not a chat folder: leave it alone
+            continue
+    return len(orphans)

backend/app/chat_memory/search.py

@@ -0,0 +1,115 @@
+"""Ranked search over a notebook's chat memory: BM25, written in place.
+
+grep finds exact strings but cannot rank and misses synonyms. Each topic file carries keywords with synonyms, and
+every searchable unit (a saved quote or the summary) is scored together with its topic's label, gist and keywords, so
+a search for "fee" can find a chat that only said "pricing". A notebook's chats are small, so this runs in
+milliseconds from the files already on disk, with no index service."""
+
+import math
+import re
+from collections import Counter
+from dataclasses import dataclass
+
+from app.chat_memory import files
+
+K1 = 1.5
+B = 0.75
+MAX_RESULTS = 8
+CUTOFF = 0.5  # drop results scoring under this share of the best one
+SNIPPET_CHARS = 240
+
+_WORD = re.compile(r"[a-z0-9]+")
+_STOP = frozenset("a an and are as at be by for from has have i in is it its me my of on or that the this to was "
+                  "we were what when which who with you your about did do does said say".split())
+
+
+def tokenize(text: str) -> list[str]:
+    out = []
+    for w in _WORD.findall(text.lower()):
+        if w in _STOP:
+            continue
+        out.append(w[:-1] if len(w) > 3 and w.endswith("s") and not w.endswith("ss") else w)
+    return out
+
+
+@dataclass
+class Unit:
+    path: str  # chat area relative: {chat}/{slug}.md
+    line: int  # 1 based line in that file
+    text: str  # what is shown
+    topic: str
+    last: str  # the topic's last active date
+    tokens: list[str]
+
+
+def units_for(path: str, text: str) -> list[Unit]:
+    topic = files.parse_topic(text)
+    if topic is None:
+        return []
+    lines = text.splitlines()
+    context = tokenize(f"{topic.label} {topic.gist} {' '.join(topic.keywords)}")  # document expansion
+    units: list[Unit] = []
+
+    def add(line: int, shown: str) -> None:
+        units.append(Unit(path, line, shown, topic.label, topic.last, tokenize(shown) + context))
+
+    summary_line = next((i for i, ln in enumerate(lines, start=1) if ln.strip() == "## Summary"), 0)
+    if topic.summary:
+        add(summary_line + 2 if summary_line else 1, topic.summary)
+    head = {q.message_id: 0 for q in topic.verbatim}
+    for i, ln in enumerate(lines, start=1):
+        for mid in head:
+            if ln.startswith(f"[{mid} "):
+                head[mid] = i
+    for q in topic.verbatim:
+        add(head[q.message_id] + 1 if head[q.message_id] else 1, q.text)
+    return units
+
+
+class Bm25:
+    def __init__(self, units: list[Unit]):
+        self.units = units
+        self.tf = [Counter(u.tokens) for u in units]
+        n = max(len(units), 1)
+        self.avg = sum(len(u.tokens) for u in units) / n if units else 0.0
+        df: Counter[str] = Counter()
+        for c in self.tf:
+            df.update(c.keys())
+        self.idf = {t: math.log(1 + (n - d + 0.5) / (d + 0.5)) for t, d in df.items()}
+
+    def search(self, query: str, since: str = "") -> list[tuple[float, Unit]]:
+        terms = list(dict.fromkeys(tokenize(query)))
+        scored = []
+        for unit, tf in zip(self.units, self.tf, strict=True):
+            if since and unit.last < since:
+                continue
+            length = len(unit.tokens) or 1
+            score = 0.0
+            for t in terms:
+                f = tf.get(t, 0)
+                if f:
+                    score += self.idf[t] * f * (K1 + 1) / (f + K1 * (1 - B + B * length / (self.avg or 1)))
+            if score > 0:
+                scored.append((score, unit))
+        scored.sort(key=lambda s: s[0], reverse=True)
+        return scored
+
+
+def cut(scored: list[tuple[float, Unit]]) -> list[tuple[float, Unit]]:
+    """Keep the clear winners: results within CUTOFF of the best score, at most MAX_RESULTS, at least one."""
+    if not scored:
+        return []
+    top = scored[0][0]
+    return [s for s in scored if s[0] >= top * CUTOFF][:MAX_RESULTS]
+
+
+_cache: dict[tuple, Bm25] = {}
+
+
+def index_for(key: tuple, load_units) -> Bm25:
+    """The BM25 index for one notebook, rebuilt only when its files change (the key holds the manifest hashes)."""
+    if key not in _cache:
+        if len(_cache) >= 8:
+            _cache.pop(next(iter(_cache)))
+        _cache[key] = Bm25(load_units())
+    return _cache[key]

backend/app/chat_memory/tools.py

@@ -0,0 +1,136 @@
+"""The agent's tools for earlier chats, scoped to one notebook's chat memory.
+
+Paths are shown as `chats/{chat_id}/{topic}.md` so a citation tells a chat file from a post (`sources/...`). Only
+topic files can be searched or read: the corpus root is the notebook's own area, and `clean_rel` rejects anything that
+climbs out of it."""
+
+import re
+
+from app.chat_memory import files, search
+from app.corpus import MAX_LINE_CHARS, MAX_READ_LINES, MAX_SEARCH_HITS, Corpus, CorpusError
+
+PREFIX = "chats/"
+
+
+def is_chat_path(path: str) -> bool:
+    return path.strip().lstrip("/").startswith(PREFIX)
+
+
+class ChatTools:
+    def __init__(self, corpus: Corpus, on_step=None):
+        self.corpus = corpus
+        self.on_step = on_step or (lambda kind, detail: None)
+
+    # Paths
+
+    def _rel(self, path: str) -> str:
+        rel = Corpus.clean_rel(path)
+        rel = rel.removeprefix(PREFIX)
+        name = rel.rsplit("/", 1)[-1]
+        if not rel.endswith(".md") or name in (files.TOPICS, files.INDEX):
+            raise CorpusError(f"{path} is not an earlier chat topic. Use list_chat_topics to see them.")
+        if not self.corpus.exists(rel):
+            raise CorpusError(f"No such earlier chat topic: {path}. Use list_chat_topics to see them.")
+        return rel
+
+    def topic_files(self) -> list[str]:
+        manifest = self.corpus._read_manifest(remote=False)
+        skip = (files.TOPICS, files.INDEX)
+        return sorted(r for r in manifest if "/" in r and r.endswith(".md") and r.rsplit("/", 1)[-1] not in skip)
+
+    @staticmethod
+    def shown(rel: str) -> str:
+        return PREFIX + rel
+
+    # Tools
+
+    def list_chat_topics(self, contains: str = "", since: str = "") -> str:
+        """List the topics of earlier chats in this notebook, newest first, one per line as
+        `date | path | topic | keywords | gist`. Filter to lines containing `contains` (case insensitive) and to
+        topics last active on or after `since` (a date like 2026-09-24)."""
+        self.on_step("recall", f"topics of earlier chats{f' about {contains}' if contains else ''}")
+        if not self.corpus.exists(files.INDEX):
+            return "No earlier chat topics yet."
+        rows = []
+        for line in self.corpus.read_lines(files.INDEX):
+            parts = [p.strip() for p in line.split("|")]
+            if len(parts) < 3:
+                continue
+            if since and parts[0] < since:
+                continue
+            if contains and contains.lower() not in line.lower():
+                continue
+            rows.append(" | ".join([parts[0], self.shown(parts[1]), *parts[2:]]))
+        return "\n".join(rows[:60]) or "No matching topics."
+
+    def search_chats(self, query: str, since: str = "", exact: bool = False) -> str:
+        """Ranked search of earlier chats in this notebook (best matches first). Matches the words used and
+        the topic's keywords, so a related word can find a chat that used another word. Optionally only topics last
+        active on or after `since` (a date like 2026-09-24). Set exact=true to match `query` as a regular expression
+        instead, for a literal phrase or a name. Returns `path:line: [topic, date] text`."""
+        if exact:
+            return self.grep_chats(query)
+        self.on_step("recall", f"earlier chats for {query}")
+        manifest = self.corpus._read_manifest(remote=False)
+        key = (str(self.corpus.root), tuple(sorted(manifest.items())))
+
+        def load():
+            units = []
+            for rel in self.topic_files():
+                units += search.units_for(rel, "\n".join(self.corpus.read_lines(rel)))
+            return units
+
+        hits = search.cut(search.index_for(key, load).search(query, since))
+        if not hits:
+            return "No matches in earlier chats. Try other words, list_chat_topics, or exact=true for a phrase."
+        return "\n".join(f"{self.shown(u.path)}:{u.line}: [{u.topic}, {u.last}] "
+                         f"{u.text.strip().replace(chr(10), ' ')[:search.SNIPPET_CHARS]}" for _, u in hits)
+
+    def grep_chats(self, pattern: str, path: str = "") -> str:
+        """Search the text of earlier chat topics with a case insensitive regular expression (like grep), for an
+        exact word or phrase. Optionally limit to one `path`. Returns `path:line: text` matches. The agent reaches
+        this through search_chats(exact=true): this model stops answering when it is given more than six tools."""
+        self.on_step("recall", f"earlier chats for {pattern}")
+        try:
+            rx = re.compile(pattern, re.IGNORECASE)
+        except re.error:
+            rx = re.compile(re.escape(pattern), re.IGNORECASE)
+        targets = [self._rel(path)] if path else self.topic_files()
+        hits: list[str] = []
+        total = 0
+        for rel in targets:
+            for n, line in enumerate(self.corpus.read_lines(rel), start=1):
+                if rx.search(line):
+                    total += 1
+                    if len(hits) < MAX_SEARCH_HITS:
+                        hits.append(f"{self.shown(rel)}:{n}: {line.strip()[:MAX_LINE_CHARS]}")
+        if not hits:
+            return "No matches in earlier chats."
+        out = "\n".join(hits)
+        return out + (f"\n... {total - len(hits)} more matches. Narrow the pattern." if total > len(hits) else "")
+
+    def read_chat(self, path: str, start_line: int = 1, end_line: int = 0) -> str:
+        """Read an earlier chat topic with line numbers (its summary, then the exact words that were kept). Reads at
+        most 160 lines per call. Cite with these line numbers."""
+        rel = self._rel(path)
+        lines = self.corpus.read_lines(rel)
+        start = max(1, start_line)
+        end = min(len(lines), end_line if end_line >= start else start + MAX_READ_LINES - 1)
+        end = min(end, start + MAX_READ_LINES - 1)
+        self.on_step("recall", f"{rel} (lines {start} to {end})")
+        body = "\n".join(f"{n}| {lines[n - 1]}" for n in range(start, end + 1))
+        more = f"\n[{len(lines) - end} more lines]" if end < len(lines) else ""
+        return f"{self.shown(rel)} ({len(lines)} lines)\n{body}{more}"
+
+    def quote(self, path: str, start: int, end: int) -> str | None:
+        """Text of a cited line range, or None if the citation does not point at real content."""
+        try:
+            rel = self._rel(path)
+            lines = self.corpus.read_lines(rel)
+        except CorpusError:
+            return None
+        if start < 1 or start > len(lines):
+            return None
+        end = max(start, min(end, len(lines), start + 40))
+        text = "\n".join(lines[start - 1:end]).strip()
+        return text or None

backend/app/config.py

@@ -20,6 +20,7 @@ class Settings(BaseSettings):
 
     # Local default is a SQLite file (relative to the working directory, normally backend/).
     # Prod and docker-compose use Postgres: postgresql+psycopg://user:pass@host:5432/db
+    # (plain postgres:// and postgresql:// URLs are rewritten to use psycopg, see below)
     database_url: str = "sqlite:///./notestack.db"
 
     # Worker (Postgres backed queue, see app/worker.py)
@@ -61,11 +62,31 @@ class Settings(BaseSettings):
     # Folder inside the bucket, so Notestack can share a bucket with other apps. Empty = bucket root.
     r2_prefix: str = ""
     r2_presign_ttl_seconds: int = 3600
-    max_upload_bytes: int = 200 * 1024 * 1024
+    max_upload_bytes: int = 300 * 1024 * 1024
+
+    # Posts an infographic reads, and a report that is not built from themes (REPORT_PLANNER below). A quiz or flashcard set reads up to that many straight from the posts; with more (no limit
+    # on how many are picked) it reads a small sample of the ideas already extracted from them, so its size does not grow.
+    artifact_max_posts: int = 20
+    # Characters of post text a report, quiz or flashcard set may read in all (split evenly between the posts, 1,500 at least each).
+    artifact_passage_budget: int = 120_000
+    # The same for a quiz: it needs less text than a report to ask good questions.
+    artifact_quiz_passage_budget: int = 60_000
+    # Ideas (already extracted from each post) in the evidence of a flashcard set, or of a quiz above ARTIFACT_MAX_POSTS posts.
+    artifact_idea_sample: int = 30
+
+    # Reports. "themes": the posts' stored ideas are grouped into weighted themes, a blueprint plans the report, and each section is
+    # written from its own evidence (pipeline/report_themes.py). "legacy": the posts' text goes straight to the writer, at most
+    # ARTIFACT_MAX_POSTS of them. Chats, small selections and posts without stored ideas always use the legacy way.
+    report_planner: str = "themes"
+    # Posts a themed report reads: 0 = every post picked (the plan's indexed_posts still applies).
+    report_max_posts: int = 0
+    # Posts whose ideas are extracted while the report is made (in parallel); the rest are represented by their opening.
+    report_inline_ideas: int = 25
 
     # LLM (LiteLLM model strings; Z.ai GLM by default)
     llm_model: str = "openai/glm-5.3"
     llm_fast_model: str = "openai/glm-5.3-flash"
+    llm_report_model: str = ""  # optional: writes report prose (default: the fast model, with a bigger output cap)
     # Chat triage (small talk, off topic, follow up rewriting). Empty = LLM_FAST_MODEL.
     llm_triage_model: str = ""
     # TypeSafe Jev classifier for chat triage. When set, triage uses Jev instead of an LLM call.
@@ -75,17 +96,40 @@ class Settings(BaseSettings):
     # Firecrawl: crawls sites without an RSS feed and renders JavaScript pages. Empty = plain HTTP only.
     firecrawl_api_key: str = ""
     firecrawl_url: str = "https://api.firecrawl.dev"
+    # Help bot (bottom right widget). Empty = LLM_FAST_MODEL.
+    support_llm_model: str = ""
+    support_enabled: bool = True
+    support_messages_per_minute: int = 20
     llm_api_base: str = "https://api.z.ai/api/paas/v4"
     llm_api_key: str = ""
     llm_temperature: float = 1.0  # Z.ai recommends 1.0 for GLM-5.x
     # Reasoning output counts against max_tokens, so leave headroom for the structured answer.
-    llm_max_tokens: int = 16000
+    llm_max_tokens: int = 10000
+    # The output cap of the fast model: quizzes, flashcards, infographics, idea extraction, template suggestions. A cap, not a target:
+    # only the tokens written are charged, and the thinking counts too, so keep room for it. Measured answers are under 3,000.
+    llm_fast_max_tokens: int = 6000
     # GLM-5.x always reasons (it cannot be disabled); this sets how hard. low | high | max
     llm_reasoning_effort: str = "low"
 
     # Corpus: posts as markdown files. R2 is the source of truth; each process keeps a disk cache.
     corpus_cache_dir: str = ".corpus-cache"
     research_max_steps: int = 10
+    # After an answer, how long the chat stream waits for the memory update so it can say what was saved.
+    memory_notice_wait_seconds: float = 25.0
+
+    # Chat memory: topic files built from a notebook's chats (docs/CHAT_RECALL_IMPLEMENTATION.md).
+    # CHAT_MEMORY_ENABLED writes the files after each answer. CHAT_MEMORY_READ lets answers use them.
+    chat_memory_enabled: bool = True
+    chat_memory_read: bool = False
+    chat_memory_delay_seconds: float = 10.0
+    chat_memory_max_rounds_per_job: int = 12
+    chat_memory_summary_chars: int = 1400
+    chat_memory_recent_rounds: int = 4
+    chat_memory_context_chars: int = 3000
+    chat_memory_topics_shown: int = 12
+    # Log what the research agent is given on every chat message (conversation, writer notes, chat memory). The logs
+    # then hold writers' text, so it is on only in development unless CHAT_CONTEXT_LOG=true. None follows ENV.
+    chat_context_log: bool | None = None
 
     # ElevenLabs (premade voices by default; a consented clone can replace host A)
     elevenlabs_api_key: str = ""
@@ -95,11 +139,21 @@ class Settings(BaseSettings):
 
     # Social publishing (Launchpad). Redirect URIs: {API_URL}/api/social/{x,linkedin}/callback
     social_token_key: str = ""  # Fernet key; derived from JWT_SECRET when empty
+    x_enabled: bool = False  # X posting is switched off for now (LinkedIn only); set X_ENABLED=true to bring it back
     x_client_id: str = ""
     x_client_secret: str = ""
     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"
@@ -128,6 +182,18 @@ class Settings(BaseSettings):
         """RUN_WORKER_IN_API= (blank, as in .env.example) means "decide from ENV", not a parse error."""
         return None if isinstance(value, str) and not value.strip() else value
 
+    @field_validator("database_url", mode="before")
+    @classmethod
+    def _use_psycopg_driver(cls, value):
+        """Accept plain postgres:// or postgresql:// URLs (as Neon, Heroku etc. hand out) and
+        point them at psycopg 3, the only Postgres driver installed. Query params pass through."""
+        if isinstance(value, str):
+            value = value.strip()
+            for prefix in ("postgres://", "postgresql://"):
+                if value.startswith(prefix):
+                    return "postgresql+psycopg://" + value[len(prefix):]
+        return value
+
     @property
     def worker_in_api(self) -> bool:
         return self.env == "development" if self.run_worker_in_api is None else self.run_worker_in_api

backend/app/corpus.py

@@ -32,7 +32,7 @@ MAX_READ_LINES = 160
 MAX_SEARCH_HITS = 40
 MAX_LINE_CHARS = 240
 
-_locks: dict[uuid.UUID, threading.Lock] = {}
+_locks: dict[tuple[uuid.UUID, str], threading.Lock] = {}
 
 
 def slugify(text: str, max_len: int = 60) -> str:
@@ -89,16 +89,20 @@ class Hit:
 
 
 class Corpus:
-    def __init__(self, workspace_id: uuid.UUID, store=None, cache_dir: str | None = None):
+    def __init__(self, workspace_id: uuid.UUID, store=None, cache_dir: str | None = None, area: str = "corpus"):
+        """`area` picks the folder inside the workspace: "corpus" for posts, "chats/{notebook_id}" for chat memory.
+        Each area has its own manifest, disk cache and lock."""
         self.workspace_id = workspace_id
+        self.area = area.strip("/")
         self.store = store or default_storage
-        self.root = Path(cache_dir or settings.corpus_cache_dir) / str(workspace_id)
-        self._lock = _locks.setdefault(workspace_id, threading.Lock())
+        base = Path(cache_dir or settings.corpus_cache_dir) / str(workspace_id)
+        self.root = base if self.area == "corpus" else base / self.area
+        self._lock = _locks.setdefault((workspace_id, self.area), threading.Lock())
 
     # Keys and paths
 
     def _key(self, rel: str) -> str:
-        return f"ws/{self.workspace_id}/corpus/{rel}"
+        return f"ws/{self.workspace_id}/{self.area}/{rel}"
 
     @staticmethod
     def clean_rel(rel: str) -> str:

backend/app/db.py

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

backend/app/infographics/content.py

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

backend/app/infographics/design.py

@@ -0,0 +1,213 @@
+"""The AI-composed infographic: a page frame of ours (head, takeaway, background, mark) around a body the model writes in
+HTML from a small vocabulary of components (flow charts, timelines, hierarchies, comparisons, cards, numbers). The
+model's markup is never trusted: it is parsed and rebuilt from an allowlist of tags and class names, with no
+attributes but `class`, so it can carry no script, style, link, image or address."""
+
+import hashlib
+import random
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from bs4 import BeautifulSoup, Comment, NavigableString, Tag
+from jinja2 import Environment, FileSystemLoader, StrictUndefined, select_autoescape
+from markupsafe import Markup
+
+from app.infographics.render import LOGO_SVG, SIZES
+
+_DIR = Path(__file__).parent / "templates"
+CSS = (_DIR / "design.css").read_text(encoding="utf-8")
+
+
+@dataclass(frozen=True)
+class Look:
+    id: str
+    name: str
+    blurb: str
+    vars: dict  # CSS variables of the palette
+
+
+LOOKS: dict[str, Look] = {l.id: l for l in (
+    Look("midnight", "Midnight", "Black and blue, white type", {
+        "bg": "#03050a", "bg2": "#0b1a3a", "ink": "#ffffff", "mute": "#9fb0cc", "acc": "#2f7bff", "acc2": "#8db8ff",
+        "line": "rgba(130,170,255,.26)", "card": "rgba(255,255,255,.04)", "hl": "rgba(47,123,255,.18)", "paper": "#ffffff",
+        "paperink": "#03050a", "star": "#ffffff", "markbg": "rgba(3,5,10,.75)", "markline": "rgba(141,184,255,.4)", "markink": "#ffffff"}),
+    Look("paper", "Orbit", "White, black type, blue orbits and stars", {
+        "bg": "#ffffff", "bg2": "#eaf1ff", "ink": "#05070d", "mute": "#4b5668", "acc": "#1f5fe6", "acc2": "#1f5fe6",
+        "line": "rgba(5,7,13,.18)", "card": "#ffffff", "hl": "rgba(31,95,230,.09)", "paper": "#05070d",
+        "paperink": "#ffffff", "star": "#1f5fe6", "markbg": "#05070d", "markline": "#05070d", "markink": "#ffffff"}),
+)}
+DEFAULT_LOOK = "midnight"
+
+# What the person can ask the layout to lean towards; "auto" lets the AI choose from the content.
+STYLES = {
+    "auto": "Choose the layout that suits the content",
+    "flowchart": "A flow chart: boxes joined by arrows, steps in order",
+    "timeline": "A timeline: what happened or happens, in order",
+    "compare": "A comparison: two sides set against each other",
+    "hierarchy": "A hierarchy: one idea and the parts it breaks into",
+    "overview": "An overview: cards of the key ideas and the numbers that matter",
+}
+
+# Every class the model's markup may use (the components in design.css); anything else is dropped.
+ALLOWED_CLASSES = {
+    "sec", "sec-t", "lead", "mono", "small", "hl", "node", "n-no", "n-t", "n-d", "flow", "col", "grid", "c2", "c3", "c4",
+    "card", "c-k", "c-t", "c-d", "timeline", "t-item", "t-when", "t-t", "t-d", "tree", "t-root", "t-kids", "compare",
+    "side", "s-h", "stats", "stat", "s-n", "s-l", "cols", "pills", "pill", "callout",
+}
+ALLOWED_TAGS = {"div", "section", "span", "p", "ul", "ol", "li", "strong", "b", "em", "i", "small", "br", "h3", "h4"}
+DROP_WITH_CONTENT = {"script", "style", "iframe", "object", "embed", "link", "meta", "svg", "img", "video", "audio", "form",
+                     "input", "button", "textarea", "select", "canvas", "math", "head", "title", "noscript", "template"}
+MAX_BODY_CHARS = 14_000
+MAX_ELEMENTS = 320
+
+_SPACE = re.compile(r"\s+")
+
+
+def _clean_text(text: str) -> str:
+    return text.replace("—", ",").replace("–", "-")
+
+
+def sanitize_body(raw: object) -> str | None:
+    """The model's body markup rebuilt from the allowlist, or None when nothing readable is left."""
+    if not isinstance(raw, str) or not raw.strip():
+        return None
+    soup = BeautifulSoup(raw[: MAX_BODY_CHARS * 2], "html.parser")
+    for c in soup.find_all(string=lambda t: isinstance(t, Comment)):
+        c.extract()
+    for tag in soup.find_all(DROP_WITH_CONTENT):
+        tag.decompose()
+    count = 0
+    for tag in list(soup.find_all(True)):
+        count += 1
+        if tag.name not in ALLOWED_TAGS or count > MAX_ELEMENTS:
+            tag.unwrap() if count <= MAX_ELEMENTS else tag.decompose()
+            continue
+        classes = [c for c in (tag.get("class") or []) if c in ALLOWED_CLASSES]
+        tag.attrs = {"class": classes} if classes else {}
+    for node in soup.find_all(string=True):
+        if isinstance(node, NavigableString):
+            node.replace_with(NavigableString(_clean_text(str(node))))
+    html = _SPACE.sub(" ", str(soup)).strip()
+    text = soup.get_text(strip=True)
+    if len(html) > MAX_BODY_CHARS or len(text) < 40:
+        return None
+    return html
+
+
+def _clip(text: object, limit: int) -> str:
+    s = _SPACE.sub(" ", re.sub(r"<[^>]*>", " ", str(text or ""))).strip()
+    s = _clean_text(s)
+    if len(s) <= limit:
+        return s
+    cut = s[: limit - 1].rsplit(" ", 1)[0].rstrip(" ,;:.-") or s[: limit - 1]
+    return cut + "…"
+
+
+def build_content(raw: dict) -> dict | None:
+    """The stored content for a model answer (title, subtitle, eyebrow, key_figures, body_html, rule, notes), or None when it is
+    too thin to draw."""
+    if hasattr(raw, "model_dump"):
+        raw = raw.model_dump()
+    title = _clip(raw.get("title"), 70)
+    body = sanitize_body(raw.get("body_html"))
+    if not title or not body:
+        return None
+    figures = []
+    for f in raw.get("key_figures") or []:
+        f = f if isinstance(f, dict) else getattr(f, "__dict__", {})
+        value, label = _clip(f.get("value"), 14), _clip(f.get("label"), 44)
+        if value and label:
+            figures.append({"value": value, "label": label})
+    notes = [n for n in (_clip(n, 100) for n in raw.get("notes") or []) if n][:3]
+    return {"title": title, "subtitle": _clip(raw.get("subtitle"), 130), "eyebrow": _clip(raw.get("eyebrow"), 30) or "Key ideas",
+            "key_figures": figures[:3], "body_html": body, "rule": _clip(raw.get("rule"), 90), "notes": notes}
+
+
+def _stars(seed: str, w: int, h: int, n: int = 90) -> str:
+    rnd = random.Random(int(hashlib.sha1(seed.encode()).hexdigest()[:8], 16))
+    out = []
+    for _ in range(n):
+        r = rnd.choice((1.2, 1.5, 1.5, 2, 2.6))
+        out.append(f'<circle cx="{rnd.randint(0, w)}" cy="{rnd.randint(0, h)}" r="{r}" fill="var(--star)" opacity="{round(rnd.uniform(.12, .5), 2)}"/>')
+    return "".join(out)
+
+
+def _orbits(w: int, h: int) -> str:
+    """The Orbit look's scenery: a ringed planet like the app's icon, orbit rings with small moons, and shooting stars."""
+    big = round(w * 0.2)
+    cx, cy = round(w * 0.86), round(h * 0.085)
+    pr = round(w * 0.05)
+
+    def ring(x, y, rx, ry, op, dash=""):
+        return (f'<ellipse cx="{x}" cy="{y}" rx="{rx}" ry="{ry}" transform="rotate(-20 {x} {y})" fill="none" stroke="var(--acc)" '
+                f'stroke-width="2" opacity="{op}"{dash}/>')
+
+    def planet_ring(front: bool):
+        sweep = 0 if front else 1
+        return (f'<g transform="rotate(-22 {cx} {cy})"><path d="M{cx - pr * 2} {cy} A{pr * 2} {round(pr * .6)} 0 0 {sweep} {cx + pr * 2} {cy}" '
+                f'fill="none" stroke="var(--acc)" stroke-width="5" opacity="{1 if front else .5}"/></g>')
+
+    out = [
+        '<defs><linearGradient id="shoot" x1="0" y1="0" x2="1" y2="0"><stop offset="0" stop-color="var(--acc)" stop-opacity="0"/>'
+        '<stop offset="1" stop-color="var(--acc)" stop-opacity=".85"/></linearGradient></defs>',
+        ring(cx, cy, big, round(big * .3), .35, ' stroke-dasharray="3 12"'),
+        ring(cx, cy, round(big * 1.55), round(big * .46), .22),
+        ring(round(w * .06), round(h * .96), round(w * .5), round(w * .14), .2, ' stroke-dasharray="3 12"'),
+        ring(round(w * .06), round(h * .96), round(w * .34), round(w * .09), .28),
+        planet_ring(False),
+        f'<circle cx="{cx}" cy="{cy}" r="{pr}" fill="var(--bg)" stroke="var(--acc)" stroke-width="5"/>',
+        f'<circle cx="{cx}" cy="{cy}" r="{pr - 12}" fill="var(--acc)" opacity=".12"/>',
+        planet_ring(True),
+        f'<circle cx="{round(w * .6)}" cy="{round(h * .036)}" r="9" fill="var(--acc)" opacity=".7"/>',
+        f'<circle cx="{round(w * .31)}" cy="{round(h * .93)}" r="8" fill="var(--acc)" opacity=".6"/>',
+    ]
+    for fx, fy, length, op in ((.46, .2, 190, .8), (.7, .4, 150, .6), (.12, .55, 120, .5)):
+        x, y = round(w * fx), round(h * fy)
+        out.append(f'<g transform="rotate(28 {x} {y})" opacity="{op}"><rect x="{x - length}" y="{y - 2}" width="{length}" height="4" rx="2" fill="url(#shoot)"/>'
+                   f'<circle cx="{x}" cy="{y}" r="5" fill="var(--acc)"/></g>')
+    return "".join(out)
+
+
+_ENV = Environment(loader=FileSystemLoader(_DIR), autoescape=select_autoescape(["j2", "html"], default=True), undefined=StrictUndefined,
+                   trim_blocks=True, lstrip_blocks=True)
+
+
+def render_design(look: str, content: dict, layout: str = "portrait", fit: float | None = None) -> str:
+    """The page for an AI-composed infographic. `fit` is the scale that makes its body fit (stored with the content)."""
+    look = look if look in LOOKS else DEFAULT_LOOK
+    layout = layout if layout in SIZES else "portrait"
+    w, h = SIZES[layout]
+    if fit is None:
+        fit = float(((content.get("fit") or {}) if isinstance(content.get("fit"), dict) else {}).get(layout) or 1)
+    fit = max(0.5, min(1.0, fit))
+    vars_css = ";".join(f"--{k}:{v}" for k, v in LOOKS[look].vars.items())
+    return _ENV.get_template("design.html.j2").render(
+        c=content, look=look, layout=layout, w=w, h=h, fit=fit, vars_css=vars_css, css=Markup(CSS), logo=Markup(LOGO_SVG),
+        body=Markup(content["body_html"]),
+        stars=Markup(_stars(content["title"] + look, w, h) + (_orbits(w, h) if look == "paper" else "")),
+        fonts="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@500;600;700&family=Inter:wght@300;400;500;600&family=JetBrains+Mono:wght@400;500;700&display=swap")
+
+
+SAMPLE_BODY = (
+    '<section class="sec"><div class="sec-t">The five layers</div><div class="flow">'
+    '<div class="node"><span class="n-no">01</span><span class="n-t">Prompt</span><span class="n-d">Wording, examples and format of one request.</span></div>'
+    '<div class="node"><span class="n-no">02</span><span class="n-t">Context</span><span class="n-d">Docs, history, tools and memory for each call.</span></div>'
+    '<div class="node hl"><span class="n-no">03</span><span class="n-t">Harness</span><span class="n-d">Tools, checks and guardrails around the model.</span></div>'
+    '<div class="node"><span class="n-no">04</span><span class="n-t">Loop</span><span class="n-d">Reason, act and observe until done.</span></div></div></section>'
+    '<section class="sec"><div class="sec-t">Every request goes through</div><div class="grid c4">'
+    + "".join(f'<div class="card{" hl" if i == 3 else ""}"><span class="c-k">Step {i + 1}</span><span class="c-t">{t}</span><span class="c-d">{d}</span></div>'
+              for i, (t, d) in enumerate([("Auth", "Identity, limits and input guards."), ("Cache", "Answers to repeat questions."),
+                                          ("Safety", "Scrub PII, catch injection."), ("Memory", "Session history, summarised."),
+                                          ("Retrieve", "Fetch docs, split queries."), ("Answer", "Sub-queries in parallel."),
+                                          ("Validate", "Check quality first."), ("Save", "Store and log one trace.")]))
+    + '</div></section>'
+    '<section class="sec"><div class="sec-t">Why it matters</div><div class="callout">Each layer builds on the one below it, so start at the bottom and add a layer only when the task needs it.</div></section>'
+)
+SAMPLE = {"title": "From Prompt to Production Agent", "subtitle": "Five engineering layers and the steps every request takes",
+          "eyebrow": "Agent engineering", "body_html": SAMPLE_BODY,
+          "key_figures": [{"value": "5", "label": "engineering layers"}, {"value": "8", "label": "steps on every request"},
+                          {"value": "30%", "label": "of traffic skips the pipeline"}],
+          "rule": "Most tasks only need the bottom layers; avoid complex graphs without cause.",
+          "notes": ["Each layer builds on the one below it.", "Cache and middleware run outside the graph.",
+                    "Every request produces one end-to-end trace."]}

backend/app/infographics/image.py

@@ -0,0 +1,111 @@
+"""An infographic's PNG: its stored HTML page drawn by a headless Chrome at the page's own size. No Remotion, no
+browser library: one `chrome --headless --screenshot` run per download (the result is kept for the next one)."""
+
+import functools
+import glob
+import hashlib
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from collections import OrderedDict
+from pathlib import Path
+from threading import Lock
+
+from app.infographics.render import SIZES
+
+TIMEOUT = 90  # seconds for one drawing
+SCALE = 2  # pixels per page pixel: a 1600 x 2260 page is drawn as 3200 x 4520, sharp on any screen and in print
+KEEP = 6  # drawings kept in memory
+
+_cache: OrderedDict[str, bytes] = OrderedDict()
+_lock = Lock()
+
+
+class ImageUnavailable(Exception):
+    """No Chrome to draw with, or it failed."""
+
+
+@functools.cache
+def _runs(path: str) -> bool:
+    """Whether the binary actually starts (a package manager's wrapper can outlive the browser it points at)."""
+    try:
+        return subprocess.run([path, "--version"], capture_output=True, timeout=20).returncode == 0
+    except (subprocess.SubprocessError, OSError):
+        return False
+
+
+def chrome() -> str | None:
+    """CHROME, or a working Chrome / Chromium found on the machine."""
+    if env := os.environ.get("CHROME"):
+        return env if Path(env).exists() else None
+    found = [p for name in ("chromium", "chromium-browser", "google-chrome", "google-chrome-stable", "chrome")
+             if (p := shutil.which(name))]
+    # Playwright's headless shell first: desktop Chrome on macOS can hang taking a headless screenshot.
+    shell = "chromium_headless_shell-*/chrome-headless-shell-*/chrome-headless-shell"
+    patterns = [os.path.expanduser(f"~/Library/Caches/ms-playwright/{shell}"), os.path.expanduser(f"~/.cache/ms-playwright/{shell}"),
+                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+                os.path.expanduser("~/.cache/puppeteer/chrome/*/chrome-mac-*/"
+                                   "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing")]
+    found += [p for pat in patterns for p in glob.glob(pat)]
+    return next((p for p in found if _runs(p)), None)
+
+
+def render_png(html: str, layout: str = "portrait") -> bytes:
+    """The page as a PNG, drawn at SCALE times its size: tall (1600 x 2260) or wide (2260 x 1600) before scaling."""
+    width, height = SIZES.get(layout, SIZES["portrait"])
+    key = hashlib.sha256(f"{width}x{height}@{SCALE}{html}".encode()).hexdigest()
+    with _lock:
+        if key in _cache:
+            _cache.move_to_end(key)
+            return _cache[key]
+    binary = chrome()
+    if not binary:
+        raise ImageUnavailable("No Chrome is installed here to draw the image.")
+    page = f'<!doctype html><meta charset="utf-8"><body style="margin:0">{html}</body>'
+    with tempfile.TemporaryDirectory() as tmp:
+        src, out = Path(tmp) / "page.html", Path(tmp) / "out.png"
+        src.write_text(page, encoding="utf-8")
+        cmd = [binary, "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars", f"--force-device-scale-factor={SCALE}",
+               f"--user-data-dir={tmp}/profile", f"--window-size={width},{height}", "--virtual-time-budget=8000",
+               f"--screenshot={out}", f"file://{src}"]
+        try:
+            subprocess.run(cmd, check=True, capture_output=True, timeout=TIMEOUT)
+        except (subprocess.SubprocessError, OSError) as exc:
+            raise ImageUnavailable("The image could not be drawn.") from exc
+        if not out.exists():
+            raise ImageUnavailable("The image could not be drawn.")
+        data = out.read_bytes()
+    with _lock:
+        _cache[key] = data
+        while len(_cache) > KEEP:
+            _cache.popitem(last=False)
+    return data
+
+
+_FIT = re.compile(r"FIT=([0-9.]+)")
+_MEASURE = ("<script>document.fonts.ready.then(function(){var b=document.querySelector('.ig-body'),i=document.querySelector('.ig-inner');"
+            "var s=1;if(b&&i){var inner=i.scrollHeight*parseFloat(getComputedStyle(i).getPropertyValue('--fit')||1);s=Math.min(1,b.clientHeight/Math.max(inner,1));}"
+            "document.title='FIT='+s.toFixed(3);});</script>")
+
+
+def measure_fit(html: str, layout: str) -> float:
+    """The scale (1 or less) that makes an AI-composed page's body fit its space: the page drawn once, in Chrome, with our own
+    small script measuring it (the page's markup is sanitised, so no other script is in it). 1 when Chrome is missing."""
+    width, height = SIZES.get(layout, SIZES["portrait"])
+    binary = chrome()
+    if not binary:
+        return 1.0
+    page = f'<!doctype html><meta charset="utf-8"><body style="margin:0">{html}{_MEASURE}</body>'
+    with tempfile.TemporaryDirectory() as tmp:
+        src = Path(tmp) / "page.html"
+        src.write_text(page, encoding="utf-8")
+        cmd = [binary, "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars", f"--user-data-dir={tmp}/profile",
+               f"--window-size={width},{height}", "--virtual-time-budget=10000", "--dump-dom", f"file://{src}"]
+        try:
+            out = subprocess.run(cmd, check=True, capture_output=True, timeout=TIMEOUT, text=True).stdout
+        except (subprocess.SubprocessError, OSError):
+            return 1.0
+    found = _FIT.search(out)
+    return max(0.55, min(1.0, float(found.group(1)))) if found else 1.0

backend/app/infographics/render.py

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

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

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

backend/app/infographics/templates/design.css

@@ -0,0 +1,126 @@
+/* The infographic design system: black, blue and white, thin lines, flow charts. The page frame (head, takeaway, mark, the
+   background) is ours; the body is composed by the AI from the components below, and only these class names survive the
+   sanitiser (design.ALLOWED_CLASSES). */
+.ig2,.ig2 *{box-sizing:border-box;margin:0;padding:0}
+.ig2{position:relative;width:var(--w);height:var(--h);overflow:hidden;color:var(--ink);font-family:'Inter',sans-serif;
+  background:radial-gradient(1300px 900px at 82% 6%,var(--bg2),var(--bg) 68%)}
+.ig2 .ig-bg{position:absolute;inset:0;pointer-events:none}
+.ig2 .ig-main{position:absolute;left:110px;right:110px;top:84px;bottom:132px;display:flex;flex-direction:column;gap:34px}
+.ig2 .ig-left{display:contents}
+.ig2 .ig-head{order:1;position:relative;flex:none;min-height:286px}
+.ig2 .ig-body{order:2;flex:1;min-height:0;overflow:hidden;display:flex}
+.ig2 .ig-take{order:3;flex:none}
+
+.ig2 .ig-eyebrow{display:flex;align-items:center;gap:16px;font:500 20px 'JetBrains Mono',monospace;letter-spacing:.24em;text-transform:uppercase;color:var(--acc2);margin-bottom:20px}
+.ig2 .ig-eyebrow:before{content:"";width:44px;height:2px;background:var(--acc)}
+.ig2 h1{font:600 74px/1.04 'Space Grotesk',sans-serif;letter-spacing:-.02em;max-width:850px;margin-bottom:20px}
+.ig2 .ig-sub{font-size:30px;line-height:1.38;color:var(--mute);max-width:850px}
+/* The key figures: the few numbers or short facts that matter most, beside the title (or under it when wide) */
+.ig2 .ig-figs{position:absolute;right:0;top:0;width:430px;display:flex;flex-direction:column;gap:16px}
+.ig2 .fig{padding:6px 0 6px 24px;border-left:3px solid var(--acc)}
+.ig2 .fig-v{display:block;font:600 56px/1.02 'Space Grotesk',sans-serif;letter-spacing:-.02em;overflow-wrap:anywhere}
+.ig2 .fig-l{display:block;margin-top:6px;font:500 19px 'JetBrains Mono',monospace;letter-spacing:.1em;text-transform:uppercase;color:var(--mute)}
+
+.ig2 .ig-take{display:grid;grid-template-columns:1.05fr 1fr;gap:48px;align-items:center;padding:32px 46px;border-radius:16px;background:var(--paper);color:var(--paperink)}
+.ig2 .ig-take .q{font:600 38px/1.16 'Space Grotesk',sans-serif;letter-spacing:-.01em}
+.ig2 .ig-take ul{list-style:none;font-size:24px;line-height:1.38}
+.ig2 .ig-take li{position:relative;padding-left:28px;margin:8px 0}
+.ig2 .ig-take li:before{content:"";position:absolute;left:0;top:12px;width:11px;height:11px;border-radius:50%;background:var(--acc)}
+
+.ig2 .ig-mark{position:absolute;right:44px;bottom:34px;display:flex;align-items:center;gap:16px;padding:8px 26px 8px 10px;border-radius:999px;
+  background:var(--markbg);border:1px solid var(--markline);font:700 30px 'JetBrains Mono',monospace;letter-spacing:.04em;color:var(--markink)}
+.ig2 .ig-mark svg{width:52px;height:52px;display:block}
+
+/* The body: fitted by scaling when the AI wrote more than a poster holds (the scale is measured once, when it is made) */
+.ig2 .ig-inner{display:flex;flex-direction:column;justify-content:space-evenly;gap:34px;min-height:calc(100% / var(--fit,1));flex:none;width:calc(1380px / var(--fit,1));transform:scale(var(--fit,1));transform-origin:0 0}
+.ig2 .sec{display:flex;flex-direction:column;gap:20px}
+.ig2 .sec-t{display:flex;align-items:center;gap:18px;font:500 20px 'JetBrains Mono',monospace;letter-spacing:.22em;text-transform:uppercase;color:var(--acc2)}
+.ig2 .sec-t:after{content:"";flex:1;height:1.5px;background:var(--line)}
+.ig2 .lead{font-size:28px;line-height:1.4;color:var(--ink)}
+.ig2 .ig-inner p{font-size:24px;line-height:1.4;color:var(--mute)}
+.ig2 .ig-inner strong,.ig2 .ig-inner b{color:var(--ink);font-weight:600}
+.ig2 .ig-inner em,.ig2 .ig-inner i{color:var(--acc2);font-style:normal}
+.ig2 .mono{font-family:'JetBrains Mono',monospace}
+.ig2 .small{font-size:20px}
+
+/* A box in a flow: a small number, a title, a line of text */
+.ig2 .node{position:relative;padding:24px 26px;border:1.5px solid var(--line);border-radius:14px;background:linear-gradient(var(--card),var(--card)),linear-gradient(var(--bg),var(--bg))}
+.ig2 .node.hl{background:linear-gradient(var(--hl),var(--hl)),linear-gradient(var(--bg),var(--bg));border-color:var(--acc)}
+.ig2 .n-no{display:block;font:500 19px 'JetBrains Mono',monospace;letter-spacing:.14em;color:var(--acc2);margin-bottom:10px}
+.ig2 .n-t{display:block;font:600 31px/1.15 'Space Grotesk',sans-serif;margin-bottom:8px}
+.ig2 .n-d{display:block;font-size:23px;line-height:1.38;color:var(--mute)}
+
+/* Flow chart: boxes in a row (or a column) joined by arrows */
+.ig2 .flow{display:flex;gap:58px;align-items:stretch}
+.ig2 .flow>.node{flex:1;min-width:0}
+.ig2 .flow>.node+.node:before{content:"";position:absolute;left:-48px;top:50%;width:34px;height:2px;background:var(--acc)}
+.ig2 .flow>.node+.node:after{content:"";position:absolute;left:-15px;top:50%;margin-top:-7px;border-style:solid;border-width:7px 0 7px 11px;border-color:transparent transparent transparent var(--acc)}
+.ig2 .flow.col{flex-direction:column;gap:50px}
+.ig2 .flow.col>.node+.node:before{left:50%;top:-40px;width:2px;height:28px;margin-left:-1px}
+.ig2 .flow.col>.node+.node:after{left:50%;top:-13px;margin:0 0 0 -7px;border-width:11px 7px 0 7px;border-color:var(--acc) transparent transparent transparent}
+
+/* Cards in a grid */
+.ig2 .grid{display:grid;gap:22px}
+.ig2 .c2{grid-template-columns:repeat(2,minmax(0,1fr))}
+.ig2 .c3{grid-template-columns:repeat(3,minmax(0,1fr))}
+.ig2 .c4{grid-template-columns:repeat(4,minmax(0,1fr))}
+.ig2 .card{padding:24px 26px 26px;border:1.5px solid var(--line);border-top:3px solid var(--acc);border-radius:14px;background:linear-gradient(var(--card),var(--card)),linear-gradient(var(--bg),var(--bg))}
+.ig2 .card.hl{background:linear-gradient(var(--hl),var(--hl)),linear-gradient(var(--bg),var(--bg));border-color:var(--acc)}
+.ig2 .c-k{display:block;font:500 19px 'JetBrains Mono',monospace;letter-spacing:.14em;text-transform:uppercase;color:var(--acc2);margin-bottom:10px}
+.ig2 .c-t{display:block;font:600 29px/1.15 'Space Grotesk',sans-serif;margin-bottom:8px}
+.ig2 .c-d{display:block;font-size:22px;line-height:1.38;color:var(--mute)}
+
+/* A timeline: a line with a dot for each moment */
+.ig2 .timeline{position:relative;display:flex;flex-direction:column;gap:28px;padding-left:46px}
+.ig2 .timeline:before{content:"";position:absolute;left:10px;top:8px;bottom:8px;width:2px;background:var(--line)}
+.ig2 .t-item{position:relative}
+.ig2 .t-item:before{content:"";position:absolute;left:-46px;top:6px;width:16px;height:16px;border-radius:50%;background:var(--bg);border:3px solid var(--acc)}
+.ig2 .t-when{display:block;font:500 19px 'JetBrains Mono',monospace;letter-spacing:.14em;text-transform:uppercase;color:var(--acc2);margin-bottom:6px}
+.ig2 .t-t{display:block;font:600 30px/1.15 'Space Grotesk',sans-serif;margin-bottom:6px}
+.ig2 .t-d{display:block;font-size:23px;line-height:1.38;color:var(--mute)}
+
+/* A hierarchy: one box over the boxes it leads to, joined by lines */
+.ig2 .tree{display:flex;flex-direction:column;align-items:center}
+.ig2 .t-root{width:560px;max-width:100%;text-align:center;position:relative}
+.ig2 .t-root:after{content:"";position:absolute;left:50%;top:100%;width:2px;height:28px;margin-left:-1px;background:var(--acc)}
+.ig2 .t-kids{display:flex;gap:24px;width:100%;margin-top:28px}
+.ig2 .t-kids>*{flex:1;min-width:0;position:relative;margin-top:28px}
+.ig2 .t-kids>*:before{content:"";position:absolute;left:50%;top:-28px;width:2px;height:28px;margin-left:-1px;background:var(--acc)}
+.ig2 .t-kids>*:after{content:"";position:absolute;top:-28px;left:-12px;right:-12px;height:2px;background:var(--acc)}
+.ig2 .t-kids>*:first-child:after{left:50%}
+.ig2 .t-kids>*:last-child:after{right:50%}
+.ig2 .t-kids>*:only-child:after{display:none}
+
+/* Two sides compared */
+.ig2 .compare{display:grid;grid-template-columns:1fr 1fr;border:1.5px solid var(--line);border-radius:14px;overflow:hidden}
+.ig2 .side{padding:26px 32px 22px;background:linear-gradient(var(--card),var(--card)),linear-gradient(var(--bg),var(--bg))}
+.ig2 .side+.side{border-left:1.5px solid var(--line)}
+.ig2 .side.hl{background:linear-gradient(var(--hl),var(--hl)),linear-gradient(var(--bg),var(--bg))}
+.ig2 .s-h{display:block;font:600 32px/1.15 'Space Grotesk',sans-serif;margin-bottom:14px}
+.ig2 .side ul{list-style:none}
+.ig2 .side li{position:relative;padding:13px 0 13px 30px;border-top:1px solid var(--line);font-size:23px;line-height:1.35;color:var(--mute)}
+.ig2 .side li:before{content:"";position:absolute;left:2px;top:23px;width:10px;height:10px;border-radius:50%;background:var(--acc)}
+
+/* Big numbers */
+.ig2 .stats{display:grid;grid-auto-flow:column;grid-auto-columns:minmax(0,1fr);gap:22px}
+.ig2 .stat{padding:20px 26px 22px;border-left:3px solid var(--acc);background:linear-gradient(var(--card),var(--card)),linear-gradient(var(--bg),var(--bg));border-radius:0 12px 12px 0}
+.ig2 .s-n{display:block;font:600 62px/1 'Space Grotesk',sans-serif;letter-spacing:-.02em}
+.ig2 .s-l{display:block;font-size:22px;line-height:1.35;color:var(--mute);margin-top:8px}
+
+.ig2 .cols{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:40px}
+.ig2 .pills{display:flex;flex-wrap:wrap;gap:12px}
+.ig2 .pill{padding:10px 22px;border:1.5px solid var(--line);border-radius:999px;font-size:22px;background:linear-gradient(var(--card),var(--card)),linear-gradient(var(--bg),var(--bg))}
+.ig2 .callout{padding:24px 30px;border-left:4px solid var(--acc);background:linear-gradient(var(--hl),var(--hl)),linear-gradient(var(--bg),var(--bg));border-radius:0 12px 12px 0;font-size:27px;line-height:1.38}
+
+/* Wide: the title and the takeaway in a column, the body beside them */
+.ig2.landscape .ig-main{top:70px;bottom:104px;flex-direction:row;gap:60px}
+.ig2.landscape .ig-left{display:flex;flex-direction:column;justify-content:space-between;gap:28px;width:600px;flex:none;min-height:0}
+.ig2.landscape .ig-head{min-height:0}
+.ig2.landscape h1{font-size:58px;max-width:none}
+.ig2.landscape .ig-sub{font-size:27px;max-width:none}
+.ig2.landscape .ig-figs{position:static;width:100%;margin-top:34px;gap:14px}
+.ig2.landscape .fig-v{font-size:50px}
+.ig2.landscape .ig-body{order:0;width:1380px;flex:none}
+.ig2.landscape .ig-take{grid-template-columns:1fr;gap:18px;padding:30px 34px}
+.ig2.landscape .ig-take .q{font-size:35px}
+.ig2.landscape .ig-take ul{font-size:22px}

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

@@ -0,0 +1,22 @@
+{#- The frame of an AI-composed infographic. `body` is sanitised markup (design.sanitize_body); every other value is autoescaped. -#}
+<link rel="stylesheet" href="{{ fonts }}">
+<style>{{ css }}</style>
+<div class="ig2 look-{{ look }} {{ layout }}" style="--w:{{ w }}px;--h:{{ h }}px;--fit:{{ fit }};{{ vars_css }}">
+  <svg class="ig-bg" width="{{ w }}" height="{{ h }}" viewBox="0 0 {{ w }} {{ h }}">{{ stars }}</svg>
+  <div class="ig-main">
+    <div class="ig-left">
+      <header class="ig-head">
+        <div class="ig-eyebrow">{{ c.eyebrow }}</div>
+        <h1>{{ c.title }}</h1>
+        <p class="ig-sub">{{ c.subtitle }}</p>
+        {% if c.key_figures %}<div class="ig-figs">{% for f in c.key_figures %}<div class="fig"><span class="fig-v">{{ f.value }}</span><span class="fig-l">{{ f.label }}</span></div>{% endfor %}</div>{% endif %}
+      </header>
+      <div class="ig-take">
+        <div class="q">{{ c.rule }}</div>
+        <ul>{% for n in c.notes %}<li>{{ n }}</li>{% endfor %}</ul>
+      </div>
+    </div>
+    <div class="ig-body"><div class="ig-inner">{{ body }}</div></div>
+  </div>
+  <div class="ig-mark">{{ logo }}<span>notestack.ai</span></div>
+</div>

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

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

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

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