deploy(hf): sync szl-holdings/a11oy@88a286749ffeafc466b438f36fbbb3ba755a1e41 derived COPY set

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy 88a286749ffeafc466b438f36fbbb3ba755a1e41.
Files: 1186 Pruned: 0
Derived from Dockerfile COPY sources (NO hand-maintained allowlist).

Signed-off-by: SZL Holdings <noreply@szlholdings.ai>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

routers/__init__.py

@@ -24,6 +24,10 @@ Action Passports, signed receipts, and bounded one-attempt effectors. It is expo
 here so invocation and package-integrity checks can prove the production module is
 intentional rather than an orphaned source file.
 
+`frontier_now_control_plane` is an additive GET/HEAD-only projection over that
+existing Series-A seam. It intentionally owns no database, signer, credentials,
+scheduler, passport authority, or effectors.
+
 The package top-level name is `routers` (not szl_*/a11oy_*), so it is intentionally
 OUTSIDE the guarded-import-liveness first-party scan — and the files exist anyway.
 
@@ -34,5 +38,6 @@ __all__ = [
     "lambda_bounty",
     "research_3d",
     "frontier_reads",
+    "frontier_now_control_plane",
     "series_a_control_plane",
 ]

routers/frontier_now_control_plane.py

@@ -0,0 +1,621 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# (c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173
+"""Read-only Frontier Now projection over the existing Series-A service.
+
+This module is intentionally not a second control authority. It owns no provider
+credential, database, signer, receipt chain, scheduler, or effector. Every GET and
+HEAD is a bounded projection of ``app.state.szl_series_a_service``. Missing or
+stale evidence remains visible as UNAVAILABLE/STALE and public claims stay held
+until an exact source-to-runtime binding is observed elsewhere.
+"""
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import HTMLResponse, JSONResponse, Response
+
+SCHEMA_SUMMARY = "szl.frontier-now-summary/v1"
+SCHEMA_INVENTORY = "szl.frontier-now-inventory/v1"
+OPERATING_MODE = "OBSERVE_ONLY"
+MAX_INVENTORY_LIMIT = 50
+PROVIDERS = {"all", "github", "huggingface", "runtime", "web"}
+NO_STORE_HEADERS = {
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff",
+    "referrer-policy": "no-referrer",
+}
+PAGE_HEADERS = {
+    **NO_STORE_HEADERS,
+    "content-security-policy": (
+        "default-src 'none'; script-src 'self'; script-src-attr 'none'; "
+        "style-src 'self'; style-src-attr 'none'; connect-src 'self'; "
+        "img-src 'self' data:; font-src 'self'; object-src 'none'; "
+        "base-uri 'none'; form-action 'none'; frame-ancestors 'self' "
+        "https://huggingface.co https://*.hf.space https://*.huggingface.co"
+    ),
+    "permissions-policy": (
+        "camera=(), microphone=(), geolocation=(), payment=(), usb=(), "
+        "accelerometer=(), gyroscope=()"
+    ),
+}
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace(
+        "+00:00", "Z"
+    )
+
+
+def _safe_mapping(value: Any) -> dict[str, Any]:
+    return dict(value) if isinstance(value, Mapping) else {}
+
+
+def _manifest_digest(value: Mapping[str, Any]) -> str:
+    payload = json.dumps(
+        dict(value),
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _service(app: FastAPI) -> Any:
+    return getattr(app.state, "szl_series_a_service", None)
+
+
+def _snapshot(
+    service: Any,
+    *,
+    include_receipts: bool = True,
+) -> tuple[
+    dict[str, Any],
+    dict[str, Any],
+    list[dict[str, Any]],
+    str | None,
+    str,
+]:
+    if service is None:
+        return (
+            {
+                "state": "UNAVAILABLE",
+                "terminal": True,
+                "detail": "Series-A estate observer is not registered",
+            },
+            {},
+            [],
+            None,
+            "UNAVAILABLE",
+        )
+    try:
+        for _ in range(2):
+            status = _safe_mapping(service.latest_status())
+            latest = service.store.latest_snapshot()
+            digest = (
+                str(latest.get("digest"))
+                if isinstance(latest, Mapping) and latest.get("digest")
+                else None
+            )
+            status_digest = status.get("manifest_digest")
+            if (digest is None and not status_digest) or status_digest == digest:
+                manifest = (
+                    _safe_mapping(latest.get("manifest"))
+                    if isinstance(latest, Mapping)
+                    else {}
+                )
+                if digest is not None and _manifest_digest(manifest) != digest:
+                    return (
+                        {
+                            "state": "UNAVAILABLE",
+                            "terminal": True,
+                            "detail": "Persisted estate manifest digest mismatch",
+                            "reason": "MANIFEST_DIGEST_MISMATCH",
+                        },
+                        {},
+                        [],
+                        None,
+                        "UNAVAILABLE",
+                    )
+                receipts: list[dict[str, Any]] = []
+                proof_state = "NOT_REQUESTED"
+                if include_receipts:
+                    try:
+                        receipt_values = service.store.list_receipts(8)
+                        receipts = [
+                            dict(item)
+                            for item in receipt_values
+                            if isinstance(item, Mapping)
+                        ]
+                        proof_state = "OBSERVED"
+                    except Exception:
+                        proof_state = "UNAVAILABLE"
+                return (
+                    status,
+                    manifest,
+                    receipts,
+                    digest,
+                    proof_state,
+                )
+        return (
+            {
+                "state": "UNAVAILABLE",
+                "terminal": True,
+                "detail": "Estate snapshot changed during bounded projection",
+                "reason": "SNAPSHOT_CHANGED_DURING_READ",
+            },
+            {},
+            [],
+            None,
+            "UNAVAILABLE",
+        )
+    except Exception:
+        return (
+            {
+                "state": "UNAVAILABLE",
+                "terminal": True,
+                "detail": "Series-A read projection failed closed",
+                "reason": "SERIES_A_READ_FAILED",
+            },
+            {},
+            [],
+            None,
+            "UNAVAILABLE",
+        )
+
+
+def _capability_state(raw: Any, observation_state: str) -> str:
+    value = str(raw or "UNAVAILABLE")
+    if observation_state == "STALE" and value in {"OBSERVED", "PARTIAL"}:
+        return "STALE"
+    return value
+
+
+def _capabilities(
+    manifest: Mapping[str, Any], observation_state: str
+) -> list[dict[str, Any]]:
+    github = _safe_mapping(manifest.get("github"))
+    github_value = _safe_mapping(github.get("value"))
+    github_detail = _safe_mapping(github.get("detail"))
+    github_state = _capability_state(github.get("state"), observation_state)
+
+    rows: list[dict[str, Any]] = [
+        {
+            "provider": "github",
+            "capability": "repositories",
+            "state": github_state,
+            "count": (
+                github_value.get("repository_count")
+                if github_state == "OBSERVED"
+                else None
+            ),
+            "scope": (
+                "AUTHENTICATED_SCOPE_REDACTED"
+                if github_detail.get("authenticated")
+                else "PUBLIC_ONLY"
+            ),
+        },
+        {
+            "provider": "github",
+            "capability": "open_pull_requests",
+            "state": github_state,
+            "count": (
+                github_value.get("open_pull_request_count")
+                if github_state == "OBSERVED"
+                else None
+            ),
+            "scope": (
+                "AUTHENTICATED_SCOPE_REDACTED"
+                if github_detail.get("authenticated")
+                else "PUBLIC_ONLY"
+            ),
+        },
+    ]
+
+    huggingface = _safe_mapping(manifest.get("huggingface"))
+    huggingface_value = _safe_mapping(huggingface.get("value"))
+    huggingface_detail = _safe_mapping(huggingface.get("detail"))
+    categories = _safe_mapping(huggingface_value.get("categories"))
+    for capability in (
+        "models",
+        "datasets",
+        "spaces",
+        "collections",
+        "buckets",
+        "kernels",
+    ):
+        value = _safe_mapping(categories.get(capability))
+        state = _capability_state(value.get("state"), observation_state)
+        rows.append(
+            {
+                "provider": "huggingface",
+                "capability": capability,
+                "state": state,
+                "count": value.get("count") if state == "OBSERVED" else None,
+                "scope": (
+                    "AUTHENTICATED_SCOPE_REDACTED"
+                    if huggingface_detail.get("authenticated")
+                    else "PUBLIC_ONLY"
+                ),
+            }
+        )
+
+    rows.extend(
+        [
+            {
+                "provider": "runtime",
+                "capability": "source_to_hf_overlay_binding",
+                "state": "UNAVAILABLE",
+                "count": None,
+                "scope": "NOT_OBSERVED_BY_ESTATE_MANIFEST",
+            },
+            {
+                "provider": "web",
+                "capability": "domain_build_identity",
+                "state": "UNAVAILABLE",
+                "count": None,
+                "scope": "NOT_OBSERVED_BY_ESTATE_MANIFEST",
+            },
+        ]
+    )
+    return rows
+
+
+def _receipt_projection(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    projected = []
+    for item in items:
+        envelope = _safe_mapping(item.get("envelope"))
+        projected.append(
+            {
+                "kind": item.get("kind"),
+                "receipt_hash": item.get("receipt_hash"),
+                "created_at": item.get("created_at"),
+                "signature_status": envelope.get("signature_status", "UNAVAILABLE"),
+                "verification_state": "UNAVAILABLE",
+            }
+        )
+    return projected
+
+
+def build_summary(app: FastAPI) -> dict[str, Any]:
+    status, manifest, receipts, digest, proof_state = _snapshot(_service(app))
+    state = str(status.get("state") or "UNAVAILABLE")
+    critical_failures = status.get("critical_failures")
+    if not isinstance(critical_failures, list):
+        critical_failures = []
+    enforcement = "OBSERVE_ONLY" if state == "OBSERVED" and not critical_failures else "FAILED_CLOSED"
+    source_revision = status.get("source_revision") or manifest.get("source_revision")
+
+    raw_counts = _safe_mapping(status.get("counts"))
+    current_counts = (
+        raw_counts
+        if state == "OBSERVED" and not critical_failures
+        else {key: None for key in raw_counts}
+    )
+
+    return {
+        "schema": SCHEMA_SUMMARY,
+        "generated_at": _now(),
+        "operating_mode": OPERATING_MODE,
+        "observation": {
+            "state": state,
+            "observed_at": status.get("observed_at"),
+            "valid_until": status.get("valid_until"),
+            "manifest_digest": digest,
+            "critical_failures": critical_failures,
+            "detail": status.get("detail"),
+            "reason": status.get("reason"),
+        },
+        "enforcement": {
+            "state": enforcement,
+            "external_writes": "DISABLED",
+            "automatic_retries": 0,
+            "effectors": [],
+            "reason": (
+                "READ_PROJECTION_ONLY"
+                if enforcement == "OBSERVE_ONLY"
+                else "CURRENT_EVIDENCE_CANNOT_AUTHORIZE_ACTION"
+            ),
+        },
+        "identity": {
+            "runtime_reported_source_revision": source_revision,
+            "github_default_branch_revision": None,
+            "huggingface_repository_revision": None,
+            "runtime_artifact_digest": None,
+            "equivalence_state": "UNAVAILABLE",
+            "reason": "ESTATE_MANIFEST_DOES_NOT_BIND_SOURCE_TO_HF_OVERLAY_AND_RUNTIME_ARTIFACT",
+        },
+        "counts": current_counts,
+        "last_known_counts": {
+            "state": state,
+            "values": raw_counts,
+        },
+        "coverage": _capabilities(manifest, state),
+        "claim_gate": {
+            "state": "FAILED_CLOSED",
+            "public_claim_status": "HELD",
+            "reason": "EXACT_SOURCE_RUNTIME_BINDING_UNAVAILABLE",
+        },
+        "frontiers": [
+            {
+                "id": "estate-observation",
+                "label": "Estate observation",
+                "state": state,
+                "source": "series-a-manifest",
+            },
+            {
+                "id": "source-runtime-parity",
+                "label": "Source to runtime parity",
+                "state": "UNAVAILABLE",
+                "source": "binding-not-observed",
+            },
+            {
+                "id": "defensive-activation",
+                "label": "Defensive activation",
+                "state": "MODELED",
+                "source": "no-effectors-bound",
+            },
+            {
+                "id": "atelier-clean-room",
+                "label": "ATELIER clean-room innovation",
+                "state": "MODELED",
+                "source": "release-gate-not-bound",
+            },
+        ],
+        "proof_rail": _receipt_projection(receipts),
+        "proof_rail_state": proof_state,
+        "routes": {
+            "series_a_manifest": "/api/a11oy/v1/series-a/manifest",
+            "series_a_receipts": "/api/a11oy/v1/series-a/receipts",
+            "series_a_events": "/api/a11oy/v1/series-a/events",
+            "frontier_manifest": "/api/a11oy/v1/frontier/manifest",
+        },
+        "private_reasoning_collected": False,
+        "claim": "CURRENT_OBSERVATION_NOT_ETERNAL_TRUTH",
+    }
+
+
+def build_inventory(app: FastAPI) -> dict[str, Any]:
+    status, manifest, _, digest, _ = _snapshot(
+        _service(app), include_receipts=False
+    )
+    state = str(status.get("state") or "UNAVAILABLE")
+    return {
+        "manifest_digest": digest,
+        "observation_state": state,
+        "observed_at": status.get("observed_at"),
+        "valid_until": status.get("valid_until"),
+        "items": _capabilities(manifest, state),
+    }
+
+
+def _single_query_value(request: Request, name: str, default: str) -> str:
+    values = request.query_params.getlist(name)
+    if len(values) > 1:
+        raise HTTPException(status_code=400, detail=f"{name} must be supplied at most once")
+    return values[0] if values else default
+
+
+def _bounded_integer(
+    request: Request,
+    name: str,
+    default: int,
+    *,
+    minimum: int,
+    maximum: int,
+) -> int:
+    raw = _single_query_value(request, name, str(default))
+    try:
+        value = int(raw)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=f"{name} must be an integer") from exc
+    if value < minimum or value > maximum:
+        raise HTTPException(
+            status_code=422,
+            detail=f"{name} must be between {minimum} and {maximum}",
+        )
+    return value
+
+
+def _asset_bytes(name: str) -> bytes:
+    path = Path(__file__).resolve().parent / "frontier_now_web" / name
+    if not path.is_file():
+        raise HTTPException(status_code=404, detail=f"asset missing: {name}")
+    return path.read_bytes()
+
+
+def _asset_digest(name: str) -> str:
+    return hashlib.sha256(_asset_bytes(name)).hexdigest()
+
+
+def _asset_cache_control(request: Request, content: bytes) -> str:
+    if request.query_params.get("v") == hashlib.sha256(content).hexdigest():
+        return "public,max-age=31536000,immutable"
+    return "no-store"
+
+
+def register(app: FastAPI, ns: str = "a11oy") -> dict[str, Any]:
+    prefix = f"/api/{ns}/v1/frontier-now"
+    intended_paths = {
+        "/frontier-now",
+        "/frontier-now/",
+        "/now",
+        "/now/",
+        "/frontier-now/app.js",
+        "/frontier-now/app.js/",
+        "/frontier-now/styles.css",
+        "/frontier-now/styles.css/",
+        f"{prefix}/summary",
+        f"{prefix}/summary/",
+        f"{prefix}/inventory",
+        f"{prefix}/inventory/",
+    }
+    existing = [
+        route
+        for route in app.router.routes
+        if getattr(route, "path", None) in intended_paths
+    ]
+    if existing:
+        complete = {getattr(route, "path", None) for route in existing} == intended_paths
+        owned = all(
+            getattr(getattr(route, "endpoint", None), "__module__", None)
+            == __name__
+            for route in existing
+        )
+        methods_complete = all(
+            {"GET", "HEAD"}.issubset(getattr(route, "methods", set()))
+            for route in existing
+        )
+        if complete and owned and methods_complete and len(existing) == len(intended_paths):
+            return {
+                "ok": True,
+                "state": "ALREADY_REGISTERED",
+                "routes": sorted(intended_paths),
+            }
+        raise RuntimeError("FRONTIER_NOW_ROUTE_COLLISION")
+
+    async def page(request: Request) -> Response:
+        html = (
+            _asset_bytes("index.html")
+            .decode("utf-8")
+            .replace("__APP_ASSET_DIGEST__", _asset_digest("app.js"))
+            .replace("__STYLE_ASSET_DIGEST__", _asset_digest("styles.css"))
+        )
+        if request.method == "HEAD":
+            return Response(
+                status_code=200,
+                media_type="text/html",
+                headers=PAGE_HEADERS,
+            )
+        return HTMLResponse(html, headers=PAGE_HEADERS)
+
+    async def js(request: Request) -> Response:
+        content = _asset_bytes("app.js")
+        headers = {
+            "cache-control": _asset_cache_control(request, content),
+            "x-content-type-options": "nosniff",
+            "referrer-policy": "no-referrer",
+        }
+        if request.method == "HEAD":
+            return Response(
+                status_code=200,
+                media_type="application/javascript",
+                headers=headers,
+            )
+        return Response(content, media_type="application/javascript", headers=headers)
+
+    async def css(request: Request) -> Response:
+        content = _asset_bytes("styles.css")
+        headers = {
+            "cache-control": _asset_cache_control(request, content),
+            "x-content-type-options": "nosniff",
+            "referrer-policy": "no-referrer",
+        }
+        if request.method == "HEAD":
+            return Response(status_code=200, media_type="text/css", headers=headers)
+        return Response(content, media_type="text/css", headers=headers)
+
+    async def summary(request: Request) -> Response:
+        if request.method == "HEAD":
+            return Response(
+                status_code=200,
+                media_type="application/json",
+                headers=NO_STORE_HEADERS,
+            )
+        return JSONResponse(build_summary(request.app), headers=NO_STORE_HEADERS)
+
+    async def inventory(request: Request) -> Response:
+        provider = _single_query_value(request, "provider", "all").lower()
+        if provider not in PROVIDERS:
+            raise HTTPException(
+                status_code=422,
+                detail="provider must be one of all, github, huggingface, runtime, web",
+            )
+        cursor = _bounded_integer(
+            request, "cursor", 0, minimum=0, maximum=1_000_000
+        )
+        limit = _bounded_integer(
+            request,
+            "limit",
+            20,
+            minimum=1,
+            maximum=MAX_INVENTORY_LIMIT,
+        )
+        projection = build_inventory(request.app)
+        rows = projection["items"]
+        if provider != "all":
+            rows = [item for item in rows if item.get("provider") == provider]
+        page_rows = rows[cursor : cursor + limit]
+        next_cursor = cursor + len(page_rows) if cursor + len(page_rows) < len(rows) else None
+        if request.method == "HEAD":
+            return Response(
+                status_code=200,
+                media_type="application/json",
+                headers=NO_STORE_HEADERS,
+            )
+        return JSONResponse(
+            {
+                "schema": SCHEMA_INVENTORY,
+                "generated_at": _now(),
+                "operating_mode": OPERATING_MODE,
+                "manifest_digest": projection["manifest_digest"],
+                "observation_state": projection["observation_state"],
+                "observed_at": projection["observed_at"],
+                "valid_until": projection["valid_until"],
+                "provider": provider,
+                "cursor": cursor,
+                "limit": limit,
+                "next_cursor": next_cursor,
+                "total": len(rows),
+                "items": page_rows,
+                "asset_names_exposed": False,
+                "claim": "CAPABILITY_COVERAGE_NOT_ASSET_READINESS",
+            },
+            headers=NO_STORE_HEADERS,
+        )
+
+    routes: list[tuple[str, Callable[..., Any], list[str]]] = [
+        ("/frontier-now", page, ["GET", "HEAD"]),
+        ("/frontier-now/", page, ["GET", "HEAD"]),
+        ("/now", page, ["GET", "HEAD"]),
+        ("/now/", page, ["GET", "HEAD"]),
+        ("/frontier-now/app.js", js, ["GET", "HEAD"]),
+        ("/frontier-now/app.js/", js, ["GET", "HEAD"]),
+        ("/frontier-now/styles.css", css, ["GET", "HEAD"]),
+        ("/frontier-now/styles.css/", css, ["GET", "HEAD"]),
+        (f"{prefix}/summary", summary, ["GET", "HEAD"]),
+        (f"{prefix}/summary/", summary, ["GET", "HEAD"]),
+        (f"{prefix}/inventory", inventory, ["GET", "HEAD"]),
+        (f"{prefix}/inventory/", inventory, ["GET", "HEAD"]),
+    ]
+    added: list[str] = []
+    for path, endpoint, methods in routes:
+        app.add_api_route(path, endpoint, methods=methods, include_in_schema=False)
+        added.append(path)
+
+    route_set = set(added)
+    selected = [
+        route
+        for route in app.router.routes
+        if getattr(route, "path", None) in route_set
+    ]
+    selected_ids = {id(route) for route in selected}
+    app.router.routes[:] = selected + [
+        route for route in app.router.routes if id(route) not in selected_ids
+    ]
+
+    return {
+        "ok": True,
+        "state": "REGISTERED",
+        "namespace": ns,
+        "routes": sorted(added),
+        "operating_mode": OPERATING_MODE,
+        "sign_on_read": False,
+        "effectors": [],
+        "private_reasoning_collected": False,
+    }

routers/frontier_now_web/app.js

@@ -0,0 +1,356 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * (c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173
+ */
+(() => {
+  "use strict";
+
+  const API = "/api/a11oy/v1/frontier-now";
+  const SERIES_EVENTS = "/api/a11oy/v1/series-a/events";
+  const TIMEOUT_MS = 8000;
+  const INVENTORY_PAGE_SIZE = 50;
+  const INVENTORY_MAX_PAGES = 10;
+  const MIN_EVENT_RELOAD_MS = 5000;
+  const STATES = new Set([
+    "OBSERVED",
+    "MODELED",
+    "PENDING",
+    "STALE",
+    "BLOCKED",
+    "FAILED_CLOSED",
+    "UNAVAILABLE",
+    "DISABLED",
+    "UNKNOWN"
+  ]);
+
+  const byId = (id) => document.getElementById(id);
+  const terminal = (value, fallback = "UNAVAILABLE") => {
+    if (value === null || value === undefined || value === "") return fallback;
+    return String(value);
+  };
+  const state = (value) => {
+    const normalized = terminal(value, "UNAVAILABLE").toUpperCase();
+    return STATES.has(normalized) ? normalized : "UNKNOWN";
+  };
+  const setText = (id, value, fallback) => {
+    const node = byId(id);
+    if (node) node.textContent = terminal(value, fallback);
+  };
+  const setState = (id, value) => {
+    const node = byId(id);
+    if (!node) return;
+    const normalized = state(value);
+    node.textContent = normalized;
+    node.dataset.state = normalized;
+  };
+  const formatTime = (value) => {
+    if (!value) return "NOT OBSERVED";
+    const date = new Date(value);
+    return Number.isNaN(date.valueOf()) ? String(value) : date.toISOString();
+  };
+  const shortHash = (value) => {
+    const text = terminal(value, "UNAVAILABLE");
+    return text.length > 24 ? `${text.slice(0, 12)}…${text.slice(-8)}` : text;
+  };
+
+  const activeControllers = new Set();
+  const request = async (path) => {
+    const controller = new AbortController();
+    activeControllers.add(controller);
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+      const response = await fetch(API + path, {
+        method: "GET",
+        cache: "no-store",
+        credentials: "same-origin",
+        headers: {accept: "application/json"},
+        signal: controller.signal
+      });
+      if (!response.ok) throw new Error(`HTTP_${response.status}`);
+      const contentType = response.headers.get("content-type") || "";
+      if (!contentType.includes("application/json")) {
+        throw new Error("NON_JSON_RESPONSE");
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timer);
+      activeControllers.delete(controller);
+    }
+  };
+
+  const requestInventory = async () => {
+    let cursor = 0;
+    let identity = null;
+    let pageCount = 0;
+    const items = [];
+    while (pageCount < INVENTORY_MAX_PAGES) {
+      const page = await request(
+        `/inventory?provider=all&limit=${INVENTORY_PAGE_SIZE}&cursor=${cursor}`
+      );
+      const pageIdentity = [
+        page.manifest_digest,
+        page.observation_state,
+        page.observed_at,
+        page.valid_until
+      ];
+      if (identity && JSON.stringify(identity) !== JSON.stringify(pageIdentity)) {
+        throw new Error("INVENTORY_CHANGED_DURING_PAGINATION");
+      }
+      identity = pageIdentity;
+      items.push(...(Array.isArray(page.items) ? page.items : []));
+      pageCount += 1;
+      if (page.next_cursor === null || page.next_cursor === undefined) {
+        return {...page, items};
+      }
+      if (!Number.isInteger(page.next_cursor) || page.next_cursor <= cursor) {
+        throw new Error("INVALID_INVENTORY_CURSOR");
+      }
+      cursor = page.next_cursor;
+    }
+    throw new Error("INVENTORY_PAGINATION_BOUND_EXCEEDED");
+  };
+
+  const sameObservation = (summary, inventory) => (
+    summary.observation?.manifest_digest === inventory.manifest_digest &&
+    summary.observation?.state === inventory.observation_state &&
+    summary.observation?.observed_at === inventory.observed_at &&
+    summary.observation?.valid_until === inventory.valid_until
+  );
+
+  const readView = async () => {
+    const settled = await Promise.allSettled([request("/summary"), requestInventory()]);
+    if (settled[0].status !== "fulfilled") throw settled[0].reason;
+    let summary = settled[0].value;
+    if (settled[1].status !== "fulfilled") {
+      return {summary, inventory: null, inventoryError: settled[1].reason};
+    }
+    let inventory = settled[1].value;
+    if (sameObservation(summary, inventory)) {
+      return {summary, inventory, inventoryError: null};
+    }
+
+    const retry = await Promise.allSettled([request("/summary"), requestInventory()]);
+    if (retry[0].status === "fulfilled") summary = retry[0].value;
+    if (retry[1].status !== "fulfilled") {
+      return {summary, inventory: null, inventoryError: retry[1].reason};
+    }
+    inventory = retry[1].value;
+    if (!sameObservation(summary, inventory)) {
+      return {
+        summary,
+        inventory: null,
+        inventoryError: new Error("SNAPSHOT_CHANGED_DURING_READ")
+      };
+    }
+    return {summary, inventory, inventoryError: null};
+  };
+
+  const renderCoverage = (items, emptyMessage) => {
+    const body = byId("coverage-rows");
+    body.replaceChildren();
+    const rows = Array.isArray(items) ? items : [];
+    if (!rows.length) {
+      const row = document.createElement("tr");
+      const cell = document.createElement("td");
+      cell.colSpan = 5;
+      cell.textContent = emptyMessage || "UNAVAILABLE · no capability observations returned";
+      row.append(cell);
+      body.append(row);
+      return;
+    }
+    rows.forEach((item) => {
+      const row = document.createElement("tr");
+      const provider = document.createElement("td");
+      const capability = document.createElement("td");
+      const statusCell = document.createElement("td");
+      const count = document.createElement("td");
+      const scope = document.createElement("td");
+      const badge = document.createElement("span");
+
+      provider.textContent = terminal(item.provider);
+      capability.textContent = terminal(item.capability);
+      badge.className = "status";
+      badge.dataset.state = state(item.state);
+      badge.textContent = state(item.state);
+      statusCell.append(badge);
+      count.textContent = item.count === null || item.count === undefined ? "—" : String(item.count);
+      scope.textContent = terminal(item.scope);
+      row.append(provider, capability, statusCell, count, scope);
+      body.append(row);
+    });
+  };
+
+  const renderProof = (items, proofState = "UNAVAILABLE") => {
+    const list = byId("proof-rail");
+    list.replaceChildren();
+    const receipts = Array.isArray(items) ? items : [];
+    if (!receipts.length) {
+      const item = document.createElement("li");
+      const observedEmpty = state(proofState) === "OBSERVED";
+      item.textContent = observedEmpty
+        ? "OBSERVED · no receipts persisted"
+        : "UNAVAILABLE · receipt projection could not be read";
+      list.append(item);
+      setState("proof-state", observedEmpty ? "OBSERVED" : "UNAVAILABLE");
+      return;
+    }
+    receipts.forEach((receipt) => {
+      const item = document.createElement("li");
+      const kind = document.createElement("span");
+      const hash = document.createElement("a");
+      const created = document.createElement("time");
+      const signature = document.createElement("span");
+      const digest = terminal(receipt.receipt_hash);
+
+      kind.textContent = terminal(receipt.kind);
+      hash.href = `/api/a11oy/v1/series-a/receipts/${encodeURIComponent(digest)}`;
+      hash.textContent = shortHash(digest);
+      hash.className = "text-link";
+      hash.title = digest;
+      hash.setAttribute("aria-label", `Open receipt SHA-256 ${digest}`);
+      created.dateTime = terminal(receipt.created_at, "");
+      created.textContent = formatTime(receipt.created_at);
+      signature.className = "status";
+      signature.dataset.state = "UNAVAILABLE";
+      signature.textContent = `REPORTED ${terminal(receipt.signature_status)}`;
+      item.append(kind, hash, created, signature);
+      list.append(item);
+    });
+    setState("proof-state", "OBSERVED");
+  };
+
+  const renderCounts = (counts) => {
+    document.querySelectorAll("[data-count]").forEach((node) => {
+      const value = counts && Object.prototype.hasOwnProperty.call(counts, node.dataset.count)
+        ? counts[node.dataset.count]
+        : null;
+      node.textContent = value === null || value === undefined ? "—" : String(value);
+    });
+  };
+
+  let loadGeneration = 0;
+  const load = async () => {
+    activeControllers.forEach((controller) => controller.abort());
+    activeControllers.clear();
+    const generation = ++loadGeneration;
+    const button = byId("refresh-view");
+    button.disabled = true;
+    setText("view-status", "Reading the persisted estate snapshot.");
+    try {
+      const {summary, inventory, inventoryError} = await readView();
+      if (generation !== loadGeneration) return;
+
+      setText("operating-mode", summary.operating_mode, "OBSERVE_ONLY");
+      setState("estate-state", summary.observation?.state);
+      setState("observe-state", summary.observation?.state);
+      setState("claim-state", summary.claim_gate?.state);
+      setText("observed-at", formatTime(summary.observation?.observed_at));
+      setText("as-of", `OBSERVED ${formatTime(summary.observation?.observed_at)} · VALID UNTIL ${formatTime(summary.observation?.valid_until)}`);
+
+      const revision = summary.identity?.runtime_reported_source_revision;
+      setText("runtime-revision", revision, "NOT OBSERVED");
+      setText("graph-source", shortHash(revision));
+      byId("runtime-source-node").classList.toggle("reported", Boolean(revision));
+      byId("runtime-source-node").classList.toggle("unavailable", !revision);
+      setText("identity-reason", terminal(summary.identity?.reason));
+      renderCounts(summary.counts || {});
+      renderCoverage(
+        inventory?.items || [],
+        inventoryError
+          ? `UNAVAILABLE · inventory projection: ${terminal(inventoryError.message)}`
+          : undefined
+      );
+      renderProof(summary.proof_rail || [], summary.proof_rail_state);
+      setText(
+        "view-status",
+        `View generated ${formatTime(summary.generated_at)} · ${terminal(summary.claim)}` +
+          (inventoryError ? " · COVERAGE UNAVAILABLE" : "")
+      );
+    } catch (error) {
+      if (generation !== loadGeneration) return;
+      setState("estate-state", "UNAVAILABLE");
+      setState("observe-state", "UNAVAILABLE");
+      setState("claim-state", "FAILED_CLOSED");
+      setState("proof-state", "UNAVAILABLE");
+      renderCounts({});
+      renderCoverage([], "UNAVAILABLE · capability projection could not be read");
+      renderProof([], "UNAVAILABLE");
+      setText("operating-mode", "OBSERVE_ONLY");
+      setText("runtime-revision", "NOT OBSERVED");
+      setText("graph-source", "NOT OBSERVED");
+      byId("runtime-source-node").classList.remove("reported");
+      byId("runtime-source-node").classList.add("unavailable");
+      setText("observed-at", "NOT OBSERVED");
+      setText("identity-reason", "CURRENT_PROJECTION_UNAVAILABLE");
+      const reason = error && error.name === "AbortError"
+        ? `UNAVAILABLE · timed out after ${TIMEOUT_MS / 1000} seconds`
+        : `UNAVAILABLE · ${terminal(error && error.message)}`;
+      setText("view-status", reason);
+      setText("as-of", "TERMINAL UNAVAILABLE STATE");
+    } finally {
+      if (generation === loadGeneration) button.disabled = false;
+    }
+  };
+
+  byId("refresh-view").addEventListener("click", load);
+
+  const activateRailLink = (active) => {
+    document.querySelectorAll('.rail a[href^="#"]').forEach((item) => {
+      const selected = item === active;
+      item.classList.toggle("active", selected);
+      if (selected) item.setAttribute("aria-current", "location");
+      else item.removeAttribute("aria-current");
+    });
+  };
+
+  document.querySelectorAll('.rail a[href^="#"]').forEach((link) => {
+    link.addEventListener("click", () => {
+      activateRailLink(link);
+    });
+  });
+
+  if ("IntersectionObserver" in window) {
+    const links = new Map(
+      [...document.querySelectorAll('.rail a[href^="#"]')].map((link) => [
+        link.getAttribute("href").slice(1),
+        link
+      ])
+    );
+    const observer = new IntersectionObserver((entries) => {
+      const visible = entries
+        .filter((entry) => entry.isIntersecting)
+        .sort((a, b) => b.intersectionRatio - a.intersectionRatio)[0];
+      if (!visible) return;
+      activateRailLink(links.get(visible.target.id));
+    }, {rootMargin: "-20% 0px -65%", threshold: [0.05, 0.25, 0.6]});
+    links.forEach((_link, id) => {
+      const section = byId(id);
+      if (section) observer.observe(section);
+    });
+  }
+
+  let eventReloadTimer = null;
+  let lastEventReload = 0;
+  if ("EventSource" in window) {
+    const events = new EventSource(SERIES_EVENTS);
+    events.addEventListener("open", () => {
+      setText("live-updates", "UPDATES CONNECTED");
+    });
+    events.addEventListener("error", () => {
+      setText("live-updates", "UPDATES UNAVAILABLE · MANUAL REFRESH");
+    });
+    ["estate.refresh", "estate.refresh.failed"].forEach((eventName) => {
+      events.addEventListener(eventName, () => {
+        clearTimeout(eventReloadTimer);
+        const wait = Math.max(250, MIN_EVENT_RELOAD_MS - (Date.now() - lastEventReload));
+        eventReloadTimer = setTimeout(() => {
+          lastEventReload = Date.now();
+          load();
+        }, wait);
+      });
+    });
+  } else {
+    setText("live-updates", "UPDATES UNAVAILABLE · MANUAL REFRESH");
+  }
+
+  load();
+})();

routers/frontier_now_web/index.html

@@ -0,0 +1,179 @@
+<!-- SPDX-License-Identifier: Apache-2.0
+(c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173 -->
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="robots" content="noindex,nofollow">
+  <meta name="color-scheme" content="dark">
+  <title>A11oy Frontier NOW · Estate Proof Surface</title>
+  <link rel="stylesheet" href="/frontier-now/styles.css?v=__STYLE_ASSET_DIGEST__">
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to estate state</a>
+<header class="topbar">
+  <a class="brand" href="/frontier-now" aria-label="A11oy Frontier Now home">
+    <span class="brand-mark" aria-hidden="true">A11</span>
+    <span>A11oy / Frontier NOW</span>
+  </a>
+  <div class="mode-lock" aria-label="Current operating mode">
+    <span class="pulse" aria-hidden="true"></span>
+    <span>OPERATING MODE</span>
+    <strong id="operating-mode">OBSERVE_ONLY</strong>
+    <span aria-hidden="true">·</span>
+    <span id="live-updates" aria-live="polite">UPDATES CONNECTING</span>
+  </div>
+  <button class="quiet-button" id="refresh-view" type="button">Refresh view</button>
+</header>
+
+<main id="main" tabindex="-1">
+  <section class="hero" aria-labelledby="hero-title">
+    <div>
+      <p class="kicker">ONE ESTATE · ONE TRUTH BOUNDARY · ZERO HIDDEN WRITES</p>
+      <h1 id="hero-title">See the whole system.<br><em>Hold what cannot be proved.</em></h1>
+      <p class="hero-copy">A read-only control surface for GitHub, Hugging Face, runtime identity, proof receipts, defensive activation, and clean-room innovation. Every material state carries its evidence boundary.</p>
+    </div>
+    <dl class="identity-card" aria-label="Build and observation identity">
+      <div><dt>Estate observation</dt><dd><span class="status" id="estate-state" data-state="PENDING">PENDING</span></dd></div>
+      <div><dt>Runtime source</dt><dd id="runtime-revision">NOT OBSERVED</dd></div>
+      <div><dt>HF overlay</dt><dd><span class="status" data-state="UNAVAILABLE">UNAVAILABLE</span></dd></div>
+      <div><dt>Claim gate</dt><dd><span class="status" id="claim-state" data-state="FAILED_CLOSED">FAILED_CLOSED</span></dd></div>
+      <div><dt>Observed at</dt><dd id="observed-at">NOT OBSERVED</dd></div>
+    </dl>
+  </section>
+
+  <section class="metric-band" aria-label="Estate counts">
+    <article><span>GitHub repos</span><strong data-count="github_repositories">—</strong><small>latest observed listing</small></article>
+    <article><span>Open pull requests</span><strong data-count="github_open_pull_requests">—</strong><small>queue, not readiness</small></article>
+    <article><span>HF models</span><strong data-count="models">—</strong><small>catalog observations</small></article>
+    <article><span>HF datasets</span><strong data-count="datasets">—</strong><small>catalog observations</small></article>
+    <article><span>HF Spaces</span><strong data-count="spaces">—</strong><small>inventory, not runtime proof</small></article>
+    <article><span>External writes</span><strong>0</strong><small>disabled in this surface</small></article>
+  </section>
+
+  <section class="workspace" aria-label="Frontier control workspace">
+    <nav class="rail" aria-label="Workspace sections">
+      <a href="#command" class="active" aria-current="location">Command</a>
+      <a href="#coverage">Coverage</a>
+      <a href="#parity">Parity</a>
+      <a href="#defense">Defense</a>
+      <a href="#atelier">ATELIER</a>
+      <a href="#proof">Proof rail</a>
+      <a href="/series-a">Series-A authority</a>
+      <a href="/frontier">Frontier manifest</a>
+    </nav>
+
+    <div class="canvas">
+      <section id="command" class="panel command-panel" aria-labelledby="command-title">
+        <div class="panel-head">
+          <div><p class="eyebrow">CURRENT CONTROL POSTURE</p><h2 id="command-title">Evidence before effect</h2></div>
+          <span id="as-of" class="as-of">WAITING FOR OBSERVATION</span>
+        </div>
+        <div class="command-grid">
+          <article class="state-card">
+            <span class="card-index">01</span>
+            <h3>Observe</h3>
+            <p>Read the persisted provider snapshot. Never turn a failed query into a green zero.</p>
+            <span class="status" id="observe-state" data-state="PENDING">PENDING</span>
+          </article>
+          <article class="state-card">
+            <span class="card-index">02</span>
+            <h3>Bind</h3>
+            <p>Link source, HF overlay, runtime artifact, and domain readback only through explicit evidence.</p>
+            <span class="status" data-state="UNAVAILABLE">UNAVAILABLE</span>
+          </article>
+          <article class="state-card">
+            <span class="card-index">03</span>
+            <h3>Authorize</h3>
+            <p>This projection has no POST route, credential, signer, or provider effector.</p>
+            <span class="status" data-state="DISABLED">DISABLED</span>
+          </article>
+          <article class="state-card">
+            <span class="card-index">04</span>
+            <h3>Prove</h3>
+            <p>Show receipt metadata and reported signature status without signing on read or claiming eternal truth.</p>
+            <span class="status" id="proof-state" data-state="PENDING">PENDING</span>
+          </article>
+        </div>
+      </section>
+
+      <section id="coverage" class="panel" aria-labelledby="coverage-title">
+        <div class="panel-head">
+          <div><p class="eyebrow">CAPABILITY-VISIBLE COVERAGE</p><h2 id="coverage-title">Every gap stays in the frame</h2></div>
+          <span class="legend"><i data-state="OBSERVED"></i> observed <i data-state="UNAVAILABLE"></i> unavailable</span>
+        </div>
+        <div class="table-wrap" role="region" aria-labelledby="coverage-title" tabindex="0">
+          <table>
+            <thead><tr><th scope="col">Provider</th><th scope="col">Capability</th><th scope="col">State</th><th scope="col">Count</th><th scope="col">Evidence scope</th></tr></thead>
+            <tbody id="coverage-rows"><tr><td colspan="5">LOADING CAPABILITY RECEIPTS</td></tr></tbody>
+          </table>
+        </div>
+      </section>
+
+      <section id="parity" class="panel" aria-labelledby="parity-title">
+        <div class="panel-head">
+          <div><p class="eyebrow">SOURCE → RUNTIME PROOF GRAPH</p><h2 id="parity-title">No inferred edges</h2></div>
+          <span class="status" data-state="FAILED_CLOSED">CLAIM HELD</span>
+        </div>
+        <div class="proof-graph">
+          <div class="graph-node unavailable" id="runtime-source-node"><span>Runtime-reported source</span><strong id="graph-source">NOT OBSERVED</strong></div>
+          <div class="edge unknown"><span>binding unavailable</span></div>
+          <div class="graph-node unavailable"><span>HF repository overlay</span><strong>UNAVAILABLE</strong></div>
+          <div class="edge unknown"><span>artifact unavailable</span></div>
+          <div class="graph-node unavailable"><span>Domain build identity</span><strong>UNAVAILABLE</strong></div>
+          <div class="edge blocked"><span>claim gate</span></div>
+          <div class="graph-node blocked"><span>Public claim</span><strong>HELD</strong></div>
+        </div>
+        <p class="boundary-note" id="identity-reason">Waiting for identity evidence.</p>
+      </section>
+
+      <section id="defense" class="panel split-panel" aria-labelledby="defense-title">
+        <div>
+          <p class="eyebrow">DEFENSIVE FRONTIER</p>
+          <h2 id="defense-title">Proposal first. Canary before scale.</h2>
+          <p>The public cockpit deliberately exposes no mutation controls. Identity, endpoint, cloud, email, source-chain, data, AI, and recovery coverage remain modeled or unavailable until exact telemetry receipts are bound.</p>
+        </div>
+        <dl class="budget-list">
+          <div><dt>External actions</dt><dd>DISABLED</dd></div>
+          <div><dt>Automatic retries</dt><dd>0</dd></div>
+          <div><dt>Canary target</dt><dd>NOT BOUND</dd></div>
+          <div><dt>Rollback proof</dt><dd>UNAVAILABLE</dd></div>
+          <div><dt>Public mutation contract</dt><dd>FAILED_CLOSED</dd></div>
+        </dl>
+      </section>
+
+      <section id="atelier" class="panel atelier-panel" aria-labelledby="atelier-title">
+        <div class="panel-head">
+          <div><p class="eyebrow">ATELIER · CLEAN-ROOM INNOVATION LINE</p><h2 id="atelier-title">Learn the pattern. Rebuild the expression.</h2></div>
+          <span class="status" data-state="MODELED">MODELED</span>
+        </div>
+        <ol class="atelier-flow">
+          <li><span>01</span><div><strong>Admit lawful sources</strong><p>Record access basis, terms, license, and obligations.</p></div></li>
+          <li><span>02</span><div><strong>Seal an original specification</strong><p>Exclude protected copy, trade dress, and source code.</p></div></li>
+          <li><span>03</span><div><strong>Build independently</strong><p>Use internal design language and approved dependencies.</p></div></li>
+          <li><span>04</span><div><strong>Review the exact artifact</strong><p>Bind revision, digest, obligations, and release surface.</p></div></li>
+        </ol>
+        <p class="boundary-note">No legal clearance is inferred by this modeled workflow. Human review remains a separate recorded decision.</p>
+      </section>
+
+      <section id="proof" class="panel" aria-labelledby="proof-title">
+        <div class="panel-head">
+          <div><p class="eyebrow">PERSISTED RECEIPT METADATA</p><h2 id="proof-title">Proof rail</h2></div>
+          <a class="text-link" href="/api/a11oy/v1/series-a/receipts">Open canonical receipts</a>
+        </div>
+        <ol id="proof-rail" class="proof-list"><li>WAITING FOR PERSISTED RECEIPTS</li></ol>
+      </section>
+
+      <section class="truth-footer" aria-label="Truth boundary">
+        <p><strong>CURRENT OBSERVATION, NOT ETERNAL TRUTH.</strong> Catalog presence is not deployment. HTTP reachability is not authorization. A pushed branch is not merged source. Merged source is not a witnessed runtime.</p>
+        <p id="view-status" aria-live="polite">Loading the persisted estate view.</p>
+      </section>
+    </div>
+  </section>
+</main>
+
+<noscript><p class="noscript">JavaScript is required to read the live estate projection. The canonical JSON remains available at <a href="/api/a11oy/v1/frontier-now/summary">the Frontier Now summary endpoint</a>.</p></noscript>
+<script src="/frontier-now/app.js?v=__APP_ASSET_DIGEST__" defer></script>
+</body>
+</html>

routers/frontier_now_web/styles.css

@@ -0,0 +1,466 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * (c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173
+ */
+:root {
+  color-scheme: dark;
+  --ink: #05070a;
+  --panel: #0d1117;
+  --panel-2: #111820;
+  --line: #2a3542;
+  --muted: #96a2af;
+  --paper: #f3f1ea;
+  --acid: #c9b787;
+  --cyan: #5fb3a3;
+  --amber: #ffc45e;
+  --rose: #ff7272;
+  --violet: #b6a2ff;
+  --radius: 18px;
+  --mono: "SFMono-Regular", Consolas, "Liberation Mono", monospace;
+  --sans: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+* { box-sizing: border-box; }
+
+html {
+  background: var(--ink);
+  scroll-behavior: smooth;
+}
+
+body {
+  margin: 0;
+  min-width: 320px;
+  color: var(--paper);
+  background:
+    radial-gradient(circle at 82% -10%, rgba(95, 179, 163, .1), transparent 32rem),
+    linear-gradient(rgba(255, 255, 255, .018) 1px, transparent 1px),
+    linear-gradient(90deg, rgba(255, 255, 255, .018) 1px, transparent 1px),
+    var(--ink);
+  background-size: auto, 40px 40px, 40px 40px, auto;
+  font-family: var(--sans);
+  line-height: 1.5;
+}
+
+a { color: inherit; }
+
+button, a { -webkit-tap-highlight-color: transparent; }
+
+button:focus-visible,
+a:focus-visible,
+[tabindex]:focus-visible {
+  outline: 3px solid var(--cyan);
+  outline-offset: 4px;
+}
+
+.skip-link {
+  position: fixed;
+  top: .75rem;
+  left: .75rem;
+  z-index: 100;
+  padding: .65rem .9rem;
+  color: var(--ink);
+  background: var(--acid);
+  transform: translateY(-180%);
+  transition: transform .15s ease;
+}
+
+.skip-link:focus { transform: translateY(0); }
+
+.topbar {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: 1rem;
+  min-height: 72px;
+  padding: .75rem clamp(1rem, 4vw, 4.5rem);
+  border-bottom: 1px solid var(--line);
+  background: rgba(5, 7, 10, .92);
+  backdrop-filter: blur(18px);
+}
+
+.brand {
+  display: inline-flex;
+  align-items: center;
+  gap: .8rem;
+  width: fit-content;
+  color: var(--paper);
+  font-weight: 750;
+  letter-spacing: .01em;
+  text-decoration: none;
+}
+
+.brand-mark {
+  display: grid;
+  place-items: center;
+  width: 38px;
+  height: 38px;
+  border: 1px solid var(--acid);
+  border-radius: 10px;
+  color: var(--acid);
+  font: 700 .7rem var(--mono);
+}
+
+.mode-lock {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: .55rem;
+  color: var(--muted);
+  font: 650 .75rem var(--mono);
+  letter-spacing: .09em;
+}
+
+.mode-lock strong { color: var(--acid); }
+
+.pulse {
+  width: .6rem;
+  height: .6rem;
+  border-radius: 50%;
+  background: var(--acid);
+  box-shadow: 0 0 0 .3rem rgba(201, 183, 135, .15);
+}
+
+.quiet-button {
+  min-height: 42px;
+  padding: .6rem .9rem;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  color: var(--paper);
+  background: transparent;
+  font: 650 .75rem var(--mono);
+  cursor: pointer;
+}
+
+.quiet-button:hover { border-color: var(--cyan); color: var(--cyan); }
+.quiet-button:disabled { opacity: .55; cursor: progress; }
+
+main { max-width: 1680px; margin: 0 auto; }
+
+.hero {
+  display: grid;
+  grid-template-columns: minmax(0, 1.25fr) minmax(310px, .75fr);
+  gap: clamp(2rem, 5vw, 6rem);
+  align-items: end;
+  padding: clamp(4rem, 9vw, 8.5rem) clamp(1rem, 4vw, 4.5rem) clamp(3rem, 6vw, 5rem);
+}
+
+.kicker,
+.eyebrow {
+  margin: 0 0 .8rem;
+  color: var(--acid);
+  font: 700 .72rem var(--mono);
+  letter-spacing: .13em;
+}
+
+h1 {
+  max-width: 15ch;
+  margin: 0;
+  font-size: clamp(3rem, 7.8vw, 8.2rem);
+  font-weight: 680;
+  letter-spacing: -.065em;
+  line-height: .88;
+}
+
+h1 em {
+  color: transparent;
+  -webkit-text-stroke: 1px var(--paper);
+  font-style: normal;
+}
+
+.hero-copy {
+  max-width: 68ch;
+  margin: 2rem 0 0;
+  color: #c3cbd4;
+  font-size: clamp(1rem, 1.4vw, 1.25rem);
+}
+
+.identity-card {
+  margin: 0;
+  padding: 1.2rem;
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  background: rgba(13, 17, 23, .82);
+  box-shadow: 0 28px 80px rgba(0, 0, 0, .3);
+}
+
+.identity-card div {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1.3fr);
+  gap: 1rem;
+  align-items: center;
+  min-height: 54px;
+  border-bottom: 1px solid var(--line);
+}
+
+.identity-card div:last-child { border-bottom: 0; }
+.identity-card dt { color: var(--muted); font-size: .82rem; }
+.identity-card dd { margin: 0; overflow-wrap: anywhere; font: 650 .76rem var(--mono); text-align: right; }
+
+.status {
+  display: inline-flex;
+  align-items: center;
+  gap: .4rem;
+  width: fit-content;
+  padding: .28rem .55rem;
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  font: 750 .75rem var(--mono);
+  letter-spacing: .04em;
+}
+
+.status::before {
+  content: "";
+  width: .4rem;
+  height: .4rem;
+  border-radius: 50%;
+  background: currentColor;
+}
+
+.status[data-state="OBSERVED"] { color: var(--acid); }
+.status[data-state="MODELED"] { color: var(--violet); }
+.status[data-state="PENDING"],
+.status[data-state="STALE"] { color: var(--amber); }
+.status[data-state="FAILED_CLOSED"],
+.status[data-state="BLOCKED"] { color: var(--rose); }
+.status[data-state="UNAVAILABLE"],
+.status[data-state="DISABLED"],
+.status[data-state="UNKNOWN"] { color: var(--muted); }
+
+.metric-band {
+  display: grid;
+  grid-template-columns: repeat(6, minmax(0, 1fr));
+  border-block: 1px solid var(--line);
+}
+
+.metric-band article {
+  min-height: 150px;
+  padding: 1.25rem;
+  border-right: 1px solid var(--line);
+}
+
+.metric-band article:last-child { border-right: 0; }
+.metric-band span, .metric-band small { display: block; color: var(--muted); font-size: .72rem; }
+.metric-band strong { display: block; margin: .5rem 0 .2rem; color: var(--paper); font: 650 clamp(2rem, 4vw, 3.7rem) var(--mono); letter-spacing: -.08em; }
+
+.workspace {
+  display: grid;
+  grid-template-columns: 190px minmax(0, 1fr);
+  gap: clamp(1.2rem, 3vw, 3rem);
+  padding: clamp(1.2rem, 3vw, 3rem) clamp(1rem, 4vw, 4.5rem) 5rem;
+}
+
+.rail {
+  position: sticky;
+  top: 96px;
+  align-self: start;
+  display: grid;
+  gap: .2rem;
+}
+
+.rail a {
+  padding: .65rem .8rem;
+  border-left: 2px solid transparent;
+  color: var(--muted);
+  font: 650 .78rem var(--mono);
+  text-decoration: none;
+}
+
+.rail a:hover, .rail a.active { border-left-color: var(--acid); color: var(--paper); background: rgba(201, 183, 135, .055); }
+
+.canvas { min-width: 0; }
+
+.panel {
+  margin: 0 0 1.25rem;
+  padding: clamp(1.2rem, 2.5vw, 2.2rem);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  background: linear-gradient(145deg, rgba(17, 24, 32, .93), rgba(9, 13, 18, .93));
+  scroll-margin-top: 96px;
+}
+
+.panel-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 1.5rem;
+  margin-bottom: 1.6rem;
+}
+
+h2 { margin: 0; font-size: clamp(1.55rem, 3vw, 2.55rem); letter-spacing: -.045em; }
+h3 { margin: .4rem 0 .6rem; font-size: 1.1rem; }
+.as-of, .legend { color: var(--muted); font: .75rem var(--mono); text-align: right; }
+.legend i { display: inline-block; width: .48rem; height: .48rem; margin: 0 .3rem 0 .8rem; border-radius: 50%; background: var(--muted); }
+.legend i[data-state="OBSERVED"] { background: var(--acid); }
+
+.command-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: .75rem;
+}
+
+.state-card {
+  min-height: 230px;
+  padding: 1rem;
+  border: 1px solid var(--line);
+  border-radius: 13px;
+  background: rgba(5, 7, 10, .42);
+}
+
+.state-card p { min-height: 6.5em; color: var(--muted); font-size: .83rem; }
+.card-index { color: var(--cyan); font: .7rem var(--mono); }
+
+.table-wrap { overflow-x: auto; }
+.table-wrap:focus-visible { outline: 3px solid var(--cyan); outline-offset: 4px; }
+table { width: 100%; border-collapse: collapse; font-size: .84rem; }
+th, td { padding: .9rem .75rem; border-bottom: 1px solid var(--line); text-align: left; vertical-align: middle; }
+th { color: var(--muted); font: 650 .68rem var(--mono); letter-spacing: .07em; text-transform: uppercase; }
+td:nth-child(1), td:nth-child(2), td:nth-child(4), td:nth-child(5) { font-family: var(--mono); }
+td:last-child { color: var(--muted); font-size: .72rem; }
+
+.proof-graph {
+  display: grid;
+  grid-template-columns: repeat(7, minmax(80px, 1fr));
+  align-items: center;
+  gap: .6rem;
+}
+
+.graph-node {
+  min-height: 132px;
+  padding: 1rem;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  background: var(--ink);
+}
+
+.graph-node span { display: block; margin-bottom: .7rem; color: var(--muted); font-size: .7rem; }
+.graph-node strong { overflow-wrap: anywhere; font: .73rem var(--mono); }
+.graph-node.observed { border-color: rgba(95, 179, 163, .65); }
+.graph-node.reported { border-color: rgba(201, 183, 135, .7); }
+.graph-node.unavailable { border-color: #596473; }
+.graph-node.blocked { border-color: rgba(255, 114, 114, .7); }
+.edge { position: relative; min-height: 44px; border-top: 1px dashed var(--muted); }
+.edge span { position: absolute; top: .35rem; left: 50%; width: 100%; color: var(--muted); font: .68rem var(--mono); text-align: center; transform: translateX(-50%); }
+.edge.blocked { border-color: var(--rose); }
+
+.boundary-note {
+  margin: 1.4rem 0 0;
+  padding: .85rem 1rem;
+  border-left: 3px solid var(--amber);
+  color: #c9d0d8;
+  background: rgba(255, 196, 94, .05);
+  font: .74rem var(--mono);
+  overflow-wrap: anywhere;
+}
+
+.split-panel { display: grid; grid-template-columns: minmax(0, 1.2fr) minmax(280px, .8fr); gap: 2.5rem; }
+.split-panel p:not(.eyebrow) { max-width: 68ch; color: var(--muted); }
+.budget-list { margin: 0; }
+.budget-list div { display: grid; grid-template-columns: 1fr auto; gap: 1rem; padding: .7rem 0; border-bottom: 1px solid var(--line); }
+.budget-list dt { color: var(--muted); }
+.budget-list dd { margin: 0; font: 700 .72rem var(--mono); }
+
+.atelier-panel { background: linear-gradient(135deg, rgba(21, 13, 31, .9), rgba(9, 13, 18, .93)); }
+.atelier-flow { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: .7rem; margin: 0; padding: 0; list-style: none; counter-reset: none; }
+.atelier-flow li { display: flex; gap: .8rem; min-height: 170px; padding: 1rem; border: 1px solid var(--line); border-radius: 12px; }
+.atelier-flow > li > span { color: var(--violet); font: .72rem var(--mono); }
+.atelier-flow strong { display: block; font-size: .9rem; }
+.atelier-flow p { color: var(--muted); font-size: .78rem; }
+
+.text-link { color: var(--cyan); font: .75rem var(--mono); }
+.proof-list { display: grid; gap: .55rem; margin: 0; padding: 0; list-style: none; }
+.proof-list li { display: grid; grid-template-columns: minmax(110px, .7fr) minmax(190px, 1.6fr) minmax(130px, .8fr) auto; gap: 1rem; padding: .8rem .9rem; border: 1px solid var(--line); border-radius: 10px; font: .75rem var(--mono); }
+.proof-list code { color: var(--cyan); overflow-wrap: anywhere; }
+
+.truth-footer {
+  display: grid;
+  grid-template-columns: minmax(0, 2fr) minmax(220px, .7fr);
+  gap: 2rem;
+  padding: 1.4rem;
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  color: var(--muted);
+  background: #070a0e;
+  font: .72rem var(--mono);
+}
+
+.truth-footer p { margin: 0; }
+.truth-footer strong { color: var(--paper); }
+#view-status { color: var(--acid); text-align: right; }
+
+.noscript {
+  margin: 1rem;
+  padding: 1rem;
+  border: 1px solid var(--amber);
+  color: var(--paper);
+  background: var(--panel);
+}
+
+@media (max-width: 1180px) {
+  .metric-band { grid-template-columns: repeat(3, minmax(0, 1fr)); }
+  .metric-band article:nth-child(3) { border-right: 0; }
+  .metric-band article:nth-child(-n + 3) { border-bottom: 1px solid var(--line); }
+  .command-grid, .atelier-flow { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .proof-graph { grid-template-columns: 1fr; }
+  .edge { min-height: 44px; width: 1px; margin: 0 auto; border-top: 0; border-left: 1px dashed var(--muted); }
+  .edge span { top: 50%; left: 1rem; width: max-content; transform: translateY(-50%); }
+}
+
+@media (max-width: 980px) {
+  .proof-list li { grid-template-columns: 1fr; }
+}
+
+@media (max-width: 820px) {
+  .topbar { grid-template-columns: 1fr auto; }
+  .mode-lock { grid-column: 1 / -1; grid-row: 2; }
+  .hero { grid-template-columns: 1fr; padding-top: 4rem; }
+  h1 { font-size: clamp(3rem, 16vw, 5.6rem); }
+  .workspace { grid-template-columns: 1fr; }
+  .rail { position: static; display: flex; overflow-x: auto; padding-bottom: .5rem; }
+  .rail a { flex: 0 0 auto; border-left: 0; border-bottom: 2px solid transparent; }
+  .rail a:hover, .rail a.active { border-left-color: transparent; border-bottom-color: var(--acid); }
+  .split-panel, .truth-footer { grid-template-columns: 1fr; }
+  #view-status { text-align: left; }
+  .proof-list li { grid-template-columns: 1fr; }
+}
+
+@media (max-width: 560px) {
+  .topbar { padding-inline: .8rem; }
+  .brand span:last-child { display: none; }
+  .quiet-button { padding-inline: .7rem; }
+  .hero { padding-inline: 1rem; }
+  .metric-band { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .metric-band article:nth-child(2n) { border-right: 0; }
+  .metric-band article:nth-child(3) { border-right: 1px solid var(--line); }
+  .metric-band article:nth-child(-n + 4) { border-bottom: 1px solid var(--line); }
+  .command-grid, .atelier-flow { grid-template-columns: 1fr; }
+  .state-card, .atelier-flow li { min-height: auto; }
+  .panel-head { display: grid; }
+  .as-of, .legend { text-align: left; }
+  .identity-card div { grid-template-columns: 1fr; gap: .25rem; padding: .65rem 0; }
+  .identity-card dd { text-align: left; }
+}
+
+@media (forced-colors: active) {
+  h1 em {
+    color: CanvasText;
+    -webkit-text-stroke: 0;
+  }
+
+  .status,
+  .graph-node,
+  .panel,
+  .state-card {
+    forced-color-adjust: auto;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    scroll-behavior: auto !important;
+    transition-duration: .01ms !important;
+    animation-duration: .01ms !important;
+    animation-iteration-count: 1 !important;
+  }
+}

routers/frontier_reads.py

@@ -16,7 +16,9 @@ this group, so it moves here with the routes. Registered BEFORE the /api/a11oy/
 
 The additive Series-A controller is registered at this same pre-catch-all seam. It
 keeps GET/HEAD read-only, uses explicit POSTs for refresh/evaluate/execute, and
-fails one surface closed without taking down the existing frontier reads.
+fails one surface closed without taking down the existing frontier reads. Frontier
+Now is a read-only projection over that controller: no second store, signer,
+credential, scheduler, passport authority, or effector.
 
 Signed-off-by: Stephen P. Lutar Jr. <stephenlutar2@gmail.com>
 """
@@ -101,15 +103,31 @@ def register(app) -> dict:
             "effectors": [],
         }
 
+    try:
+        from routers import frontier_now_control_plane as _frontier_now
+
+        frontier_now = _frontier_now.register(app, ns="a11oy")
+    except Exception as exc:  # one read projection must never take down A11oy
+        frontier_now = {
+            "ok": False,
+            "state": "UNAVAILABLE",
+            "reason": type(exc).__name__,
+            "effectors": [],
+        }
+
     return {
         "ok": True,
         "ns": "a11oy",
         "group": "frontier-reads",
         "series_a": series_a,
+        "frontier_now": frontier_now,
         "routes": [
             "/api/a11oy/v1/forecast-baseline", "/v1/forecast-baseline",
             "/api/a11oy/v1/vertical-packs", "/v1/vertical-packs",
             "/api/a11oy/v1/observability/business", "/v1/observability/business",
             "/series-a", "/api/a11oy/v1/series-a/status",
+            "/frontier-now", "/now",
+            "/api/a11oy/v1/frontier-now/summary",
+            "/api/a11oy/v1/frontier-now/inventory",
         ],
     }