M1: make the first story turn work with no Internet

Phase 0B ran the upstream application on a network with no route out and
the first turn died in tiktoken, which downloads its BPE table the first
time anything counts a token. The browser separately fetched three font
families from Google on every page load. Neither is visible on a machine
that has been online once, which is why both now have tests.

The tokenizer table is vendored at
backend/app/context/vendor/cl100k_base.tiktoken and
backend/app/context/encoding.py builds the encoding from it directly,
verifying its SHA-256 against the digest tiktoken itself pins for that
URL. No code path in the tokenizer can reach the network any more —
not a warm cache, not an environment variable a deployment could forget.
The encoding was checked token for token against tiktoken's own.

The three font families are self-hosted as variable fonts under
frontend/public/fonts/ (343 KiB, Latin and Latin Extended), declared in
frontend/src/styles/fonts.css, and re-vendored by
frontend/tools/vendor_fonts.py. Their OFL licences ship beside them.
With no remote asset left, the CSP drops both Google hosts and gains
object-src, base-uri and form-action; woff2 also gets its real media
type, which Python's table lacks on a slim image.

A trusted-LAN Ollama turned out not to work at all over HTTPS. httpx
verifies against the certifi bundle, so an endpoint whose certificate
comes from a CA the user installed on their own machines — a StartOS
server's Ollama, for one — was refused with CERTIFICATE_VERIFY_FAILED
while curl and the browser on the same host accepted it.
app/tlstrust.py builds one context that unions the platform CA store
with certifi's, and all four outbound clients use it. A union rather
than a swap, so an image with an empty system store cannot start failing
on endpoints that worked before. Verification itself is untouched:
CERT_REQUIRED, hostname checking on, and no insecure escape hatch.

The storyteller listener is now loopback by explicit statement rather
than by inheriting uvicorn's default: start.sh, start.ps1, and
docker-compose.yml, which publishes to 127.0.0.1 rather than every
interface. Reaching an Ollama on another machine is outbound and needs
none of that inbound exposure.

backend/requirements.lock pins the exact tested closure;
requirements.txt keeps the ranges. DEVELOPMENT.md covers setup, the
same-host and trusted-LAN Ollama configurations, and how to re-run the
offline proof. PROVENANCE.md records the upstream commit, the MIT terms,
and both vendored assets.

Verified, not just compiled. On an --internal Docker network with
1.1.1.1 unreachable and no name resolving, a campaign was created and
played for six turns through same-host Ollama, restarted, and resumed.
A second run played ten turns through Ollama on a separate physical
machine on the LAN over verified HTTPS, summaries and embeddings
included, with the storyteller's default route deleted so the LAN was
reachable and the Internet was not. Its capture: 893 packets to the
approved host, 730 loopback, zero anywhere else, and zero DNS queries.
Two induced model failures left the accepted story bit-identical. The
inherited SPA was opened in a browser and a campaign read back from it.
Evidence is in planning/reports/M1-BASELINE-REPORT.md, along with the
findings that did not belong in this change.

648 backend tests pass, up from the inherited 632; frontend lint and
build are clean; the image builds. No M2 work is included: the hosted,
cloud, analytics, Postgres and scripting surfaces are untouched.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017foPNqFjAJa2Ngebf5mEfL

backend/tests/test_tls_trust.py

@@ -0,0 +1,93 @@
+"""Guards on outbound TLS verification.
+
+A trusted-LAN Ollama is often served over HTTPS with a certificate from a CA
+the user installed on their own machines rather than one the public web knows.
+`httpx` verifies against `certifi` alone, so such an endpoint failed here while
+`curl` and the browser accepted it. `app/tlstrust.py` unions the machine's CA
+store with certifi's; these tests keep that union honest in both directions —
+it must not lose a public CA, and it must not stop verifying.
+
+Everything here is local. Nothing in this file opens a socket, so the suite
+still runs with no network.
+
+    python -m pytest tests/test_tls_trust.py -v
+"""
+import ast
+import ssl
+from pathlib import Path
+
+import certifi
+import pytest
+
+from app import tlstrust
+
+APP = Path(__file__).resolve().parents[1] / "app"
+
+
+def test_verification_is_not_weakened():
+    """The point of the change is *where* trust comes from, never whether it is
+    checked. A context that skipped verification would make every one of these
+    endpoints reachable, including a hostile one."""
+    context = tlstrust.ssl_context()
+    assert context.verify_mode is ssl.CERT_REQUIRED
+    assert context.check_hostname is True
+
+
+def test_context_is_built_once():
+    assert tlstrust.ssl_context() is tlstrust.ssl_context()
+
+
+def test_public_certificate_authorities_are_still_trusted():
+    """The union is a strict superset of what httpx trusted before. Swapping
+    certifi for the platform store instead would quietly break public
+    endpoints on an image whose system store is empty or stale."""
+    ours = {c for c in tlstrust.ssl_context().get_ca_certs(binary_form=True)}
+
+    certifi_only = ssl.create_default_context(cafile=certifi.where())
+    theirs = {c for c in certifi_only.get_ca_certs(binary_form=True)}
+
+    assert theirs, "certifi's bundle came back empty; the comparison proves nothing"
+    assert theirs <= ours, f"{len(theirs - ours)} certifi roots are missing from the union"
+
+
+def _async_client_calls(path: Path):
+    """Every `httpx.AsyncClient(...)` construction in a module, as AST nodes."""
+    tree = ast.parse(path.read_text())
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        if (
+            isinstance(func, ast.Attribute)
+            and func.attr == "AsyncClient"
+            and isinstance(func.value, ast.Name)
+            and func.value.id == "httpx"
+        ):
+            yield node
+
+
+@pytest.mark.parametrize(
+    "module",
+    ["providers/openai_compatible.py", "routers/settings.py"],
+)
+def test_every_http_client_uses_the_shared_context(module):
+    """Checked in the source rather than at runtime, because the failure this
+    catches is a *new* client added later without the context — which no
+    existing test would exercise, and which would work perfectly until someone
+    pointed it at a LAN endpoint."""
+    calls = list(_async_client_calls(APP / module))
+    assert calls, f"no httpx.AsyncClient found in {module} — has it been renamed?"
+    for call in calls:
+        keywords = {kw.arg for kw in call.keywords}
+        assert "verify" in keywords, (
+            f"{module}:{call.lineno} builds an httpx.AsyncClient without "
+            f"verify=tlstrust.ssl_context()"
+        )
+
+
+def test_no_other_module_builds_its_own_client():
+    """If a third module starts making outbound requests, it has to be added to
+    the list above rather than inheriting certifi-only trust by default."""
+    known = {APP / "providers/openai_compatible.py", APP / "routers/settings.py"}
+    found = {p for p in APP.rglob("*.py") if any(_async_client_calls(p))}
+    assert found == known, f"unexpected httpx.AsyncClient call sites: {found - known}"