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/app/context/builder.py

@@ -18,13 +18,12 @@ top of the prompt re-prices everything below it. See the comments on the static
 block and the live sections in `build_context`.
 """
 
-import functools
 from dataclasses import dataclass
 
 import tiktoken
 
 from .. import models, worldstate
-from . import history
+from . import encoding, history
 
 AUTHORS_NOTE_DEPTH = 3  # actions from the end of history
 CARD_BUDGET_SHARE = 0.4  # max share of non-reserved budget that story cards may take
@@ -61,9 +60,11 @@ MIN_LENGTH_FLOOR_WORDS = 60
 MAX_LENGTH_FLOOR_WORDS = 300
 
 
-@functools.lru_cache(maxsize=1)
+# Built from the table vendored in `encoding.py`, not fetched: the upstream
+# `tiktoken.get_encoding("cl100k_base")` downloads it on first use, and this
+# is called on every turn.
 def _encoding() -> tiktoken.Encoding:
-    return tiktoken.get_encoding("cl100k_base")
+    return encoding.get_encoding()
 
 
 def count_tokens(text: str) -> int:

backend/app/context/encoding.py

@@ -0,0 +1,90 @@
+"""`cl100k_base` without a first-use download.
+
+Upstream called `tiktoken.get_encoding("cl100k_base")`, which fetches the BPE
+table from `openaipublic.blob.core.windows.net` the first time it is used and
+caches it under the system temp directory. That download is invisible on a
+developer machine that has already made it once, and fatal on a machine with
+outbound Internet blocked: the context builder counts tokens on *every* turn,
+so the first story turn died with a `ConnectionError` instead of narrating
+(Phase 0B offline report; acceptance tests A01 and H11).
+
+The table is vendored beside this module and the `Encoding` is constructed from
+it directly, so no code path inside the tokenizer can reach the network — not a
+cache that happens to be warm, and not an environment variable a deployment
+could forget to set.
+
+The vendored file's SHA-256 is verified against the digest `tiktoken` itself
+pins for that URL. A truncated checkout or a substituted table then fails
+loudly, rather than silently changing every token count the context budget is
+computed from.
+"""
+
+import base64
+import functools
+import hashlib
+from pathlib import Path
+
+import tiktoken
+
+ENCODING_NAME = "cl100k_base"
+
+#: Where the table came from, recorded so the vendored copy can be re-derived.
+SOURCE_URL = "https://openaipublic.blob.core.windows.net/encodings/cl100k_base.tiktoken"
+
+#: The digest `tiktoken_ext.openai_public.cl100k_base()` pins for SOURCE_URL.
+BPE_SHA256 = "223921b76ee99bde995b7ff738513eef100fb51d18c93597a113bcffe865b2a7"
+
+BPE_PATH = Path(__file__).resolve().parent / "vendor" / "cl100k_base.tiktoken"
+
+# Both copied from `tiktoken_ext.openai_public.cl100k_base()`. They are part of
+# the encoding's identity: the same merge table with a different pattern is a
+# different tokenizer, so they are pinned here rather than imported, and the
+# round-trip test asserts this build agrees with tiktoken's own.
+_PAT_STR = r"""'(?i:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?+\p{L}++|\p{N}{1,3}+| ?[^\s\p{L}\p{N}]++[\r\n]*+|\s++$|\s*[\r\n]|\s+(?!\S)|\s"""
+_SPECIAL_TOKENS = {
+    "<|endoftext|>": 100257,
+    "<|fim_prefix|>": 100258,
+    "<|fim_middle|>": 100259,
+    "<|fim_suffix|>": 100260,
+    "<|endofprompt|>": 100276,
+}
+
+
+def _mergeable_ranks() -> dict[bytes, int]:
+    try:
+        data = BPE_PATH.read_bytes()
+    except OSError as exc:  # pragma: no cover - packaging fault, not a run fault
+        raise RuntimeError(
+            f"The vendored {ENCODING_NAME} table is missing at {BPE_PATH}. "
+            f"Re-download it from {SOURCE_URL} (SHA-256 {BPE_SHA256})."
+        ) from exc
+
+    digest = hashlib.sha256(data).hexdigest()
+    if digest != BPE_SHA256:
+        raise RuntimeError(
+            f"The vendored {ENCODING_NAME} table at {BPE_PATH} has SHA-256 "
+            f"{digest}, expected {BPE_SHA256}."
+        )
+
+    # Same parse as tiktoken.load.load_tiktoken_bpe, minus its fetch/cache step.
+    ranks: dict[bytes, int] = {}
+    for line in data.splitlines():
+        if not line:
+            continue
+        try:
+            token, rank = line.split()
+            ranks[base64.b64decode(token)] = int(rank)
+        except Exception as exc:
+            raise ValueError(f"Error parsing line {line!r} in {BPE_PATH}") from exc
+    return ranks
+
+
+@functools.lru_cache(maxsize=1)
+def get_encoding() -> tiktoken.Encoding:
+    """The `cl100k_base` encoding, built from the vendored table."""
+    return tiktoken.Encoding(
+        name=ENCODING_NAME,
+        pat_str=_PAT_STR,
+        mergeable_ranks=_mergeable_ranks(),
+        special_tokens=_SPECIAL_TOKENS,
+    )

backend/app/main.py

@@ -1,3 +1,4 @@
+import mimetypes
 import os
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -68,8 +69,18 @@ app.add_middleware(BodySizeLimitMiddleware)
 
 class SecurityHeadersMiddleware:
     """Standard hardening headers on every response. Pure ASGI (wraps `send`)
-    so SSE streams pass through unbuffered. The CSP allows exactly what the
-    SPA uses: same-origin everything, inline styles (React), Google Fonts."""
+    so SSE streams pass through unbuffered.
+
+    The CSP allows exactly what the SPA uses, and that is now same-origin and
+    nothing else: scripts, styles, fonts, images and XHR/SSE all resolve to the
+    app itself. The fonts used to come from Google, which made an Internet
+    request on every page load; they are self-hosted under /fonts/ instead
+    (frontend/tools/vendor_fonts.py), so `font-src 'self'` covers them and the
+    two remote hosts are gone from the policy.
+
+    `'unsafe-inline'` stays on `style-src` because React writes inline `style`
+    attributes. It is deliberately absent from `script-src`.
+    """
 
     _HEADERS = [
         (b"x-content-type-options", b"nosniff"),
@@ -79,10 +90,13 @@ class SecurityHeadersMiddleware:
             b"content-security-policy",
             b"default-src 'self'; "
             b"script-src 'self'; "
-            b"style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "
-            b"font-src https://fonts.gstatic.com; "
+            b"style-src 'self' 'unsafe-inline'; "
+            b"font-src 'self'; "
             b"img-src 'self' data:; "
             b"connect-src 'self'; "
+            b"object-src 'none'; "
+            b"base-uri 'none'; "
+            b"form-action 'self'; "
             b"frame-ancestors 'none'",
         ),
     ]
@@ -171,6 +185,13 @@ class SPAStaticFiles(StaticFiles):
         return response
 
 
+# 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
+# take them anyway — a @font-face src carries its own format() hint — but the
+# honest type costs one line.
+mimetypes.add_type("font/woff2", ".woff2")
+mimetypes.add_type("font/woff", ".woff")
+
 frontend_dist = Path(__file__).resolve().parent.parent.parent / "frontend" / "dist"
 if frontend_dist.is_dir():
     app.mount("/", SPAStaticFiles(directory=frontend_dist, html=True), name="frontend")

backend/app/providers/openai_compatible.py

@@ -3,7 +3,7 @@ from typing import AsyncIterator
 
 import httpx
 
-from .. import debuglog, netguard
+from .. import debuglog, netguard, tlstrust
 from .base import PromptParts, Provider, ProviderError
 
 # Appended after the story text in chat mode, so a chat-tuned model continues
@@ -247,7 +247,9 @@ class OpenAICompatibleProvider(Provider):
         log = debuglog.start_entry(url, self.model, body)
         received: list[str] = []
         try:
-            async with httpx.AsyncClient(timeout=httpx.Timeout(120, connect=10)) as client:
+            async with httpx.AsyncClient(
+                timeout=httpx.Timeout(120, connect=10), verify=tlstrust.ssl_context()
+            ) as client:
                 async with client.stream("POST", url, json=body, headers=self._headers()) as resp:
                     if resp.status_code != 200:
                         detail = (await resp.aread()).decode(errors="replace")[:500]
@@ -354,7 +356,9 @@ class OpenAICompatibleProvider(Provider):
 
         log = debuglog.start_entry(url, self.model, body)
         try:
-            async with httpx.AsyncClient(timeout=httpx.Timeout(120, connect=10)) as client:
+            async with httpx.AsyncClient(
+                timeout=httpx.Timeout(120, connect=10), verify=tlstrust.ssl_context()
+            ) as client:
                 resp = await client.post(url, json=body, headers=self._headers())
         except httpx.HTTPError as exc:
             debuglog.finish_entry(log, error=str(exc))
@@ -381,7 +385,9 @@ class OpenAICompatibleProvider(Provider):
         body = {"model": self.model, "input": texts}
         log = debuglog.start_entry(url, self.model, body)
         try:
-            async with httpx.AsyncClient(timeout=httpx.Timeout(60, connect=10)) as client:
+            async with httpx.AsyncClient(
+                timeout=httpx.Timeout(60, connect=10), verify=tlstrust.ssl_context()
+            ) as client:
                 resp = await client.post(url, json=body, headers=self._headers())
         except httpx.HTTPError as exc:
             debuglog.finish_entry(log, error=str(exc))

backend/app/routers/settings.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter, Depends, Request
 from sqlalchemy.orm import Session
 from starlette.concurrency import run_in_threadpool
 
-from .. import auth, limits, models, netguard, schemas, security
+from .. import auth, limits, models, netguard, schemas, security, tlstrust
 from ..database import get_db
 
 router = APIRouter(prefix="/api/settings", tags=["settings"])
@@ -95,7 +95,7 @@ async def list_endpoint_models(cfg: auth.ProviderConfig) -> dict:
     if cfg.api_key:
         headers["Authorization"] = f"Bearer {cfg.api_key}"
     try:
-        async with httpx.AsyncClient(timeout=10) as client:
+        async with httpx.AsyncClient(timeout=10, verify=tlstrust.ssl_context()) as client:
             resp = await client.get(url, headers=headers)
     except httpx.HTTPError as exc:
         return {"ok": False, "detail": f"Connection failed: {exc}"}

backend/app/tlstrust.py

@@ -0,0 +1,47 @@
+"""Verify TLS against this machine's own trust store as well as certifi's.
+
+`httpx` verifies against the `certifi` bundle, which carries the public web's
+certificate authorities and nothing else. A trusted-LAN inference host often
+has no public certificate: on a StartOS server, Ollama is served over HTTPS
+with a certificate from a local CA that the user installs on the machines they
+use it from. `curl` and the browser accepted such an endpoint; this
+application refused it:
+
+    Connection failed: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify
+    failed: self-signed certificate in certificate chain
+
+That is a wrong answer for the deployment this project targets
+(`planning/DECISIONS/002-ollama-only-v1.md`), because the user had already
+made the decision to trust that CA, at the level where such decisions belong.
+
+So the rule is the one a user already expects from everything else on their
+machine: **a CA installed on this host is trusted by this application.** This
+is not a relaxation of verification. Certificates are still verified, hostnames
+are still checked, and a certificate signed by nobody the machine trusts is
+still refused — `AIDND_ENDPOINT_INSECURE` and its like deliberately do not
+exist.
+
+The two stores are unioned rather than swapped. `ssl.create_default_context()`
+alone would be a behaviour *change* — it loads only the platform's default CA
+locations (`/etc/ssl/certs` on Debian and Ubuntu), and a stripped-down image
+whose system store is empty or stale would start failing on endpoints that
+used to work. Adding certifi on top makes this a strict superset of the old
+behaviour, so nothing that verified before can stop verifying now.
+
+Building a context parses every certificate in both stores, so it is done once
+and cached. The result is read-only afterwards and is shared safely across
+concurrent requests.
+"""
+
+import functools
+import ssl
+
+import certifi
+
+
+@functools.lru_cache(maxsize=1)
+def ssl_context() -> ssl.SSLContext:
+    """The verification context every outbound HTTPS client should use."""
+    context = ssl.create_default_context()  # the platform's CA store
+    context.load_verify_locations(cafile=certifi.where())  # plus the public web's
+    return context

backend/requirements.lock

@@ -0,0 +1,57 @@
+# Exact versions of the whole dependency closure, including transitive ones.
+#
+# requirements.txt states the ranges the code needs; this file states what was
+# actually installed and tested, so a fresh checkout reproduces a known-good
+# environment instead of resolving whatever is newest that day. It covers the
+# dev/test dependencies too, because the regression report is only meaningful
+# against a pinned suite.
+#
+#   python3 -m venv backend/.venv
+#   backend/.venv/bin/pip install -r backend/requirements.lock
+#
+# Regenerate after a deliberate upgrade, by installing from requirements.txt
+# and requirements-dev.txt and re-running the suite:
+#
+#   backend/.venv/bin/pip freeze > backend/requirements.lock   # then restore this header
+#
+# `pip` itself is deliberately left out: it is the tool, not a dependency.
+annotated-doc==0.0.5
+annotated-types==0.8.0
+anyio==4.14.2
+certifi==2026.7.22
+cffi==2.1.1
+charset-normalizer==3.5.1
+click==8.5.0
+cryptography==50.0.1
+fastapi==0.141.1
+greenlet==3.5.5
+h11==0.16.0
+httpcore==1.0.9
+httptools==0.8.0
+httpx==0.28.1
+idna==3.19
+iniconfig==2.3.0
+packaging==26.3
+pluggy==1.6.0
+psycopg==3.3.5
+psycopg-binary==3.3.5
+pycparser==3.0
+pydantic==2.13.5
+pydantic_core==2.46.5
+Pygments==2.21.0
+pytest==9.1.1
+python-dotenv==1.2.3
+PyYAML==6.0.3
+quickjs==1.19.4
+regex==2026.9.3
+requests==2.34.2
+SQLAlchemy==2.0.52
+starlette==1.6.0
+tiktoken==0.14.0
+typing-inspection==0.4.4
+typing_extensions==4.16.0
+urllib3==2.7.0
+uvicorn==0.52.4
+uvloop==0.22.1
+watchfiles==1.2.0
+websockets==17.1

backend/requirements.txt

@@ -3,6 +3,10 @@ uvicorn[standard]>=0.30
 sqlalchemy>=2.0
 pydantic>=2.7
 httpx>=0.27
+# Imported directly by app/tlstrust.py, which unions this bundle with the
+# machine's own CA store. It arrives with httpx anyway; declared because the
+# code imports it by name.
+certifi
 tiktoken>=0.7
 quickjs>=1.19
 cryptography>=42

backend/tests/test_offline_assets.py

@@ -0,0 +1,160 @@
+"""Guards on the offline baseline: nothing a story turn needs is fetched.
+
+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 — invisible on a machine that had already been online
+once. The browser separately pulled three font families from Google on every
+page load. Both are now local, and these tests fail if either comes back.
+
+The distinction that matters here is *runtime* assets. Downloading a dependency
+at install time is fine; downloading one while the user is playing is not.
+
+    python -m pytest tests/test_offline_assets.py -v
+
+Acceptance tests A01, H01 and H11.
+"""
+import hashlib
+import inspect
+import re
+import socket
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.context import builder, encoding
+from app.main import app
+
+REPO = Path(__file__).resolve().parents[2]
+FRONTEND = REPO / "frontend"
+
+# Any absolute http(s) URL. Matched against the places a browser would actually
+# be told to fetch from: markup attributes and CSS url()/@import.
+REMOTE_URL = re.compile(rb"https?://[^\s\"'()>]+")
+
+
+@pytest.fixture
+def client():
+    with TestClient(app) as c:
+        yield c
+
+
+# --- the tokenizer -------------------------------------------------------
+
+
+def test_vendored_table_is_present_and_intact():
+    """The digest is the whole reason the vendored copy is trustworthy."""
+    data = encoding.BPE_PATH.read_bytes()
+    assert hashlib.sha256(data).hexdigest() == encoding.BPE_SHA256
+
+
+def test_pinned_digest_still_matches_tiktokens_own():
+    """`tiktoken` hardcodes the digest it expects for `cl100k_base`. If an
+    upgrade ever points that name at a different table, the vendored copy is
+    stale and every token count would quietly disagree with upstream's."""
+    import tiktoken_ext.openai_public
+
+    source = inspect.getsource(tiktoken_ext.openai_public.cl100k_base)
+    assert encoding.BPE_SHA256 in source
+    assert encoding.SOURCE_URL in source
+
+
+def test_token_counting_makes_no_network_call(monkeypatch):
+    """The real regression. `count_tokens` runs on every turn; on a host with
+    no route out, the upstream version raised ConnectionError instead of
+    narrating."""
+    encoding.get_encoding.cache_clear()
+
+    def refuse(*args, **kwargs):
+        raise AssertionError("the tokenizer tried to open a socket")
+
+    monkeypatch.setattr(socket, "socket", refuse)
+    monkeypatch.setattr(socket, "create_connection", refuse)
+    monkeypatch.setattr(socket, "getaddrinfo", refuse)
+
+    try:
+        assert builder.count_tokens("The lighthouse keeper's lamp guttered.") > 0
+    finally:
+        encoding.get_encoding.cache_clear()
+
+
+def test_token_counts_are_unchanged():
+    """Golden values from the encoding built by upstream's own
+    `tiktoken.get_encoding("cl100k_base")`, checked equal token for token
+    across ASCII and accented text. The context
+    budget is computed from these numbers, so a silently different tokenizer
+    would silently change what fits in a prompt."""
+    assert builder.count_tokens("") == 0
+    assert builder.count_tokens("hello world") == 2
+    assert builder.count_tokens(
+        "The lighthouse keeper's lamp guttered in the salt wind."
+    ) == 13
+    assert builder.count_tokens("naïve café — résumé") == 8
+
+
+def test_round_trip_survives_the_awkward_characters():
+    enc = encoding.get_encoding()
+    for text in ("", "naïve café — résumé 🜂 龍", "tabs\tand\r\nCRLF", "a" * 500):
+        assert enc.decode(enc.encode(text)) == text
+
+
+# --- the browser ---------------------------------------------------------
+
+
+def test_csp_names_no_remote_origin(client):
+    csp = client.get("/api/health").headers["content-security-policy"]
+    assert "fonts.googleapis.com" not in csp
+    assert "fonts.gstatic.com" not in csp
+    assert "//" not in csp, f"CSP still allows a remote origin: {csp}"
+    assert "font-src 'self'" in csp
+    assert "connect-src 'self'" in csp
+
+
+def test_index_html_fetches_nothing_remote():
+    html = (FRONTEND / "index.html").read_bytes()
+    # The comment explaining where the fonts went is not a fetch, so match
+    # attributes rather than the whole file.
+    for attr in re.findall(rb"(?:href|src)\s*=\s*\"([^\"]*)\"", html):
+        assert not REMOTE_URL.match(attr), attr
+
+
+def test_stylesheets_fetch_nothing_remote():
+    for css in sorted((FRONTEND / "src").rglob("*.css")):
+        text = css.read_bytes()
+        for statement in re.findall(rb"(?:url|@import)\s*\(?[^;{}]*", text):
+            assert not REMOTE_URL.search(statement), f"{css.name}: {statement}"
+
+
+def test_every_declared_font_file_exists():
+    """A @font-face pointing at a file that is not in the tree falls back to a
+    system font on the developer's machine and 404s on a user's."""
+    css = (FRONTEND / "src" / "styles" / "fonts.css").read_text()
+    declared = re.findall(r"url\('/fonts/([^']+)'\)", css)
+    assert declared, "fonts.css declares no faces"
+    for name in declared:
+        assert (FRONTEND / "public" / "fonts" / name).is_file(), name
+
+
+def _without_comments(text: bytes) -> bytes:
+    """Comments name the hosts these files no longer talk to — the note in
+    `index.html` saying where the fonts went, and the `/* from ... */` line
+    recording where each vendored face was downloaded from. Both are
+    documentation. Strip them, then the check below can be blunt."""
+    text = re.sub(rb"<!--.*?-->", b"", text, flags=re.S)
+    return re.sub(rb"/\*.*?\*/", b"", text, flags=re.S)
+
+
+@pytest.mark.skipif(
+    not (Path(__file__).resolve().parents[2] / "frontend" / "dist" / "index.html").exists(),
+    reason="SPA not built; run `npm run build` in frontend/ to check the shipped bundle",
+)
+def test_built_spa_fetches_no_fonts_remotely():
+    """The source is what the tests above read; this is what users are served."""
+    dist = FRONTEND / "dist"
+    for path in list(dist.rglob("*.html")) + list(dist.rglob("*.css")):
+        text = _without_comments(path.read_bytes())
+        assert b"fonts.googleapis.com" not in text, path
+        assert b"fonts.gstatic.com" not in text, path
+    for path in dist.rglob("*.css"):
+        for url in re.findall(rb"url\(([^)]*)\)", _without_comments(path.read_bytes())):
+            assert not REMOTE_URL.search(url), f"{path}: {url}"

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}"