M2: cut the hosted product away from the local one

94 files, +1,395 -6,578. Three files are new; twenty-four are gone. The
milestone is subtraction, and what is left is the single-user local
storyteller the specification describes.

Removed in full: campaign scripting and its QuickJS sandbox; multi-user
accounts, guest sessions, login, registration and the shared demo key;
the visitor-analytics tables, dashboard and page beacon; the access log
of sign-ins, addresses and devices; per-IP and per-user rate limiting
and quotas; Render deployment config; Postgres and psycopg; cloud
inference providers, the API-key field and the key encryption that
existed to store it; session-cookie signing. None of it was hidden
behind a flag — the routes are gone and answer 404.

Two things were kept that the brief allowed keeping. The `users` table
and its foreign keys stay as an internal ownership detail, because
rewriting them out means a migration across most of the schema to
delete a column that costs nothing; nothing creates a second user and
no request carries an identity. Five inert tables and four inert
columns stay for the same reason, so an M1 campaign database opens
unchanged.

The one addition is app/endpoints.py, which decides where a story may
be sent. Loopback, RFC1918, link-local, unique-local and CGNAT — an
explicit allowlist of networks, not a guess at what `ipaddress` means
by "private", which calls the documentation ranges private and IPv6
loopback reserved. Every address a hostname resolves to must be in it,
so a split answer does not squeak through, and the rule runs both when
the endpoint is saved and before every outbound request, because a name
that resolved to the LAN this morning can resolve elsewhere this
afternoon. Known cloud hosts are named in the refusal so the error says
why rather than looking like broken DNS. TLS is never traded against
it: M1's shared trust context is intact on all four clients and there
is no way to skip verification.

The hardcoded 120-second model timeout is now a setting. That was not
theoretical — on this GPU-less four-core host a cold load of
qwen2.5:3b-instruct took 648.9 seconds to produce the first turn, while
turns 2 to 5 of the same campaign took 3.6 to 13.1. Connect stays short
at 10s so a wrong address still fails fast; the read timeout defaults
to 300s and is bounded at 3600, because "wait longer" must stay a
number.

Two defects found while testing and fixed here. An unknown /api path
fell through the SPA catch-all and came back as HTML with status 200,
so a client asking for JSON parsed a web page instead of learning the
route was gone. And AIDND_CORS_ORIGINS accepted "*", which on an
unauthenticated loopback API would hand every page on the Internet a
write handle on the campaign database; it now refuses to start.

Verified rather than assumed. Offline, on a network with no route out
and no DNS: five turns, retry with both takes retained, restart with an
identical transcript digest, a failed model call leaving the accepted
AI-turn count untouched, and a capture with zero non-loopback unicast
packets. Against a real second machine on the LAN over HTTPS with a
private CA: four turns, restart, and a capture showing 289 packets to
the approved host, 344 loopback, zero anywhere else, zero DNS queries.
Cloud and public endpoints refused with their reasons; no API key
settable; every removed route 404.

604 backend tests pass, down from 648 by the fifteen retired with the
subsystems they tested and up by the twenty-nine added for the endpoint
policy and the removed surface. The scripting tests were not deleted:
eight files used a JavaScript counter as instrumentation for the state
snapshot and rollback machinery, which M2 does not touch, so the
counter moved to the world-state engine and those tests still assert
what they always did. Frontend lint and build are clean; the image
builds, and its wheel-building stage is gone with quickjs.

No M3 work. Undo is still destructive and there is still no Redo.

backend/app/main.py

@@ -1,6 +1,5 @@
 import mimetypes
 import os
-from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI
@@ -8,15 +7,10 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
-from . import analytics, cleanup
-from .auth import MULTI_USER
 from .database import engine
 from .limits import BodySizeLimitMiddleware
 from .migrations import bootstrap
-from .routers import (
-    adventures, analytics as analytics_router, auth, chat, debug, scenarios, scripts,
-    settings, story_cards,
-)
+from .routers import adventures, chat, debug, scenarios, settings, story_cards
 from .seed import seed_public_scenarios
 
 bootstrap(engine)
@@ -24,37 +18,32 @@ seed_public_scenarios(engine)
 
 # Production serves the SPA same-origin, so CORS only matters for the Vite dev
 # server; AIDND_CORS_ORIGINS overrides for any other cross-origin setup.
+#
+# A wildcard is refused rather than honoured. This API is unauthenticated by
+# design and bound to loopback, so its only protection from a page the user
+# happens to have open in another tab is the same-origin policy. `*` would hand
+# every site on the Internet a write handle on the local campaign database. If the
+# value is wrong the app refuses to start, because a permissive CORS policy that
+# nobody notices is worse than one that fails loudly.
 CORS_ORIGINS = [
     o.strip()
     for o in os.environ.get("AIDND_CORS_ORIGINS", "").split(",")
     if o.strip()
 ] or ["http://localhost:5173", "http://127.0.0.1:5173"]
 
-@asynccontextmanager
-async def lifespan(_app: FastAPI):
-    # Sweeps once on boot, then on an interval. Booting is the reliable
-    # trigger on Render's free tier, where the service sleeps after ~15
-    # minutes and a long-running timer rarely gets to fire.
-    sweeper = cleanup.start_sweeper()
-    # Visit counters are buffered in memory and written in batches; this is
-    # what turns them into rows, and stop_flusher writes out the last batch so
-    # a deploy doesn't drop it.
-    flusher = analytics.start_flusher()
-    try:
-        yield
-    finally:
-        await cleanup.stop_sweeper(sweeper)
-        await analytics.stop_flusher(flusher)
+if any(o == "*" or o.strip() == "*" for o in CORS_ORIGINS):
+    raise RuntimeError(
+        "AIDND_CORS_ORIGINS must not contain '*'. The storyteller API is "
+        "unauthenticated and loopback-bound; a wildcard origin would let any "
+        "web page read and rewrite every campaign. List the exact origins "
+        "instead."
+    )
 
-
-# The interactive API docs stay local-only: in multi-user mode they just hand
-# strangers a map of the API surface.
 app = FastAPI(
-    title="AI D&D",
-    docs_url=None if MULTI_USER else "/docs",
+    title="Adventure Storyteller",
+    docs_url="/docs",
     redoc_url=None,
-    openapi_url=None if MULTI_USER else "/openapi.json",
-    lifespan=lifespan,
+    openapi_url="/openapi.json",
 )
 
 app.add_middleware(
@@ -117,50 +106,14 @@ class SecurityHeadersMiddleware:
         await self.app(scope, receive, send_with_headers)
 
 
-class ApiErrorMiddleware:
-    """Counts failed API responses for the analytics dashboard.
-
-    This is middleware rather than an exception handler, because it observes
-    what the client received. A 429 from a rate limiter, a 404 from routing, and
-    a 500 from a handler that never returned all reach it the same way. It is
-    pure ASGI for the same reason as the headers above: an SSE turn must not be
-    buffered on its way out. It watches `/api` only, because a 404 on the SPA
-    mount is a page load rather than a fault.
-    """
-
-    def __init__(self, app):
-        self.app = app
-
-    async def __call__(self, scope, receive, send):
-        if scope["type"] != "http" or not scope.get("path", "").startswith("/api"):
-            return await self.app(scope, receive, send)
-
-        async def send_counting(message):
-            if message["type"] == "http.response.start" and message["status"] >= 400:
-                # The router has already put the matched route on the scope by
-                # the time a response starts, so the label can name the
-                # endpoint rather than the caller's path.
-                analytics.record(
-                    analytics.M_ERROR,
-                    analytics.api_route_label(scope, message["status"]),
-                )
-            await send(message)
-
-        await self.app(scope, receive, send_counting)
-
-
-app.add_middleware(ApiErrorMiddleware)
 app.add_middleware(SecurityHeadersMiddleware)
 
-app.include_router(auth.router)
 app.include_router(scenarios.router)
 app.include_router(adventures.router)
 app.include_router(story_cards.router)
-app.include_router(scripts.router)
 app.include_router(settings.router)
 app.include_router(chat.router)
 app.include_router(debug.router)
-app.include_router(analytics_router.router)
 
 
 @app.get("/api/health")
@@ -171,7 +124,8 @@ def health():
 # In production, serve the built frontend (frontend/dist) as static files.
 class SPAStaticFiles(StaticFiles):
     """Serve index.html for unknown paths so client-side routes (/play/3)
-    survive a page reload. API routes are matched before this mount."""
+    survive a page reload. API routes are matched before this mount, and an
+    unmatched one 404s rather than falling through to the page."""
 
     async def get_response(self, path, scope):
         try:
@@ -179,11 +133,20 @@ class SPAStaticFiles(StaticFiles):
         except StarletteHTTPException as exc:
             if exc.status_code != 404:
                 raise
-            return await super().get_response("index.html", scope)
+            return await self._fallback(path, scope)
         if response.status_code == 404:
-            return await super().get_response("index.html", scope)
+            return await self._fallback(path, scope)
         return response
 
+    async def _fallback(self, path, scope):
+        # The mount is a catch-all, so an /api path no router claims — a typo,
+        # or an endpoint this build removed — used to come back as the SPA's
+        # HTML with status 200, and a client asking for JSON parsed a web page
+        # instead of seeing that the route is not there.
+        if path == "api" or path.startswith("api/"):
+            raise StarletteHTTPException(status_code=404)
+        return await super().get_response("index.html", scope)
+
 
 # Python's mimetypes table has no entry for woff2 on a slim Debian image, so
 # StaticFiles served the self-hosted fonts as application/octet-stream. Browsers